@attocash/commons-test 6.0.0 → 6.1.0

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

@@ -45,37 +45,37 @@ var imul = Math.imul;
 //region block: pre-declaration
 //endregion
 function throwEof($this, byteCount) {
-  throw EOFException().m1k("Buffer doesn't contain required number of bytes (size: " + $this.n1().toString() + ', required: ' + byteCount.toString() + ')');
+  throw EOFException().c2h("Buffer doesn't contain required number of bytes (size: " + $this.n1().toString() + ', required: ' + byteCount.toString() + ')');
 }
 var BufferClass;
 function Buffer() {
   if (BufferClass === VOID) {
     class $ {
       constructor() {
-        this.g1k_1 = null;
-        this.h1k_1 = null;
-        this.i1k_1 = 0n;
+        this.w2g_1 = null;
+        this.x2g_1 = null;
+        this.y2g_1 = 0n;
       }
       n1() {
-        return this.i1k_1;
+        return this.y2g_1;
       }
-      n1k() {
+      d2h() {
         return this;
       }
-      o1k() {
+      e2h() {
         return this.n1() === 0n;
       }
-      p1k(byteCount) {
+      f2h(byteCount) {
         // Inline function 'kotlin.require' call
         if (!(byteCount >= 0n)) {
           var message = 'byteCount: ' + byteCount.toString();
           throw IllegalArgumentException().i1(toString(message));
         }
         if (this.n1() < byteCount) {
-          throw EOFException().m1k("Buffer doesn't contain required number of bytes (size: " + this.n1().toString() + ', required: ' + byteCount.toString() + ')');
+          throw EOFException().c2h("Buffer doesn't contain required number of bytes (size: " + this.n1().toString() + ', required: ' + byteCount.toString() + ')');
         }
       }
-      q1k(byteCount) {
+      g2h(byteCount) {
         // Inline function 'kotlin.require' call
         if (!(byteCount >= 0n)) {
           var message = 'byteCount: ' + byteCount.toString() + ' < 0';
@@ -83,8 +83,8 @@ function Buffer() {
         }
         return this.n1() >= byteCount;
       }
-      r1k() {
-        var tmp0_elvis_lhs = this.g1k_1;
+      h2h() {
+        var tmp0_elvis_lhs = this.w2g_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           throwEof(this, 1n);
@@ -94,18 +94,18 @@ function Buffer() {
         var segment = tmp;
         var segmentSize = segment.n1();
         if (segmentSize === 0) {
-          this.z1k();
-          return this.r1k();
+          this.p2h();
+          return this.h2h();
         }
-        var v = segment.a1l();
-        this.i1k_1 = subtract(this.i1k_1, 1n);
+        var v = segment.q2h();
+        this.y2g_1 = subtract(this.y2g_1, 1n);
         if (segmentSize === 1) {
-          this.z1k();
+          this.p2h();
         }
         return v;
       }
-      b1l() {
-        var tmp0_elvis_lhs = this.g1k_1;
+      r2h() {
+        var tmp0_elvis_lhs = this.w2g_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           throwEof(this, 2n);
@@ -115,26 +115,26 @@ function Buffer() {
         var segment = tmp;
         var segmentSize = segment.n1();
         if (segmentSize < 2) {
-          this.p1k(2n);
+          this.f2h(2n);
           if (segmentSize === 0) {
-            this.z1k();
-            return this.b1l();
+            this.p2h();
+            return this.r2h();
           }
           // Inline function 'kotlinx.io.and' call
-          var tmp_0 = (this.r1k() & 255) << 8;
+          var tmp_0 = (this.h2h() & 255) << 8;
           // Inline function 'kotlinx.io.and' call
-          var tmp$ret$1 = this.r1k() & 255;
+          var tmp$ret$1 = this.h2h() & 255;
           return toShort(tmp_0 | tmp$ret$1);
         }
-        var v = segment.c1l();
-        this.i1k_1 = subtract(this.i1k_1, 2n);
+        var v = segment.s2h();
+        this.y2g_1 = subtract(this.y2g_1, 2n);
         if (segmentSize === 2) {
-          this.z1k();
+          this.p2h();
         }
         return v;
       }
-      d1l() {
-        var tmp0_elvis_lhs = this.g1k_1;
+      t2h() {
+        var tmp0_elvis_lhs = this.w2g_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           throwEof(this, 4n);
@@ -144,22 +144,22 @@ function Buffer() {
         var segment = tmp;
         var segmentSize = segment.n1();
         if (segmentSize < 4) {
-          this.p1k(4n);
+          this.f2h(4n);
           if (segmentSize === 0) {
-            this.z1k();
-            return this.d1l();
+            this.p2h();
+            return this.t2h();
           }
-          return this.b1l() << 16 | this.b1l() & 65535;
+          return this.r2h() << 16 | this.r2h() & 65535;
         }
-        var v = segment.e1l();
-        this.i1k_1 = subtract(this.i1k_1, 4n);
+        var v = segment.u2h();
+        this.y2g_1 = subtract(this.y2g_1, 4n);
         if (segmentSize === 4) {
-          this.z1k();
+          this.p2h();
         }
         return v;
       }
-      f1l() {
-        var tmp0_elvis_lhs = this.g1k_1;
+      v2h() {
+        var tmp0_elvis_lhs = this.w2g_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           throwEof(this, 8n);
@@ -169,115 +169,115 @@ function Buffer() {
         var segment = tmp;
         var segmentSize = segment.n1();
         if (segmentSize < 8) {
-          this.p1k(8n);
+          this.f2h(8n);
           if (segmentSize === 0) {
-            this.z1k();
-            return this.f1l();
+            this.p2h();
+            return this.v2h();
           }
-          return shiftLeft(fromInt(this.d1l()), 32) | fromInt(this.d1l()) & 4294967295n;
+          return shiftLeft(fromInt(this.t2h()), 32) | fromInt(this.t2h()) & 4294967295n;
         }
-        var v = segment.g1l();
-        this.i1k_1 = subtract(this.i1k_1, 8n);
+        var v = segment.w2h();
+        this.y2g_1 = subtract(this.y2g_1, 8n);
         if (segmentSize === 8) {
-          this.z1k();
+          this.p2h();
         }
         return v;
       }
-      h1l() {
+      x2h() {
         return Unit_instance;
       }
-      i1l(out, startIndex, endIndex) {
+      y2h(out, startIndex, endIndex) {
         checkBounds(this.n1(), startIndex, endIndex);
         if (startIndex === endIndex)
           return Unit_instance;
         var currentOffset = startIndex;
         var remainingByteCount = subtract(endIndex, startIndex);
-        out.i1k_1 = add(out.i1k_1, remainingByteCount);
-        var s = this.g1k_1;
-        while (currentOffset >= fromInt(ensureNotNull(s).u1k_1 - s.t1k_1 | 0)) {
-          currentOffset = subtract(currentOffset, fromInt(s.u1k_1 - s.t1k_1 | 0));
-          s = s.x1k_1;
+        out.y2g_1 = add(out.y2g_1, remainingByteCount);
+        var s = this.w2g_1;
+        while (currentOffset >= fromInt(ensureNotNull(s).k2h_1 - s.j2h_1 | 0)) {
+          currentOffset = subtract(currentOffset, fromInt(s.k2h_1 - s.j2h_1 | 0));
+          s = s.n2h_1;
         }
         while (remainingByteCount > 0n) {
-          var copy = ensureNotNull(s).j1l();
-          copy.t1k_1 = copy.t1k_1 + convertToInt(currentOffset) | 0;
+          var copy = ensureNotNull(s).z2h();
+          copy.j2h_1 = copy.j2h_1 + convertToInt(currentOffset) | 0;
           var tmp = copy;
-          var tmp0 = copy.t1k_1 + convertToInt(remainingByteCount) | 0;
+          var tmp0 = copy.j2h_1 + convertToInt(remainingByteCount) | 0;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = copy.u1k_1;
-          tmp.u1k_1 = Math.min(tmp0, b);
+          var b = copy.k2h_1;
+          tmp.k2h_1 = Math.min(tmp0, b);
           // Inline function 'kotlinx.io.Buffer.pushSegment' call
-          if (out.g1k_1 == null) {
-            out.g1k_1 = copy;
-            out.h1k_1 = copy;
+          if (out.w2g_1 == null) {
+            out.w2g_1 = copy;
+            out.x2g_1 = copy;
           } else if (false) {
-            out.h1k_1 = ensureNotNull(out.h1k_1).k1l(copy).l1l();
-            if (ensureNotNull(out.h1k_1).y1k_1 == null) {
-              out.g1k_1 = out.h1k_1;
+            out.x2g_1 = ensureNotNull(out.x2g_1).a2i(copy).b2i();
+            if (ensureNotNull(out.x2g_1).o2h_1 == null) {
+              out.w2g_1 = out.x2g_1;
             }
           } else {
-            out.h1k_1 = ensureNotNull(out.h1k_1).k1l(copy);
+            out.x2g_1 = ensureNotNull(out.x2g_1).a2i(copy);
           }
-          remainingByteCount = subtract(remainingByteCount, fromInt(copy.u1k_1 - copy.t1k_1 | 0));
+          remainingByteCount = subtract(remainingByteCount, fromInt(copy.k2h_1 - copy.j2h_1 | 0));
           currentOffset = 0n;
-          s = s.x1k_1;
+          s = s.n2h_1;
         }
       }
-      m1l() {
+      c2i() {
         var result = this.n1();
         if (result === 0n)
           return 0n;
-        var tail = ensureNotNull(this.h1k_1);
-        if (tail.u1k_1 < 8192 && tail.w1k_1) {
-          result = subtract(result, fromInt(tail.u1k_1 - tail.t1k_1 | 0));
+        var tail = ensureNotNull(this.x2g_1);
+        if (tail.k2h_1 < 8192 && tail.m2h_1) {
+          result = subtract(result, fromInt(tail.k2h_1 - tail.j2h_1 | 0));
         }
         return result;
       }
-      n1l(position) {
+      d2i(position) {
         if (position < 0n || position >= this.n1()) {
           throw IndexOutOfBoundsException().ud('position (' + position.toString() + ') is not within the range [0..size(' + this.n1().toString() + '))');
         }
         if (position === 0n) {
-          return ensureNotNull(this.g1k_1).o1l(0);
+          return ensureNotNull(this.w2g_1).e2i(0);
         }
         // Inline function 'kotlinx.io.seek' call
-        if (this.g1k_1 == null) {
-          return ensureNotNull(null).o1l(convertToInt(subtract(position, -1n)));
+        if (this.w2g_1 == null) {
+          return ensureNotNull(null).e2i(convertToInt(subtract(position, -1n)));
         }
         if (subtract(this.n1(), position) < position) {
-          var s = this.h1k_1;
+          var s = this.x2g_1;
           var offset = this.n1();
           $l$loop: while (!(s == null) && offset > position) {
-            offset = subtract(offset, fromInt(s.u1k_1 - s.t1k_1 | 0));
+            offset = subtract(offset, fromInt(s.k2h_1 - s.j2h_1 | 0));
             if (offset <= position)
               break $l$loop;
-            s = s.y1k_1;
+            s = s.o2h_1;
           }
           var tmp0 = s;
           var offset_0 = offset;
-          return ensureNotNull(tmp0).o1l(convertToInt(subtract(position, offset_0)));
+          return ensureNotNull(tmp0).e2i(convertToInt(subtract(position, offset_0)));
         } else {
-          var s_0 = this.g1k_1;
+          var s_0 = this.w2g_1;
           var offset_1 = 0n;
           $l$loop_0: while (!(s_0 == null)) {
             var tmp0_0 = offset_1;
             // Inline function 'kotlin.Long.plus' call
-            var other = s_0.u1k_1 - s_0.t1k_1 | 0;
+            var other = s_0.k2h_1 - s_0.j2h_1 | 0;
             var nextOffset = add(tmp0_0, fromInt(other));
             if (nextOffset > position)
               break $l$loop_0;
-            s_0 = s_0.x1k_1;
+            s_0 = s_0.n2h_1;
             offset_1 = nextOffset;
           }
           var tmp0_1 = s_0;
           var offset_2 = offset_1;
-          return ensureNotNull(tmp0_1).o1l(convertToInt(subtract(position, offset_2)));
+          return ensureNotNull(tmp0_1).e2i(convertToInt(subtract(position, offset_2)));
         }
       }
       p3() {
-        return this.p1l(this.n1());
+        return this.f2i(this.n1());
       }
-      p1l(byteCount) {
+      f2i(byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(byteCount >= 0n)) {
@@ -286,34 +286,34 @@ function Buffer() {
         }
         var remainingByteCount = byteCount;
         while (remainingByteCount > 0n) {
-          var tmp0_elvis_lhs = this.g1k_1;
+          var tmp0_elvis_lhs = this.w2g_1;
           var tmp;
           if (tmp0_elvis_lhs == null) {
-            throw EOFException().m1k('Buffer exhausted before skipping ' + byteCount.toString() + ' bytes.');
+            throw EOFException().c2h('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.u1k_1 - head.t1k_1 | 0;
+          var b = head.k2h_1 - head.j2h_1 | 0;
           // Inline function 'kotlin.comparisons.minOf' call
           var b_0 = fromInt(b);
           var tmp$ret$4 = tmp0 <= b_0 ? tmp0 : b_0;
           var toSkip = convertToInt(tmp$ret$4);
-          this.i1k_1 = subtract(this.i1k_1, fromInt(toSkip));
+          this.y2g_1 = subtract(this.y2g_1, fromInt(toSkip));
           remainingByteCount = subtract(remainingByteCount, fromInt(toSkip));
-          head.t1k_1 = head.t1k_1 + toSkip | 0;
-          if (head.t1k_1 === head.u1k_1) {
-            this.z1k();
+          head.j2h_1 = head.j2h_1 + toSkip | 0;
+          if (head.j2h_1 === head.k2h_1) {
+            this.p2h();
           }
         }
       }
-      q1l(sink, startIndex, endIndex) {
+      g2i(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.g1k_1;
+        var tmp0_elvis_lhs = this.w2g_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           return -1;
@@ -325,14 +325,14 @@ function Buffer() {
         // Inline function 'kotlin.comparisons.minOf' call
         var b = s.n1();
         var toCopy = Math.min(tmp0, b);
-        s.r1l(sink, startIndex, startIndex + toCopy | 0);
-        this.i1k_1 = subtract(this.i1k_1, fromInt(toCopy));
+        s.h2i(sink, startIndex, startIndex + toCopy | 0);
+        this.y2g_1 = subtract(this.y2g_1, fromInt(toCopy));
         if (isEmpty(s)) {
-          this.z1k();
+          this.p2h();
         }
         return toCopy;
       }
-      s1l(sink, byteCount) {
+      i2i(sink, byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(byteCount >= 0n)) {
@@ -342,10 +342,10 @@ function Buffer() {
         if (this.n1() === 0n)
           return -1n;
         var bytesWritten = byteCount > this.n1() ? this.n1() : byteCount;
-        sink.t1l(this, bytesWritten);
+        sink.j2i(this, bytesWritten);
         return bytesWritten;
       }
-      u1l(sink, byteCount) {
+      k2i(sink, byteCount) {
         // Inline function 'kotlinx.io.checkByteCount' call
         // Inline function 'kotlin.require' call
         if (!(byteCount >= 0n)) {
@@ -353,156 +353,156 @@ function Buffer() {
           throw IllegalArgumentException().i1(toString(message));
         }
         if (this.n1() < byteCount) {
-          sink.t1l(this, this.n1());
-          throw EOFException().m1k('Buffer exhausted before writing ' + byteCount.toString() + ' bytes. Only ' + this.n1().toString() + ' bytes were written.');
+          sink.j2i(this, this.n1());
+          throw EOFException().c2h('Buffer exhausted before writing ' + byteCount.toString() + ' bytes. Only ' + this.n1().toString() + ' bytes were written.');
         }
-        sink.t1l(this, byteCount);
+        sink.j2i(this, byteCount);
       }
-      v1l(sink) {
+      l2i(sink) {
         var byteCount = this.n1();
         if (byteCount > 0n) {
-          sink.t1l(this, byteCount);
+          sink.j2i(this, byteCount);
         }
         return byteCount;
       }
-      w1l() {
+      m2i() {
         return buffered(new (PeekSource())(this));
       }
-      x1l(minimumCapacity) {
+      n2i(minimumCapacity) {
         // Inline function 'kotlin.require' call
         if (!(minimumCapacity >= 1 && minimumCapacity <= 8192)) {
           var message = 'unexpected capacity (' + minimumCapacity + '), should be in range [1, 8192]';
           throw IllegalArgumentException().i1(toString(message));
         }
-        if (this.h1k_1 == null) {
-          var result = SegmentPool_instance.a1m();
-          this.g1k_1 = result;
-          this.h1k_1 = result;
+        if (this.x2g_1 == null) {
+          var result = SegmentPool_instance.q2i();
+          this.w2g_1 = result;
+          this.x2g_1 = result;
           return result;
         }
-        var t = ensureNotNull(this.h1k_1);
-        if ((t.u1k_1 + minimumCapacity | 0) > 8192 || !t.w1k_1) {
-          var newTail = t.k1l(SegmentPool_instance.a1m());
-          this.h1k_1 = newTail;
+        var t = ensureNotNull(this.x2g_1);
+        if ((t.k2h_1 + minimumCapacity | 0) > 8192 || !t.m2h_1) {
+          var newTail = t.a2i(SegmentPool_instance.q2i());
+          this.x2g_1 = newTail;
           return newTail;
         }
         return t;
       }
-      b1m(source, startIndex, endIndex) {
+      r2i(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.x1l(1);
+          var tail = this.n2i(1);
           var tmp0 = endIndex - currentOffset | 0;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = tail.c1m();
+          var b = tail.s2i();
           var toCopy = Math.min(tmp0, b);
-          tail.d1m(source, currentOffset, currentOffset + toCopy | 0);
+          tail.t2i(source, currentOffset, currentOffset + toCopy | 0);
           currentOffset = currentOffset + toCopy | 0;
         }
         var tmp = this;
-        var tmp0_0 = this.i1k_1;
+        var tmp0_0 = this.y2g_1;
         // Inline function 'kotlin.Long.plus' call
         var other = endIndex - startIndex | 0;
-        tmp.i1k_1 = add(tmp0_0, fromInt(other));
+        tmp.y2g_1 = add(tmp0_0, fromInt(other));
       }
-      t1l(source, byteCount) {
+      j2i(source, byteCount) {
         // Inline function 'kotlin.require' call
         if (!!(source === this)) {
           var message = 'source == this';
           throw IllegalArgumentException().i1(toString(message));
         }
-        checkOffsetAndCount(source.i1k_1, 0n, byteCount);
+        checkOffsetAndCount(source.y2g_1, 0n, byteCount);
         var remainingByteCount = byteCount;
         while (remainingByteCount > 0n) {
-          if (remainingByteCount < fromInt(ensureNotNull(source.g1k_1).n1())) {
-            var tail = this.h1k_1;
+          if (remainingByteCount < fromInt(ensureNotNull(source.w2g_1).n1())) {
+            var tail = this.x2g_1;
             var tmp;
-            if (!(tail == null) && tail.w1k_1) {
+            if (!(tail == null) && tail.m2h_1) {
               var tmp0 = remainingByteCount;
               // Inline function 'kotlin.Long.plus' call
-              var other = tail.u1k_1;
+              var other = tail.k2h_1;
               var tmp0_0 = add(tmp0, fromInt(other));
               // Inline function 'kotlin.Long.minus' call
-              var other_0 = tail.f1m() ? 0 : tail.t1k_1;
+              var other_0 = tail.v2i() ? 0 : tail.j2h_1;
               tmp = subtract(tmp0_0, fromInt(other_0)) <= 8192n;
             } else {
               tmp = false;
             }
             if (tmp) {
-              ensureNotNull(source.g1k_1).h1m(tail, convertToInt(remainingByteCount));
-              source.i1k_1 = subtract(source.i1k_1, remainingByteCount);
-              this.i1k_1 = add(this.i1k_1, remainingByteCount);
+              ensureNotNull(source.w2g_1).x2i(tail, convertToInt(remainingByteCount));
+              source.y2g_1 = subtract(source.y2g_1, remainingByteCount);
+              this.y2g_1 = add(this.y2g_1, remainingByteCount);
               return Unit_instance;
             } else {
-              source.g1k_1 = ensureNotNull(source.g1k_1).g1m(convertToInt(remainingByteCount));
+              source.w2g_1 = ensureNotNull(source.w2g_1).w2i(convertToInt(remainingByteCount));
             }
           }
-          var segmentToMove = ensureNotNull(source.g1k_1);
+          var segmentToMove = ensureNotNull(source.w2g_1);
           var movedByteCount = fromInt(segmentToMove.n1());
-          source.g1k_1 = segmentToMove.i1m();
-          if (source.g1k_1 == null) {
-            source.h1k_1 = null;
+          source.w2g_1 = segmentToMove.y2i();
+          if (source.w2g_1 == null) {
+            source.x2g_1 = null;
           }
           // Inline function 'kotlinx.io.Buffer.pushSegment' call
-          if (this.g1k_1 == null) {
-            this.g1k_1 = segmentToMove;
-            this.h1k_1 = segmentToMove;
+          if (this.w2g_1 == null) {
+            this.w2g_1 = segmentToMove;
+            this.x2g_1 = segmentToMove;
           } else if (true) {
-            this.h1k_1 = ensureNotNull(this.h1k_1).k1l(segmentToMove).l1l();
-            if (ensureNotNull(this.h1k_1).y1k_1 == null) {
-              this.g1k_1 = this.h1k_1;
+            this.x2g_1 = ensureNotNull(this.x2g_1).a2i(segmentToMove).b2i();
+            if (ensureNotNull(this.x2g_1).o2h_1 == null) {
+              this.w2g_1 = this.x2g_1;
             }
           } else {
-            this.h1k_1 = ensureNotNull(this.h1k_1).k1l(segmentToMove);
+            this.x2g_1 = ensureNotNull(this.x2g_1).a2i(segmentToMove);
           }
-          source.i1k_1 = subtract(source.i1k_1, movedByteCount);
-          this.i1k_1 = add(this.i1k_1, movedByteCount);
+          source.y2g_1 = subtract(source.y2g_1, movedByteCount);
+          this.y2g_1 = add(this.y2g_1, movedByteCount);
           remainingByteCount = subtract(remainingByteCount, movedByteCount);
         }
       }
-      j1m(source) {
+      z2i(source) {
         var totalBytesRead = 0n;
         $l$loop: while (true) {
-          var readCount = source.s1l(this, 8192n);
+          var readCount = source.i2i(this, 8192n);
           if (readCount === -1n)
             break $l$loop;
           totalBytesRead = add(totalBytesRead, readCount);
         }
         return totalBytesRead;
       }
-      k1m(byte) {
-        this.x1l(1).l1m(byte);
-        this.i1k_1 = add(this.i1k_1, 1n);
+      a2j(byte) {
+        this.n2i(1).b2j(byte);
+        this.y2g_1 = add(this.y2g_1, 1n);
       }
-      m1m(short) {
-        this.x1l(2).n1m(short);
-        this.i1k_1 = add(this.i1k_1, 2n);
+      c2j(short) {
+        this.n2i(2).d2j(short);
+        this.y2g_1 = add(this.y2g_1, 2n);
       }
-      o1m(int) {
-        this.x1l(4).p1m(int);
-        this.i1k_1 = add(this.i1k_1, 4n);
+      e2j(int) {
+        this.n2i(4).f2j(int);
+        this.y2g_1 = add(this.y2g_1, 4n);
       }
-      q1m(long) {
-        this.x1l(8).r1m(long);
-        this.i1k_1 = add(this.i1k_1, 8n);
+      h1i(long) {
+        this.n2i(8).g2j(long);
+        this.y2g_1 = add(this.y2g_1, 8n);
       }
-      s1m() {
+      h2j() {
         var result = new (Buffer())();
         if (this.n1() === 0n)
           return result;
-        var head = ensureNotNull(this.g1k_1);
-        var headCopy = head.j1l();
-        result.g1k_1 = headCopy;
-        result.h1k_1 = headCopy;
-        var s = head.x1k_1;
+        var head = ensureNotNull(this.w2g_1);
+        var headCopy = head.z2h();
+        result.w2g_1 = headCopy;
+        result.x2g_1 = headCopy;
+        var s = head.n2h_1;
         while (!(s == null)) {
-          result.h1k_1 = ensureNotNull(result.h1k_1).k1l(s.j1l());
-          s = s.x1k_1;
+          result.x2g_1 = ensureNotNull(result.x2g_1).a2i(s.z2h());
+          s = s.n2h_1;
         }
-        result.i1k_1 = this.n1();
+        result.y2g_1 = this.n1();
         return result;
       }
       a6() {
@@ -521,7 +521,7 @@ function Buffer() {
         var builder = StringBuilder().mb(imul(len, 2) + (this.n1() > fromInt(maxPrintableBytes) ? 1 : 0) | 0);
         var bytesWritten = 0;
         // Inline function 'kotlinx.io.unsafe.UnsafeBufferOperations.forEachSegment' call
-        var curr = this.g1k_1;
+        var curr = this.w2g_1;
         while (!(curr == null)) {
           var tmp0 = get_SegmentReadContextImpl();
           var segment = curr;
@@ -529,7 +529,7 @@ function Buffer() {
           while (bytesWritten < len && idx < segment.n1()) {
             var _unary__edvuaz = idx;
             idx = _unary__edvuaz + 1 | 0;
-            var b_0 = tmp0.t1m(segment, _unary__edvuaz);
+            var b_0 = tmp0.i2j(segment, _unary__edvuaz);
             bytesWritten = bytesWritten + 1 | 0;
             var tmp = get_HEX_DIGIT_CHARS();
             // Inline function 'kotlinx.io.shr' call
@@ -540,39 +540,39 @@ function Buffer() {
             var tmp$ret$3 = b_0 & 15;
             tmp_0.jb(tmp_1[tmp$ret$3]);
           }
-          curr = curr.x1k_1;
+          curr = curr.n2h_1;
         }
         if (this.n1() > fromInt(maxPrintableBytes)) {
           builder.jb(_Char___init__impl__6a9atx(8230));
         }
         return 'Buffer(size=' + this.n1().toString() + ' hex=' + builder.toString() + ')';
       }
-      z1k() {
-        var oldHead = ensureNotNull(this.g1k_1);
-        var nextHead = oldHead.x1k_1;
-        this.g1k_1 = nextHead;
+      p2h() {
+        var oldHead = ensureNotNull(this.w2g_1);
+        var nextHead = oldHead.n2h_1;
+        this.w2g_1 = nextHead;
         if (nextHead == null) {
-          this.h1k_1 = null;
+          this.x2g_1 = null;
         } else {
-          nextHead.y1k_1 = null;
+          nextHead.o2h_1 = null;
         }
-        oldHead.x1k_1 = null;
-        SegmentPool_instance.u1m(oldHead);
+        oldHead.n2h_1 = null;
+        SegmentPool_instance.j2j(oldHead);
       }
-      v1m() {
-        var oldTail = ensureNotNull(this.h1k_1);
-        var newTail = oldTail.y1k_1;
-        this.h1k_1 = newTail;
+      k2j() {
+        var oldTail = ensureNotNull(this.x2g_1);
+        var newTail = oldTail.o2h_1;
+        this.x2g_1 = newTail;
         if (newTail == null) {
-          this.g1k_1 = null;
+          this.w2g_1 = null;
         } else {
-          newTail.x1k_1 = null;
+          newTail.n2h_1 = null;
         }
-        oldTail.y1k_1 = null;
-        SegmentPool_instance.u1m(oldTail);
+        oldTail.o2h_1 = null;
+        SegmentPool_instance.j2j(oldTail);
       }
     }
-    protoOf($).e1m = write$default;
+    protoOf($).u2i = write$default;
     initMetadataForClass($, 'Buffer', Buffer, VOID, [Source(), Sink()]);
     BufferClass = $;
   }