@continuous-excellence/coupling-cli 1.1.685 → 1.1.686

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

@@ -46,12 +46,12 @@ function Companion() {
         var tmp = this;
         // Inline function 'kotlin.byteArrayOf' call
         var tmp$ret$0 = new Int8Array([]);
-        tmp.r4f_1 = new (ByteString())(tmp$ret$0);
+        tmp.k4f_1 = new (ByteString())(tmp$ret$0);
       }
-      s4f(_this__u8e3s4) {
+      l4f(_this__u8e3s4) {
         // Inline function 'okio.internal.commonEncodeUtf8' call
         var byteString = new (ByteString())(asUtf8ToByteArray(_this__u8e3s4));
-        byteString.t4f(_this__u8e3s4);
+        byteString.m4f(_this__u8e3s4);
         return byteString;
       }
     }
@@ -72,28 +72,28 @@ function ByteString() {
     class $ {
       constructor(data) {
         Companion_getInstance();
-        this.f4d_1 = data;
-        this.g4d_1 = 0;
-        this.h4d_1 = null;
+        this.y4c_1 = data;
+        this.z4c_1 = 0;
+        this.a4d_1 = null;
       }
-      u4f(value) {
+      n4f(value) {
       }
-      t4f(value) {
+      m4f(value) {
       }
-      v4f() {
+      o4f() {
         // Inline function 'okio.internal.commonUtf8' call
-        var result = this.h4d_1;
+        var result = this.a4d_1;
         if (result == null) {
-          result = toUtf8String(this.p4e());
-          this.t4f(result);
+          result = toUtf8String(this.i4e());
+          this.m4f(result);
         }
         return result;
       }
-      w4f() {
+      p4f() {
         // Inline function 'okio.internal.commonHex' call
-        var result = charArray(imul(this.f4d_1.length, 2));
+        var result = charArray(imul(this.y4c_1.length, 2));
         var c = 0;
-        var indexedObject = this.f4d_1;
+        var indexedObject = this.y4c_1;
         var inductionVariable = 0;
         var last = indexedObject.length;
         while (inductionVariable < last) {
@@ -112,46 +112,46 @@ function ByteString() {
         }
         return concatToString(result);
       }
-      x4f(pos) {
+      q4f(pos) {
         if (pos >= this.q2() || pos < 0)
-          throw ArrayIndexOutOfBoundsException().o4e('size=' + this.q2() + ' pos=' + pos);
+          throw ArrayIndexOutOfBoundsException().h4e('size=' + this.q2() + ' pos=' + pos);
         // Inline function 'okio.internal.commonGetByte' call
-        return this.f4d_1[pos];
+        return this.y4c_1[pos];
       }
       p2(index) {
-        return this.x4f(index);
+        return this.q4f(index);
       }
       q2() {
-        return this.y4f();
+        return this.r4f();
       }
-      y4f() {
+      r4f() {
         // Inline function 'okio.internal.commonGetSize' call
-        return this.f4d_1.length;
+        return this.y4c_1.length;
       }
-      z4f() {
+      s4f() {
         // Inline function 'okio.internal.commonToByteArray' call
         // Inline function 'kotlin.collections.copyOf' call
         // Inline function 'kotlin.js.asDynamic' call
-        return this.f4d_1.slice();
+        return this.y4c_1.slice();
       }
-      p4e() {
+      i4e() {
         // Inline function 'okio.internal.commonInternalArray' call
-        return this.f4d_1;
+        return this.y4c_1;
       }
-      a4g(buffer, offset, byteCount) {
+      t4f(buffer, offset, byteCount) {
         return commonWrite(this, buffer, offset, byteCount);
       }
-      b4g(offset, other, otherOffset, byteCount) {
+      u4f(offset, other, otherOffset, byteCount) {
         // Inline function 'okio.internal.commonRangeEquals' call
-        return other.c4g(otherOffset, this.f4d_1, offset, byteCount);
+        return other.v4f(otherOffset, this.y4c_1, offset, byteCount);
       }
-      c4g(offset, other, otherOffset, byteCount) {
+      v4f(offset, other, otherOffset, byteCount) {
         // Inline function 'okio.internal.commonRangeEquals' call
-        return offset >= 0 && offset <= (this.f4d_1.length - byteCount | 0) && otherOffset >= 0 && otherOffset <= (other.length - byteCount | 0) && arrayRangeEquals(this.f4d_1, offset, other, otherOffset, byteCount);
+        return offset >= 0 && offset <= (this.y4c_1.length - byteCount | 0) && otherOffset >= 0 && otherOffset <= (other.length - byteCount | 0) && arrayRangeEquals(this.y4c_1, offset, other, otherOffset, byteCount);
       }
-      o4d(prefix) {
+      h4d(prefix) {
         // Inline function 'okio.internal.commonStartsWith' call
-        return this.b4g(0, prefix, 0, prefix.q2());
+        return this.u4f(0, prefix, 0, prefix.q2());
       }
       equals(other) {
         // Inline function 'okio.internal.commonEquals' call
@@ -160,7 +160,7 @@ function ByteString() {
           tmp = true;
         } else {
           if (other instanceof ByteString()) {
-            tmp = (other.q2() === this.f4d_1.length && other.c4g(0, this.f4d_1, 0, this.f4d_1.length));
+            tmp = (other.q2() === this.y4c_1.length && other.v4f(0, this.y4c_1, 0, this.y4c_1.length));
           } else {
             tmp = false;
           }
@@ -171,19 +171,19 @@ function ByteString() {
         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;
           }
           // Inline function 'kotlin.also' call
-          var this_0 = contentHashCode(this.f4d_1);
-          this.u4f(this_0);
+          var this_0 = contentHashCode(this.y4c_1);
+          this.n4f(this_0);
           tmp$ret$0 = this_0;
         }
         return tmp$ret$0;
       }
-      d4g(other) {
+      w4f(other) {
         var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonCompareTo' call
@@ -213,24 +213,24 @@ function ByteString() {
         return tmp$ret$0;
       }
       d(other) {
-        return this.d4g(other instanceof ByteString() ? other : THROW_CCE());
+        return this.w4f(other instanceof ByteString() ? other : THROW_CCE());
       }
       toString() {
         var tmp$ret$0;
         $l$block_1: {
           // Inline function 'okio.internal.commonToString' call
           // Inline function 'kotlin.collections.isEmpty' call
-          if (this.f4d_1.length === 0) {
+          if (this.y4c_1.length === 0) {
             tmp$ret$0 = '[size=0]';
             break $l$block_1;
           }
-          var i = access$codePointIndexToCharIndex$tByteStringKt(this.f4d_1, 64);
+          var i = access$codePointIndexToCharIndex$tByteStringKt(this.y4c_1, 64);
           if (i === -1) {
             var tmp;
-            if (this.f4d_1.length <= 64) {
-              tmp = '[hex=' + this.w4f() + ']';
+            if (this.y4c_1.length <= 64) {
+              tmp = '[hex=' + this.p4f() + ']';
             } else {
-              var tmp_0 = this.f4d_1.length;
+              var tmp_0 = this.y4c_1.length;
               var tmp$ret$2;
               $l$block_0: {
                 // Inline function 'okio.internal.commonSubstring' call
@@ -241,8 +241,8 @@ function ByteString() {
                   throw IllegalArgumentException().m2(toString(message));
                 }
                 // Inline function 'kotlin.require' call
-                if (!(endIndex <= this.f4d_1.length)) {
-                  var message_0 = 'endIndex > length(' + this.f4d_1.length + ')';
+                if (!(endIndex <= this.y4c_1.length)) {
+                  var message_0 = 'endIndex > length(' + this.y4c_1.length + ')';
                   throw IllegalArgumentException().m2(toString(message_0));
                 }
                 var subLen = endIndex - 0 | 0;
@@ -251,22 +251,22 @@ function ByteString() {
                   var message_1 = 'endIndex < beginIndex';
                   throw IllegalArgumentException().m2(toString(message_1));
                 }
-                if (0 === 0 && endIndex === this.f4d_1.length) {
+                if (0 === 0 && endIndex === this.y4c_1.length) {
                   tmp$ret$2 = this;
                   break $l$block_0;
                 }
-                tmp$ret$2 = new (ByteString())(copyOfRange(this.f4d_1, 0, endIndex));
+                tmp$ret$2 = new (ByteString())(copyOfRange(this.y4c_1, 0, endIndex));
               }
-              tmp = '[size=' + tmp_0 + ' hex=' + tmp$ret$2.w4f() + '\u2026]';
+              tmp = '[size=' + tmp_0 + ' hex=' + tmp$ret$2.p4f() + '\u2026]';
             }
             tmp$ret$0 = tmp;
             break $l$block_1;
           }
-          var text = this.v4f();
+          var text = this.o4f();
           var safeText = replace(replace(replace(substring(text, 0, i), '\\', '\\\\'), '\n', '\\n'), '\r', '\\r');
           var tmp_1;
           if (i < text.length) {
-            tmp_1 = '[size=' + this.f4d_1.length + ' text=' + safeText + '\u2026]';
+            tmp_1 = '[size=' + this.y4c_1.length + ' text=' + safeText + '\u2026]';
           } else {
             tmp_1 = '[text=' + safeText + ']';
           }

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

@@ -23,7 +23,7 @@ var CompanionClass;
 function Companion() {
   if (CompanionClass === VOID) {
     class $ {
-      r4h(sink) {
+      k4h(sink) {
         return new (HashingSink())(sink, new (Sha256())());
       }
     }
@@ -41,37 +41,37 @@ function HashingSink() {
   if (HashingSinkClass === VOID) {
     class $ {
       constructor(sink, hashFunction) {
-        this.s4h_1 = sink;
-        this.t4h_1 = hashFunction;
+        this.l4h_1 = sink;
+        this.m4h_1 = hashFunction;
       }
-      c4d(source, byteCount) {
-        checkOffsetAndCount(source.e4d_1, new (Long())(0, 0), byteCount);
+      v4c(source, byteCount) {
+        checkOffsetAndCount(source.x4c_1, new (Long())(0, 0), byteCount);
         var hashedCount = new (Long())(0, 0);
-        var s = ensureNotNull(source.d4d_1);
+        var s = ensureNotNull(source.w4c_1);
         while (compare(hashedCount, byteCount) < 0) {
           var tmp0 = subtract(byteCount, hashedCount);
           // Inline function 'okio.minOf' call
-          var b = s.u4d_1 - s.t4d_1 | 0;
+          var b = s.n4d_1 - s.m4d_1 | 0;
           // Inline function 'kotlin.comparisons.minOf' call
           var b_0 = fromInt(b);
           var tmp$ret$0 = compare(tmp0, b_0) <= 0 ? tmp0 : b_0;
           var toHash = convertToInt(tmp$ret$0);
-          this.t4h_1.p4f(s.s4d_1, s.t4d_1, toHash);
+          this.m4h_1.i4f(s.l4d_1, s.m4d_1, toHash);
           // Inline function 'kotlin.Long.plus' call
           var this_0 = hashedCount;
           hashedCount = add(this_0, fromInt(toHash));
-          s = ensureNotNull(s.x4d_1);
+          s = ensureNotNull(s.q4d_1);
         }
-        this.s4h_1.c4d(source, byteCount);
+        this.l4h_1.v4c(source, byteCount);
       }
       vc() {
-        return this.s4h_1.vc();
+        return this.l4h_1.vc();
       }
       j6() {
-        return this.s4h_1.j6();
+        return this.l4h_1.j6();
       }
-      u4h() {
-        var result = this.t4h_1.q4f();
+      n4h() {
+        var result = this.m4h_1.j4f();
         return new (ByteString())(result);
       }
     }

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

@@ -18,21 +18,21 @@ function IOException() {
   if (IOExceptionClass === VOID) {
     class $ extends Exception() {
       constructor(message, cause) {
-        return new.target.x4h(message, cause);
+        return new.target.q4h(message, cause);
       }
-      static x4h(message, cause) {
+      static q4h(message, cause) {
         var $this = this.ce(message, cause);
-        captureStack($this, $this.w4h_1);
+        captureStack($this, $this.p4h_1);
         return $this;
       }
-      static y4h(message) {
-        return this.x4h(message, null);
+      static r4h(message) {
+        return this.q4h(message, null);
       }
-      static z4h() {
-        return this.x4h(null, null);
+      static s4h() {
+        return this.q4h(null, null);
       }
     }
-    initMetadataForClass($, 'IOException', $.z4h);
+    initMetadataForClass($, 'IOException', $.s4h);
     IOExceptionClass = $;
   }
   return IOExceptionClass;
@@ -45,11 +45,11 @@ function ArrayIndexOutOfBoundsException() {
   if (ArrayIndexOutOfBoundsExceptionClass === VOID) {
     class $ extends IndexOutOfBoundsException() {
       constructor(message) {
-        return new.target.o4e(message);
+        return new.target.h4e(message);
       }
-      static o4e(message) {
+      static h4e(message) {
         var $this = this.ie(message);
-        captureStack($this, $this.n4e_1);
+        captureStack($this, $this.g4e_1);
         return $this;
       }
     }
@@ -63,18 +63,18 @@ function EOFException() {
   if (EOFExceptionClass === VOID) {
     class $ extends IOException() {
       constructor(message) {
-        return new.target.o4g(message);
+        return new.target.h4g(message);
       }
-      static o4g(message) {
-        var $this = this.y4h(message);
-        captureStack($this, $this.n4g_1);
+      static h4g(message) {
+        var $this = this.r4h(message);
+        captureStack($this, $this.g4g_1);
         return $this;
       }
-      static r4g() {
-        return this.o4g(null);
+      static k4g() {
+        return this.h4g(null);
       }
     }
-    initMetadataForClass($, 'EOFException', $.r4g);
+    initMetadataForClass($, 'EOFException', $.k4g);
     EOFExceptionClass = $;
   }
   return EOFExceptionClass;

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

@@ -19,7 +19,7 @@ var BlackholeSinkClass;
 function BlackholeSink() {
   if (BlackholeSinkClass === VOID) {
     class $ {
-      c4d(source, byteCount) {
+      v4c(source, byteCount) {
         return source.f1q(byteCount);
       }
       vc() {

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

@@ -79,8 +79,8 @@ function buildTrieRecursive($this, nodeOffset, node, byteStringOffset, byteStrin
     // Inline function 'kotlin.Long.plus' call
     var other = imul(selectChoiceCount, 2);
     var childNodesOffset = add(tmp0, fromInt(other));
-    node.i4d(selectChoiceCount);
-    node.i4d(prefixIndex);
+    node.b4d(selectChoiceCount);
+    node.b4d(prefixIndex);
     var inductionVariable_1 = fromIndex_0;
     if (inductionVariable_1 < toIndex)
       do {
@@ -90,7 +90,7 @@ function buildTrieRecursive($this, nodeOffset, node, byteStringOffset, byteStrin
         if (i_1 === fromIndex_0 || !(rangeByte === byteStrings.p2(i_1 - 1 | 0).p2(byteStringOffset))) {
           // Inline function 'okio.and' call
           var tmp$ret$8 = rangeByte & 255;
-          node.i4d(tmp$ret$8);
+          node.b4d(tmp$ret$8);
         }
       }
        while (inductionVariable_1 < toIndex);
@@ -111,14 +111,14 @@ function buildTrieRecursive($this, nodeOffset, node, byteStringOffset, byteStrin
         }
          while (inductionVariable_2 < toIndex);
       if ((rangeStart + 1 | 0) === rangeEnd && (byteStringOffset + 1 | 0) === byteStrings.p2(rangeStart).q2()) {
-        node.i4d(indexes.p2(rangeStart));
+        node.b4d(indexes.p2(rangeStart));
       } else {
-        node.i4d(imul(-1, convertToInt(add(childNodesOffset, _get_intCount__gol563($this, childNodes)))));
+        node.b4d(imul(-1, convertToInt(add(childNodesOffset, _get_intCount__gol563($this, childNodes)))));
         buildTrieRecursive($this, childNodesOffset, childNodes, byteStringOffset + 1 | 0, byteStrings, rangeStart, rangeEnd, indexes);
       }
       rangeStart = rangeEnd;
     }
-    node.j4d(childNodes);
+    node.c4d(childNodes);
   } else {
     var scanByteCount = 0;
     var inductionVariable_3 = byteStringOffset;
@@ -145,8 +145,8 @@ function buildTrieRecursive($this, nodeOffset, node, byteStringOffset, byteStrin
     // Inline function 'kotlin.Long.plus' call
     var this_2 = add(tmp0_1, fromInt(other_0));
     var childNodesOffset_0 = add(this_2, fromInt(1));
-    node.i4d(-scanByteCount | 0);
-    node.i4d(prefixIndex);
+    node.b4d(-scanByteCount | 0);
+    node.b4d(prefixIndex);
     var inductionVariable_4 = byteStringOffset;
     var last_0 = byteStringOffset + scanByteCount | 0;
     if (inductionVariable_4 < last_0)
@@ -155,7 +155,7 @@ function buildTrieRecursive($this, nodeOffset, node, byteStringOffset, byteStrin
         inductionVariable_4 = inductionVariable_4 + 1 | 0;
         // Inline function 'okio.and' call
         var tmp$ret$13 = from.p2(i_4) & 255;
-        node.i4d(tmp$ret$13);
+        node.b4d(tmp$ret$13);
       }
        while (inductionVariable_4 < last_0);
     if ((fromIndex_0 + 1 | 0) === toIndex) {
@@ -163,25 +163,25 @@ function buildTrieRecursive($this, nodeOffset, node, byteStringOffset, byteStrin
       if (!((byteStringOffset + scanByteCount | 0) === byteStrings.p2(fromIndex_0).q2())) {
         throw IllegalStateException().o('Check failed.');
       }
-      node.i4d(indexes.p2(fromIndex_0));
+      node.b4d(indexes.p2(fromIndex_0));
     } else {
       var childNodes_0 = new (Buffer())();
-      node.i4d(imul(-1, convertToInt(add(childNodesOffset_0, _get_intCount__gol563($this, childNodes_0)))));
+      node.b4d(imul(-1, convertToInt(add(childNodesOffset_0, _get_intCount__gol563($this, childNodes_0)))));
       buildTrieRecursive($this, childNodesOffset_0, childNodes_0, byteStringOffset + scanByteCount | 0, byteStrings, fromIndex_0, toIndex, indexes);
-      node.j4d(childNodes_0);
+      node.c4d(childNodes_0);
     }
   }
 }
 function _get_intCount__gol563($this, $receiver) {
   // Inline function 'kotlin.Long.div' call
-  var this_0 = $receiver.e4d_1;
+  var this_0 = $receiver.x4c_1;
   return divide(this_0, fromInt(4));
 }
 var CompanionClass;
 function Companion() {
   if (CompanionClass === VOID) {
     class $ {
-      k4d(byteStrings) {
+      d4d(byteStrings) {
         // Inline function 'kotlin.collections.isEmpty' call
         if (byteStrings.length === 0) {
           // Inline function 'kotlin.arrayOf' call
@@ -190,7 +190,7 @@ function Companion() {
           var tmp = [];
           // Inline function 'kotlin.intArrayOf' call
           var tmp$ret$4 = new Int32Array([0, -1]);
-          return Options().n4d(tmp, tmp$ret$4);
+          return Options().g4d(tmp, tmp$ret$4);
         }
         var list = toMutableList(byteStrings);
         sort(list);
@@ -230,7 +230,7 @@ function Companion() {
           var b = a + 1 | 0;
           $l$loop: while (b < list.q2()) {
             var byteString = list.p2(b);
-            if (!byteString.o4d(prefix))
+            if (!byteString.h4d(prefix))
               break $l$loop;
             // Inline function 'kotlin.require' call
             if (!!(byteString.q2() === prefix.q2())) {
@@ -252,14 +252,14 @@ function Companion() {
         var tmp_1 = convertToInt(_get_intCount__gol563(this, trieBytes));
         var tmp_2 = new Int32Array(tmp_1);
         while (tmp_0 < tmp_1) {
-          tmp_2[tmp_0] = trieBytes.p4d();
+          tmp_2[tmp_0] = trieBytes.i4d();
           tmp_0 = tmp_0 + 1 | 0;
         }
         var trie = tmp_2;
         // Inline function 'kotlin.collections.copyOf' call
         // Inline function 'kotlin.js.asDynamic' call
         var tmp$ret$16 = byteStrings.slice();
-        return Options().n4d(tmp$ret$16, trie);
+        return Options().g4d(tmp$ret$16, trie);
       }
     }
     initMetadataForCompanion($);
@@ -276,19 +276,19 @@ function Options() {
   if (OptionsClass === VOID) {
     class $ extends AbstractList() {
       constructor(byteStrings, trie) {
-        return new.target.n4d(byteStrings, trie);
+        return new.target.g4d(byteStrings, trie);
       }
-      static n4d(byteStrings, trie) {
+      static g4d(byteStrings, trie) {
         var $this = this.si();
-        $this.l4d_1 = byteStrings;
-        $this.m4d_1 = trie;
+        $this.e4d_1 = byteStrings;
+        $this.f4d_1 = trie;
         return $this;
       }
       q2() {
-        return this.l4d_1.length;
+        return this.e4d_1.length;
       }
       p2(index) {
-        return this.l4d_1[index];
+        return this.e4d_1[index];
       }
     }
     initMetadataForClass($, 'Options', VOID, VOID, [RandomAccess()]);

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

@@ -15,99 +15,99 @@ function RealBufferedSink() {
   if (RealBufferedSinkClass === VOID) {
     class $ {
       constructor(sink) {
-        this.a4i_1 = sink;
-        this.b4i_1 = false;
-        this.c4i_1 = new (Buffer())();
+        this.t4h_1 = sink;
+        this.u4h_1 = false;
+        this.v4h_1 = new (Buffer())();
       }
-      c4d(source, byteCount) {
+      v4c(source, byteCount) {
         // Inline function 'okio.internal.commonWrite' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        this.c4i_1.c4d(source, byteCount);
-        this.d4i();
+        this.v4h_1.v4c(source, byteCount);
+        this.w4h();
         return Unit_instance;
       }
-      e4h(byteString) {
+      x4g(byteString) {
         // Inline function 'okio.internal.commonWrite' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        this.c4i_1.e4h(byteString);
-        return this.d4i();
+        this.v4h_1.x4g(byteString);
+        return this.w4h();
       }
-      g4h(string) {
+      z4g(string) {
         // Inline function 'okio.internal.commonWriteUtf8' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        this.c4i_1.g4h(string);
-        return this.d4i();
+        this.v4h_1.z4g(string);
+        return this.w4h();
       }
-      h4h(string, beginIndex, endIndex) {
+      a4h(string, beginIndex, endIndex) {
         // Inline function 'okio.internal.commonWriteUtf8' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        this.c4i_1.h4h(string, beginIndex, endIndex);
-        return this.d4i();
+        this.v4h_1.a4h(string, beginIndex, endIndex);
+        return this.w4h();
       }
-      i4h(b) {
+      b4h(b) {
         // Inline function 'okio.internal.commonWriteByte' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        this.c4i_1.i4h(b);
-        return this.d4i();
+        this.v4h_1.b4h(b);
+        return this.w4h();
       }
-      d4i() {
+      w4h() {
         // Inline function 'okio.internal.commonEmitCompleteSegments' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        var byteCount = this.c4i_1.q4g();
+        var byteCount = this.v4h_1.j4g();
         if (compare(byteCount, new (Long())(0, 0)) > 0) {
-          this.a4i_1.c4d(this.c4i_1, byteCount);
+          this.t4h_1.v4c(this.v4h_1, byteCount);
         }
         return this;
       }
       vc() {
         // Inline function 'okio.internal.commonFlush' call
         // Inline function 'kotlin.check' call
-        if (!!this.b4i_1) {
+        if (!!this.u4h_1) {
           var message = 'closed';
           throw IllegalStateException().o(toString(message));
         }
-        if (compare(this.c4i_1.e4d_1, new (Long())(0, 0)) > 0) {
-          this.a4i_1.c4d(this.c4i_1, this.c4i_1.e4d_1);
+        if (compare(this.v4h_1.x4c_1, new (Long())(0, 0)) > 0) {
+          this.t4h_1.v4c(this.v4h_1, this.v4h_1.x4c_1);
         }
-        this.a4i_1.vc();
+        this.t4h_1.vc();
         return Unit_instance;
       }
       j6() {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonClose' call
-          if (this.b4i_1) {
+          if (this.u4h_1) {
             tmp$ret$0 = Unit_instance;
             break $l$block;
           }
           var thrown = null;
           try {
-            if (compare(this.c4i_1.e4d_1, new (Long())(0, 0)) > 0) {
-              this.a4i_1.c4d(this.c4i_1, this.c4i_1.e4d_1);
+            if (compare(this.v4h_1.x4c_1, new (Long())(0, 0)) > 0) {
+              this.t4h_1.v4c(this.v4h_1, this.v4h_1.x4c_1);
             }
           } catch ($p) {
             if ($p instanceof Error) {
@@ -118,7 +118,7 @@ function RealBufferedSink() {
             }
           }
           try {
-            this.a4i_1.j6();
+            this.t4h_1.j6();
           } catch ($p_0) {
             if ($p_0 instanceof Error) {
               var e_0 = $p_0;
@@ -128,7 +128,7 @@ function RealBufferedSink() {
               throw $p_0;
             }
           }
-          this.b4i_1 = true;
+          this.u4h_1 = true;
           if (!(thrown == null))
             throw thrown;
           tmp$ret$0 = Unit_instance;
@@ -137,7 +137,7 @@ function RealBufferedSink() {
       }
       toString() {
         // Inline function 'okio.internal.commonToString' call
-        return 'buffer(' + toString(this.a4i_1) + ')';
+        return 'buffer(' + toString(this.t4h_1) + ')';
       }
     }
     initMetadataForClass($, 'RealBufferedSink');