@continuous-excellence/coupling-cli 1.1.415 → 1.1.417

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs

@@ -47,37 +47,37 @@ var imul = Math.imul;
 //region block: pre-declaration
 //endregion
 function throwEof($this, byteCount) {
-  throw EOFException().e1o("Buffer doesn't contain required number of bytes (size: " + $this.v2().toString() + ', required: ' + byteCount.toString() + ')');
+  throw EOFException().f1o("Buffer doesn't contain required number of bytes (size: " + $this.v2().toString() + ', required: ' + byteCount.toString() + ')');
 }
 var BufferClass;
 function Buffer() {
   if (BufferClass === VOID) {
     class $ {
       constructor() {
-        this.y1n_1 = null;
         this.z1n_1 = null;
-        this.a1o_1 = new (Long())(0, 0);
+        this.a1o_1 = null;
+        this.b1o_1 = new (Long())(0, 0);
       }
       v2() {
-        return this.a1o_1;
+        return this.b1o_1;
       }
-      f1o() {
+      g1o() {
         return this;
       }
-      g1o() {
+      h1o() {
         return equalsLong(this.v2(), new (Long())(0, 0));
       }
-      h1o(byteCount) {
+      i1o(byteCount) {
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0)) {
           var message = 'byteCount: ' + byteCount.toString();
           throw IllegalArgumentException().r2(toString(message));
         }
         if (compare(this.v2(), byteCount) < 0) {
-          throw EOFException().e1o("Buffer doesn't contain required number of bytes (size: " + this.v2().toString() + ', required: ' + byteCount.toString() + ')');
+          throw EOFException().f1o("Buffer doesn't contain required number of bytes (size: " + this.v2().toString() + ', required: ' + byteCount.toString() + ')');
         }
       }
-      i1o(byteCount) {
+      j1o(byteCount) {
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0)) {
           var message = 'byteCount: ' + byteCount.toString() + ' < 0';
@@ -85,8 +85,8 @@ function Buffer() {
         }
         return compare(this.v2(), byteCount) >= 0;
       }
-      j1o() {
-        var tmp0_elvis_lhs = this.y1n_1;
+      k1o() {
+        var tmp0_elvis_lhs = this.z1n_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           throwEof(this, new (Long())(1, 0));
@@ -96,18 +96,18 @@ function Buffer() {
         var segment = tmp;
         var segmentSize = segment.v2();
         if (segmentSize === 0) {
-          this.r1o();
-          return this.j1o();
+          this.s1o();
+          return this.k1o();
         }
-        var v = segment.s1o();
-        this.a1o_1 = subtract(this.a1o_1, new (Long())(1, 0));
+        var v = segment.t1o();
+        this.b1o_1 = subtract(this.b1o_1, new (Long())(1, 0));
         if (segmentSize === 1) {
-          this.r1o();
+          this.s1o();
         }
         return v;
       }
-      t1o() {
-        var tmp0_elvis_lhs = this.y1n_1;
+      u1o() {
+        var tmp0_elvis_lhs = this.z1n_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           throwEof(this, new (Long())(2, 0));
@@ -117,120 +117,120 @@ function Buffer() {
         var segment = tmp;
         var segmentSize = segment.v2();
         if (segmentSize < 2) {
-          this.h1o(new (Long())(2, 0));
+          this.i1o(new (Long())(2, 0));
           if (segmentSize === 0) {
-            this.r1o();
-            return this.t1o();
+            this.s1o();
+            return this.u1o();
           }
           // Inline function 'kotlinx.io.and' call
-          var tmp_0 = (this.j1o() & 255) << 8;
+          var tmp_0 = (this.k1o() & 255) << 8;
           // Inline function 'kotlinx.io.and' call
-          var tmp$ret$1 = this.j1o() & 255;
+          var tmp$ret$1 = this.k1o() & 255;
           return toShort(tmp_0 | tmp$ret$1);
         }
-        var v = segment.u1o();
-        this.a1o_1 = subtract(this.a1o_1, new (Long())(2, 0));
+        var v = segment.v1o();
+        this.b1o_1 = subtract(this.b1o_1, new (Long())(2, 0));
         if (segmentSize === 2) {
-          this.r1o();
+          this.s1o();
         }
         return v;
       }
-      v1o() {
+      w1o() {
         return Unit_instance;
       }
-      w1o(out, startIndex, endIndex) {
+      x1o(out, startIndex, endIndex) {
         checkBounds(this.v2(), startIndex, endIndex);
         if (equalsLong(startIndex, endIndex))
           return Unit_instance;
         var currentOffset = startIndex;
         var remainingByteCount = subtract(endIndex, startIndex);
-        out.a1o_1 = add(out.a1o_1, remainingByteCount);
-        var s = this.y1n_1;
-        while (compare(currentOffset, fromInt(ensureNotNull(s).m1o_1 - s.l1o_1 | 0)) >= 0) {
-          currentOffset = subtract(currentOffset, fromInt(s.m1o_1 - s.l1o_1 | 0));
-          s = s.p1o_1;
+        out.b1o_1 = add(out.b1o_1, remainingByteCount);
+        var s = this.z1n_1;
+        while (compare(currentOffset, fromInt(ensureNotNull(s).n1o_1 - s.m1o_1 | 0)) >= 0) {
+          currentOffset = subtract(currentOffset, fromInt(s.n1o_1 - s.m1o_1 | 0));
+          s = s.q1o_1;
         }
         while (compare(remainingByteCount, new (Long())(0, 0)) > 0) {
-          var copy = ensureNotNull(s).x1o();
-          copy.l1o_1 = copy.l1o_1 + convertToInt(currentOffset) | 0;
+          var copy = ensureNotNull(s).y1o();
+          copy.m1o_1 = copy.m1o_1 + convertToInt(currentOffset) | 0;
           var tmp = copy;
-          var tmp0 = copy.l1o_1 + convertToInt(remainingByteCount) | 0;
+          var tmp0 = copy.m1o_1 + convertToInt(remainingByteCount) | 0;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = copy.m1o_1;
-          tmp.m1o_1 = Math.min(tmp0, b);
+          var b = copy.n1o_1;
+          tmp.n1o_1 = Math.min(tmp0, b);
           // Inline function 'kotlinx.io.Buffer.pushSegment' call
-          if (out.y1n_1 == null) {
-            out.y1n_1 = copy;
+          if (out.z1n_1 == null) {
             out.z1n_1 = copy;
+            out.a1o_1 = copy;
           } else if (false) {
-            out.z1n_1 = ensureNotNull(out.z1n_1).y1o(copy).z1o();
-            if (ensureNotNull(out.z1n_1).q1o_1 == null) {
-              out.y1n_1 = out.z1n_1;
+            out.a1o_1 = ensureNotNull(out.a1o_1).z1o(copy).a1p();
+            if (ensureNotNull(out.a1o_1).r1o_1 == null) {
+              out.z1n_1 = out.a1o_1;
             }
           } else {
-            out.z1n_1 = ensureNotNull(out.z1n_1).y1o(copy);
+            out.a1o_1 = ensureNotNull(out.a1o_1).z1o(copy);
           }
-          remainingByteCount = subtract(remainingByteCount, fromInt(copy.m1o_1 - copy.l1o_1 | 0));
+          remainingByteCount = subtract(remainingByteCount, fromInt(copy.n1o_1 - copy.m1o_1 | 0));
           currentOffset = new (Long())(0, 0);
-          s = s.p1o_1;
+          s = s.q1o_1;
         }
       }
-      a1p() {
+      b1p() {
         var result = this.v2();
         if (equalsLong(result, new (Long())(0, 0)))
           return new (Long())(0, 0);
-        var tail = ensureNotNull(this.z1n_1);
-        if (tail.m1o_1 < 8192 && tail.o1o_1) {
-          result = subtract(result, fromInt(tail.m1o_1 - tail.l1o_1 | 0));
+        var tail = ensureNotNull(this.a1o_1);
+        if (tail.n1o_1 < 8192 && tail.p1o_1) {
+          result = subtract(result, fromInt(tail.n1o_1 - tail.m1o_1 | 0));
         }
         return result;
       }
-      b1p(position) {
+      c1p(position) {
         if (compare(position, new (Long())(0, 0)) < 0 || compare(position, this.v2()) >= 0) {
           throw IndexOutOfBoundsException().qe('position (' + position.toString() + ') is not within the range [0..size(' + this.v2().toString() + '))');
         }
         if (equalsLong(position, new (Long())(0, 0))) {
-          return ensureNotNull(this.y1n_1).c1p(0);
+          return ensureNotNull(this.z1n_1).d1p(0);
         }
         // Inline function 'kotlinx.io.seek' call
-        if (this.y1n_1 == null) {
+        if (this.z1n_1 == null) {
           var offset = new (Long())(-1, -1);
-          return ensureNotNull(null).c1p(convertToInt(subtract(position, offset)));
+          return ensureNotNull(null).d1p(convertToInt(subtract(position, offset)));
         }
         if (compare(subtract(this.v2(), position), position) < 0) {
-          var s = this.z1n_1;
+          var s = this.a1o_1;
           var offset_0 = this.v2();
           $l$loop: while (!(s == null) && compare(offset_0, position) > 0) {
-            offset_0 = subtract(offset_0, fromInt(s.m1o_1 - s.l1o_1 | 0));
+            offset_0 = subtract(offset_0, fromInt(s.n1o_1 - s.m1o_1 | 0));
             if (compare(offset_0, position) <= 0)
               break $l$loop;
-            s = s.q1o_1;
+            s = s.r1o_1;
           }
           var tmp0 = s;
           var offset_1 = offset_0;
-          return ensureNotNull(tmp0).c1p(convertToInt(subtract(position, offset_1)));
+          return ensureNotNull(tmp0).d1p(convertToInt(subtract(position, offset_1)));
         } else {
-          var s_0 = this.y1n_1;
+          var s_0 = this.z1n_1;
           var offset_2 = new (Long())(0, 0);
           $l$loop_0: while (!(s_0 == null)) {
             var tmp0_0 = offset_2;
             // Inline function 'kotlin.Long.plus' call
-            var other = s_0.m1o_1 - s_0.l1o_1 | 0;
+            var other = s_0.n1o_1 - s_0.m1o_1 | 0;
             var nextOffset = add(tmp0_0, fromInt(other));
             if (compare(nextOffset, position) > 0)
               break $l$loop_0;
-            s_0 = s_0.p1o_1;
+            s_0 = s_0.q1o_1;
             offset_2 = nextOffset;
           }
           var tmp0_1 = s_0;
           var offset_3 = offset_2;
-          return ensureNotNull(tmp0_1).c1p(convertToInt(subtract(position, offset_3)));
+          return ensureNotNull(tmp0_1).d1p(convertToInt(subtract(position, offset_3)));
         }
       }
       r4() {
-        return this.d1p(this.v2());
+        return this.e1p(this.v2());
       }
-      d1p(byteCount) {
+      e1p(byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0)) {
@@ -239,34 +239,34 @@ function Buffer() {
         }
         var remainingByteCount = byteCount;
         while (compare(remainingByteCount, new (Long())(0, 0)) > 0) {
-          var tmp0_elvis_lhs = this.y1n_1;
+          var tmp0_elvis_lhs = this.z1n_1;
           var tmp;
           if (tmp0_elvis_lhs == null) {
-            throw EOFException().e1o('Buffer exhausted before skipping ' + byteCount.toString() + ' bytes.');
+            throw EOFException().f1o('Buffer exhausted before skipping ' + byteCount.toString() + ' bytes.');
           } else {
             tmp = tmp0_elvis_lhs;
           }
           var head = tmp;
           var tmp0 = remainingByteCount;
           // Inline function 'kotlinx.io.minOf' call
-          var b = head.m1o_1 - head.l1o_1 | 0;
+          var b = head.n1o_1 - head.m1o_1 | 0;
           // Inline function 'kotlin.comparisons.minOf' call
           var b_0 = fromInt(b);
           var tmp$ret$4 = compare(tmp0, b_0) <= 0 ? tmp0 : b_0;
           var toSkip = convertToInt(tmp$ret$4);
-          this.a1o_1 = subtract(this.a1o_1, fromInt(toSkip));
+          this.b1o_1 = subtract(this.b1o_1, fromInt(toSkip));
           remainingByteCount = subtract(remainingByteCount, fromInt(toSkip));
-          head.l1o_1 = head.l1o_1 + toSkip | 0;
-          if (head.l1o_1 === head.m1o_1) {
-            this.r1o();
+          head.m1o_1 = head.m1o_1 + toSkip | 0;
+          if (head.m1o_1 === head.n1o_1) {
+            this.s1o();
           }
         }
       }
-      e1p(sink, startIndex, endIndex) {
+      f1p(sink, startIndex, endIndex) {
         // Inline function 'kotlinx.io.checkBounds' call
         var size = sink.length;
         checkBounds(fromInt(size), fromInt(startIndex), fromInt(endIndex));
-        var tmp0_elvis_lhs = this.y1n_1;
+        var tmp0_elvis_lhs = this.z1n_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           return -1;
@@ -278,14 +278,14 @@ function Buffer() {
         // Inline function 'kotlin.comparisons.minOf' call
         var b = s.v2();
         var toCopy = Math.min(tmp0, b);
-        s.f1p(sink, startIndex, startIndex + toCopy | 0);
-        this.a1o_1 = subtract(this.a1o_1, fromInt(toCopy));
+        s.g1p(sink, startIndex, startIndex + toCopy | 0);
+        this.b1o_1 = subtract(this.b1o_1, fromInt(toCopy));
         if (isEmpty(s)) {
-          this.r1o();
+          this.s1o();
         }
         return toCopy;
       }
-      g1p(sink, byteCount) {
+      h1p(sink, byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0)) {
@@ -295,10 +295,10 @@ function Buffer() {
         if (equalsLong(this.v2(), new (Long())(0, 0)))
           return new (Long())(-1, -1);
         var bytesWritten = compare(byteCount, this.v2()) > 0 ? this.v2() : byteCount;
-        sink.h1p(this, bytesWritten);
+        sink.i1p(this, bytesWritten);
         return bytesWritten;
       }
-      i1p(sink, byteCount) {
+      j1p(sink, byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0)) {
@@ -306,62 +306,62 @@ function Buffer() {
           throw IllegalArgumentException().r2(toString(message));
         }
         if (compare(this.v2(), byteCount) < 0) {
-          sink.h1p(this, this.v2());
-          throw EOFException().e1o('Buffer exhausted before writing ' + byteCount.toString() + ' bytes. Only ' + this.v2().toString() + ' bytes were written.');
+          sink.i1p(this, this.v2());
+          throw EOFException().f1o('Buffer exhausted before writing ' + byteCount.toString() + ' bytes. Only ' + this.v2().toString() + ' bytes were written.');
         }
-        sink.h1p(this, byteCount);
+        sink.i1p(this, byteCount);
       }
-      j1p(sink) {
+      k1p(sink) {
         var byteCount = this.v2();
         if (compare(byteCount, new (Long())(0, 0)) > 0) {
-          sink.h1p(this, byteCount);
+          sink.i1p(this, byteCount);
         }
         return byteCount;
       }
-      k1p() {
+      l1p() {
         return buffered(new (PeekSource())(this));
       }
-      l1p(minimumCapacity) {
+      m1p(minimumCapacity) {
         // Inline function 'kotlin.require' call
         if (!(minimumCapacity >= 1 && minimumCapacity <= 8192)) {
           var message = 'unexpected capacity (' + minimumCapacity + '), should be in range [1, 8192]';
           throw IllegalArgumentException().r2(toString(message));
         }
-        if (this.z1n_1 == null) {
-          var result = SegmentPool_instance.o1p();
-          this.y1n_1 = result;
+        if (this.a1o_1 == null) {
+          var result = SegmentPool_instance.p1p();
           this.z1n_1 = result;
+          this.a1o_1 = result;
           return result;
         }
-        var t = ensureNotNull(this.z1n_1);
-        if ((t.m1o_1 + minimumCapacity | 0) > 8192 || !t.o1o_1) {
-          var newTail = t.y1o(SegmentPool_instance.o1p());
-          this.z1n_1 = newTail;
+        var t = ensureNotNull(this.a1o_1);
+        if ((t.n1o_1 + minimumCapacity | 0) > 8192 || !t.p1o_1) {
+          var newTail = t.z1o(SegmentPool_instance.p1p());
+          this.a1o_1 = newTail;
           return newTail;
         }
         return t;
       }
-      p1p(source, startIndex, endIndex) {
+      q1p(source, startIndex, endIndex) {
         // Inline function 'kotlinx.io.checkBounds' call
         var size = source.length;
         checkBounds(fromInt(size), fromInt(startIndex), fromInt(endIndex));
         var currentOffset = startIndex;
         while (currentOffset < endIndex) {
-          var tail = this.l1p(1);
+          var tail = this.m1p(1);
           var tmp0 = endIndex - currentOffset | 0;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = tail.q1p();
+          var b = tail.r1p();
           var toCopy = Math.min(tmp0, b);
-          tail.r1p(source, currentOffset, currentOffset + toCopy | 0);
+          tail.s1p(source, currentOffset, currentOffset + toCopy | 0);
           currentOffset = currentOffset + toCopy | 0;
         }
         var tmp = this;
-        var tmp0_0 = this.a1o_1;
+        var tmp0_0 = this.b1o_1;
         // Inline function 'kotlin.Long.plus' call
         var other = endIndex - startIndex | 0;
-        tmp.a1o_1 = add(tmp0_0, fromInt(other));
+        tmp.b1o_1 = add(tmp0_0, fromInt(other));
       }
-      t1p(source, byteCount) {
+      u1p(source, byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0)) {
@@ -370,86 +370,86 @@ function Buffer() {
         }
         var remainingByteCount = byteCount;
         while (compare(remainingByteCount, new (Long())(0, 0)) > 0) {
-          var read = source.g1p(this, remainingByteCount);
+          var read = source.h1p(this, remainingByteCount);
           if (equalsLong(read, new (Long())(-1, -1))) {
-            throw EOFException().e1o('Source exhausted before reading ' + byteCount.toString() + ' bytes. ' + ('Only ' + subtract(byteCount, remainingByteCount).toString() + ' were read.'));
+            throw EOFException().f1o('Source exhausted before reading ' + byteCount.toString() + ' bytes. ' + ('Only ' + subtract(byteCount, remainingByteCount).toString() + ' were read.'));
           }
           remainingByteCount = subtract(remainingByteCount, read);
         }
       }
-      h1p(source, byteCount) {
+      i1p(source, byteCount) {
         // Inline function 'kotlin.require' call
         if (!!(source === this)) {
           var message = 'source == this';
           throw IllegalArgumentException().r2(toString(message));
         }
-        checkOffsetAndCount(source.a1o_1, new (Long())(0, 0), byteCount);
+        checkOffsetAndCount(source.b1o_1, new (Long())(0, 0), byteCount);
         var remainingByteCount = byteCount;
         while (compare(remainingByteCount, new (Long())(0, 0)) > 0) {
-          if (compare(remainingByteCount, fromInt(ensureNotNull(source.y1n_1).v2())) < 0) {
-            var tail = this.z1n_1;
+          if (compare(remainingByteCount, fromInt(ensureNotNull(source.z1n_1).v2())) < 0) {
+            var tail = this.a1o_1;
             var tmp;
-            if (!(tail == null) && tail.o1o_1) {
+            if (!(tail == null) && tail.p1o_1) {
               var tmp0 = remainingByteCount;
               // Inline function 'kotlin.Long.plus' call
-              var other = tail.m1o_1;
+              var other = tail.n1o_1;
               var tmp0_0 = add(tmp0, fromInt(other));
               // Inline function 'kotlin.Long.minus' call
-              var other_0 = tail.u1p() ? 0 : tail.l1o_1;
+              var other_0 = tail.v1p() ? 0 : tail.m1o_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.y1n_1).w1p(tail, convertToInt(remainingByteCount));
-              source.a1o_1 = subtract(source.a1o_1, remainingByteCount);
-              this.a1o_1 = add(this.a1o_1, remainingByteCount);
+              ensureNotNull(source.z1n_1).x1p(tail, convertToInt(remainingByteCount));
+              source.b1o_1 = subtract(source.b1o_1, remainingByteCount);
+              this.b1o_1 = add(this.b1o_1, remainingByteCount);
               return Unit_instance;
             } else {
-              source.y1n_1 = ensureNotNull(source.y1n_1).v1p(convertToInt(remainingByteCount));
+              source.z1n_1 = ensureNotNull(source.z1n_1).w1p(convertToInt(remainingByteCount));
             }
           }
-          var segmentToMove = ensureNotNull(source.y1n_1);
+          var segmentToMove = ensureNotNull(source.z1n_1);
           var movedByteCount = fromInt(segmentToMove.v2());
-          source.y1n_1 = segmentToMove.x1p();
-          if (source.y1n_1 == null) {
-            source.z1n_1 = null;
+          source.z1n_1 = segmentToMove.y1p();
+          if (source.z1n_1 == null) {
+            source.a1o_1 = null;
           }
           // Inline function 'kotlinx.io.Buffer.pushSegment' call
-          if (this.y1n_1 == null) {
-            this.y1n_1 = segmentToMove;
+          if (this.z1n_1 == null) {
             this.z1n_1 = segmentToMove;
+            this.a1o_1 = segmentToMove;
           } else if (true) {
-            this.z1n_1 = ensureNotNull(this.z1n_1).y1o(segmentToMove).z1o();
-            if (ensureNotNull(this.z1n_1).q1o_1 == null) {
-              this.y1n_1 = this.z1n_1;
+            this.a1o_1 = ensureNotNull(this.a1o_1).z1o(segmentToMove).a1p();
+            if (ensureNotNull(this.a1o_1).r1o_1 == null) {
+              this.z1n_1 = this.a1o_1;
             }
           } else {
-            this.z1n_1 = ensureNotNull(this.z1n_1).y1o(segmentToMove);
+            this.a1o_1 = ensureNotNull(this.a1o_1).z1o(segmentToMove);
           }
-          source.a1o_1 = subtract(source.a1o_1, movedByteCount);
-          this.a1o_1 = add(this.a1o_1, movedByteCount);
+          source.b1o_1 = subtract(source.b1o_1, movedByteCount);
+          this.b1o_1 = add(this.b1o_1, movedByteCount);
           remainingByteCount = subtract(remainingByteCount, movedByteCount);
         }
       }
-      y1p(source) {
+      z1p(source) {
         var totalBytesRead = new (Long())(0, 0);
         $l$loop: while (true) {
-          var readCount = source.g1p(this, new (Long())(8192, 0));
+          var readCount = source.h1p(this, new (Long())(8192, 0));
           if (equalsLong(readCount, new (Long())(-1, -1)))
             break $l$loop;
           totalBytesRead = add(totalBytesRead, readCount);
         }
         return totalBytesRead;
       }
-      z1p(byte) {
-        this.l1p(1).a1q(byte);
-        this.a1o_1 = add(this.a1o_1, new (Long())(1, 0));
+      a1q(byte) {
+        this.m1p(1).b1q(byte);
+        this.b1o_1 = add(this.b1o_1, new (Long())(1, 0));
       }
-      b1q(short) {
-        this.l1p(2).c1q(short);
-        this.a1o_1 = add(this.a1o_1, new (Long())(2, 0));
+      c1q(short) {
+        this.m1p(2).d1q(short);
+        this.b1o_1 = add(this.b1o_1, new (Long())(2, 0));
       }
       o6() {
         return Unit_instance;
@@ -467,7 +467,7 @@ function Buffer() {
         var builder = StringBuilder().gc(imul(len, 2) + (compare(this.v2(), fromInt(maxPrintableBytes)) > 0 ? 1 : 0) | 0);
         var bytesWritten = 0;
         // Inline function 'kotlinx.io.unsafe.UnsafeBufferOperations.forEachSegment' call
-        var curr = this.y1n_1;
+        var curr = this.z1n_1;
         while (!(curr == null)) {
           var tmp0 = get_SegmentReadContextImpl();
           var segment = curr;
@@ -475,7 +475,7 @@ function Buffer() {
           while (bytesWritten < len && idx < segment.v2()) {
             var _unary__edvuaz = idx;
             idx = _unary__edvuaz + 1 | 0;
-            var b_0 = tmp0.d1q(segment, _unary__edvuaz);
+            var b_0 = tmp0.e1q(segment, _unary__edvuaz);
             bytesWritten = bytesWritten + 1 | 0;
             var tmp = get_HEX_DIGIT_CHARS();
             // Inline function 'kotlinx.io.shr' call
@@ -486,39 +486,39 @@ function Buffer() {
             var tmp$ret$3 = b_0 & 15;
             tmp_0.p1(tmp_1[tmp$ret$3]);
           }
-          curr = curr.p1o_1;
+          curr = curr.q1o_1;
         }
         if (compare(this.v2(), fromInt(maxPrintableBytes)) > 0) {
           builder.p1(_Char___init__impl__6a9atx(8230));
         }
         return 'Buffer(size=' + this.v2().toString() + ' hex=' + builder.toString() + ')';
       }
-      r1o() {
-        var oldHead = ensureNotNull(this.y1n_1);
-        var nextHead = oldHead.p1o_1;
-        this.y1n_1 = nextHead;
+      s1o() {
+        var oldHead = ensureNotNull(this.z1n_1);
+        var nextHead = oldHead.q1o_1;
+        this.z1n_1 = nextHead;
         if (nextHead == null) {
-          this.z1n_1 = null;
+          this.a1o_1 = null;
         } else {
-          nextHead.q1o_1 = null;
+          nextHead.r1o_1 = null;
         }
-        oldHead.p1o_1 = null;
-        SegmentPool_instance.e1q(oldHead);
+        oldHead.q1o_1 = null;
+        SegmentPool_instance.f1q(oldHead);
       }
-      f1q() {
-        var oldTail = ensureNotNull(this.z1n_1);
-        var newTail = oldTail.q1o_1;
-        this.z1n_1 = newTail;
+      g1q() {
+        var oldTail = ensureNotNull(this.a1o_1);
+        var newTail = oldTail.r1o_1;
+        this.a1o_1 = newTail;
         if (newTail == null) {
-          this.y1n_1 = null;
+          this.z1n_1 = null;
         } else {
-          newTail.p1o_1 = null;
+          newTail.q1o_1 = null;
         }
-        oldTail.q1o_1 = null;
-        SegmentPool_instance.e1q(oldTail);
+        oldTail.r1o_1 = null;
+        SegmentPool_instance.f1q(oldTail);
       }
     }
-    protoOf($).s1p = write$default;
+    protoOf($).t1p = write$default;
     initMetadataForClass($, 'Buffer', Buffer, VOID, [Source(), Sink()]);
     BufferClass = $;
   }