@continuous-excellence/coupling-cli 1.1.509 → 1.1.510

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/SharedFlow.mjs

@@ -85,41 +85,41 @@ function MutableSharedFlow(replay, extraBufferCapacity, onBufferOverflow) {
   return new (SharedFlowImpl())(replay, bufferCapacity, onBufferOverflow);
 }
 function _get_head__d7jo8b($this) {
-  var tmp0 = $this.b1g_1;
+  var tmp0 = $this.w1f_1;
   // Inline function 'kotlin.comparisons.minOf' call
-  var b = $this.a1g_1;
+  var b = $this.v1f_1;
   return compare(tmp0, b) <= 0 ? tmp0 : b;
 }
 function _get_replaySize__dxgnb1($this) {
   var tmp0 = _get_head__d7jo8b($this);
   // Inline function 'kotlin.Long.plus' call
-  var other = $this.c1g_1;
+  var other = $this.x1f_1;
   var tmp$ret$0 = add(tmp0, fromInt(other));
-  return convertToInt(subtract(tmp$ret$0, $this.a1g_1));
+  return convertToInt(subtract(tmp$ret$0, $this.v1f_1));
 }
 function _get_totalSize__xhdb3o($this) {
-  return $this.c1g_1 + $this.d1g_1 | 0;
+  return $this.x1f_1 + $this.y1f_1 | 0;
 }
 function _get_bufferEndIndex__d2rk18($this) {
   var tmp0 = _get_head__d7jo8b($this);
   // Inline function 'kotlin.Long.plus' call
-  var other = $this.c1g_1;
+  var other = $this.x1f_1;
   return add(tmp0, fromInt(other));
 }
 function _get_queueEndIndex__4m025l($this) {
   var tmp0 = _get_head__d7jo8b($this);
   // Inline function 'kotlin.Long.plus' call
-  var other = $this.c1g_1;
+  var other = $this.x1f_1;
   var tmp0_0 = add(tmp0, fromInt(other));
   // Inline function 'kotlin.Long.plus' call
-  var other_0 = $this.d1g_1;
+  var other_0 = $this.y1f_1;
   return add(tmp0_0, fromInt(other_0));
 }
 function tryEmitLocked($this, value) {
-  if ($this.f1g_1 === 0)
+  if ($this.a1g_1 === 0)
     return tryEmitNoCollectorsLocked($this, value);
-  if ($this.c1g_1 >= $this.x1f_1 && compare($this.b1g_1, $this.a1g_1) <= 0) {
-    switch ($this.y1f_1.s1_1) {
+  if ($this.x1f_1 >= $this.s1f_1 && compare($this.w1f_1, $this.v1f_1) <= 0) {
+    switch ($this.t1f_1.s1_1) {
       case 0:
         return false;
       case 2:
@@ -132,43 +132,43 @@ function tryEmitLocked($this, value) {
     }
   }
   enqueueLocked($this, value);
-  $this.c1g_1 = $this.c1g_1 + 1 | 0;
-  if ($this.c1g_1 > $this.x1f_1) {
+  $this.x1f_1 = $this.x1f_1 + 1 | 0;
+  if ($this.x1f_1 > $this.s1f_1) {
     dropOldestLocked($this);
   }
-  if (_get_replaySize__dxgnb1($this) > $this.w1f_1) {
+  if (_get_replaySize__dxgnb1($this) > $this.r1f_1) {
     // Inline function 'kotlin.Long.plus' call
-    var this_0 = $this.a1g_1;
+    var this_0 = $this.v1f_1;
     var tmp$ret$0 = add(this_0, fromInt(1));
-    updateBufferLocked($this, tmp$ret$0, $this.b1g_1, _get_bufferEndIndex__d2rk18($this), _get_queueEndIndex__4m025l($this));
+    updateBufferLocked($this, tmp$ret$0, $this.w1f_1, _get_bufferEndIndex__d2rk18($this), _get_queueEndIndex__4m025l($this));
   }
   return true;
 }
 function tryEmitNoCollectorsLocked($this, value) {
   // Inline function 'kotlinx.coroutines.assert' call
-  if ($this.w1f_1 === 0)
+  if ($this.r1f_1 === 0)
     return true;
   enqueueLocked($this, value);
-  $this.c1g_1 = $this.c1g_1 + 1 | 0;
-  if ($this.c1g_1 > $this.w1f_1) {
+  $this.x1f_1 = $this.x1f_1 + 1 | 0;
+  if ($this.x1f_1 > $this.r1f_1) {
     dropOldestLocked($this);
   }
   var tmp = $this;
   var tmp0 = _get_head__d7jo8b($this);
   // Inline function 'kotlin.Long.plus' call
-  var other = $this.c1g_1;
-  tmp.b1g_1 = add(tmp0, fromInt(other));
+  var other = $this.x1f_1;
+  tmp.w1f_1 = add(tmp0, fromInt(other));
   return true;
 }
 function dropOldestLocked($this) {
-  setBufferAt(ensureNotNull($this.z1f_1), _get_head__d7jo8b($this), null);
-  $this.c1g_1 = $this.c1g_1 - 1 | 0;
+  setBufferAt(ensureNotNull($this.u1f_1), _get_head__d7jo8b($this), null);
+  $this.x1f_1 = $this.x1f_1 - 1 | 0;
   // Inline function 'kotlin.Long.plus' call
   var this_0 = _get_head__d7jo8b($this);
   var newHead = add(this_0, fromInt(1));
-  if (compare($this.a1g_1, newHead) < 0)
-    $this.a1g_1 = newHead;
-  if (compare($this.b1g_1, newHead) < 0) {
+  if (compare($this.v1f_1, newHead) < 0)
+    $this.v1f_1 = newHead;
+  if (compare($this.w1f_1, newHead) < 0) {
     correctCollectorIndexesOnDropOldest($this, newHead);
   }
   // Inline function 'kotlinx.coroutines.assert' call
@@ -176,10 +176,10 @@ function dropOldestLocked($this) {
 function correctCollectorIndexesOnDropOldest($this, newHead) {
   $l$block: {
     // Inline function 'kotlinx.coroutines.flow.internal.AbstractSharedFlow.forEachSlotLocked' call
-    if ($this.f1g_1 === 0) {
+    if ($this.a1g_1 === 0) {
       break $l$block;
     }
-    var tmp0_safe_receiver = $this.e1g_1;
+    var tmp0_safe_receiver = $this.z1f_1;
     if (tmp0_safe_receiver == null)
       null;
     else {
@@ -190,18 +190,18 @@ function correctCollectorIndexesOnDropOldest($this, newHead) {
         var element = tmp0_safe_receiver[inductionVariable];
         inductionVariable = inductionVariable + 1 | 0;
         if (!(element == null)) {
-          if (compare(element.i1g_1, new (Long())(0, 0)) >= 0 && compare(element.i1g_1, newHead) < 0) {
-            element.i1g_1 = newHead;
+          if (compare(element.d1g_1, new (Long())(0, 0)) >= 0 && compare(element.d1g_1, newHead) < 0) {
+            element.d1g_1 = newHead;
           }
         }
       }
     }
   }
-  $this.b1g_1 = newHead;
+  $this.w1f_1 = newHead;
 }
 function enqueueLocked($this, item) {
   var curSize = _get_totalSize__xhdb3o($this);
-  var curBuffer = $this.z1f_1;
+  var curBuffer = $this.u1f_1;
   var buffer = curBuffer == null ? growBuffer($this, null, 0, 2) : curSize >= curBuffer.length ? growBuffer($this, curBuffer, curSize, imul(curBuffer.length, 2)) : curBuffer;
   // Inline function 'kotlin.Long.plus' call
   var this_0 = _get_head__d7jo8b($this);
@@ -217,7 +217,7 @@ function growBuffer($this, curBuffer, curSize, newSize) {
   // Inline function 'kotlin.arrayOfNulls' call
   // Inline function 'kotlin.also' call
   var this_0 = Array(newSize);
-  $this.z1f_1 = this_0;
+  $this.u1f_1 = this_0;
   var newBuffer = this_0;
   if (curBuffer == null)
     return newBuffer;
@@ -242,7 +242,7 @@ function *emitSuspend($this, value, $completion) {
   (yield () => {
     var uCont = $completion;
     var cancellable = new (CancellableContinuationImpl())(intercepted(uCont), 1);
-    cancellable.w10();
+    cancellable.r10();
     var resumes = get_EMPTY_RESUMES();
     // Inline function 'kotlinx.coroutines.internal.synchronized' call
     // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
@@ -264,9 +264,9 @@ function *emitSuspend($this, value, $completion) {
       // Inline function 'kotlin.also' call
       var this_0 = new (Emitter())($this, tmp$ret$9, value, cancellable);
       enqueueLocked($this, this_0);
-      var _unary__edvuaz = $this.d1g_1;
-      $this.d1g_1 = _unary__edvuaz + 1 | 0;
-      if ($this.x1f_1 === 0)
+      var _unary__edvuaz = $this.y1f_1;
+      $this.y1f_1 = _unary__edvuaz + 1 | 0;
+      if ($this.s1f_1 === 0)
         resumes = findSlotsToResumeLocked($this, resumes);
       tmp$ret$6 = this_0;
     }
@@ -292,19 +292,19 @@ function *emitSuspend($this, value, $completion) {
         r.yc(tmp$ret$15);
       }
     }
-    return cancellable.x10();
+    return cancellable.s10();
   });
   return Unit_instance;
 }
 function cancelEmitter($this, emitter) {
   // Inline function 'kotlinx.coroutines.internal.synchronized' call
   // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
-  if (compare(emitter.l1g_1, _get_head__d7jo8b($this)) < 0)
+  if (compare(emitter.g1g_1, _get_head__d7jo8b($this)) < 0)
     return Unit_instance;
-  var buffer = ensureNotNull($this.z1f_1);
-  if (!(getBufferAt(buffer, emitter.l1g_1) === emitter))
+  var buffer = ensureNotNull($this.u1f_1);
+  if (!(getBufferAt(buffer, emitter.g1g_1) === emitter))
     return Unit_instance;
-  setBufferAt(buffer, emitter.l1g_1, get_NO_VALUE());
+  setBufferAt(buffer, emitter.g1g_1, get_NO_VALUE());
   cleanupTailLocked($this);
   return Unit_instance;
 }
@@ -317,24 +317,24 @@ function updateBufferLocked($this, newReplayIndex, newMinCollectorIndex, newBuff
     do {
       var index = inductionVariable;
       inductionVariable = add(inductionVariable, new (Long())(1, 0));
-      setBufferAt(ensureNotNull($this.z1f_1), index, null);
+      setBufferAt(ensureNotNull($this.u1f_1), index, null);
     }
      while (compare(inductionVariable, newHead) < 0);
-  $this.a1g_1 = newReplayIndex;
-  $this.b1g_1 = newMinCollectorIndex;
-  $this.c1g_1 = convertToInt(subtract(newBufferEndIndex, newHead));
-  $this.d1g_1 = convertToInt(subtract(newQueueEndIndex, newBufferEndIndex));
+  $this.v1f_1 = newReplayIndex;
+  $this.w1f_1 = newMinCollectorIndex;
+  $this.x1f_1 = convertToInt(subtract(newBufferEndIndex, newHead));
+  $this.y1f_1 = convertToInt(subtract(newQueueEndIndex, newBufferEndIndex));
   // Inline function 'kotlinx.coroutines.assert' call
   // Inline function 'kotlinx.coroutines.assert' call
   // Inline function 'kotlinx.coroutines.assert' call
 }
 function cleanupTailLocked($this) {
-  if ($this.x1f_1 === 0 && $this.d1g_1 <= 1)
+  if ($this.s1f_1 === 0 && $this.y1f_1 <= 1)
     return Unit_instance;
-  var buffer = ensureNotNull($this.z1f_1);
+  var buffer = ensureNotNull($this.u1f_1);
   $l$loop: while (true) {
     var tmp;
-    if ($this.d1g_1 > 0) {
+    if ($this.y1f_1 > 0) {
       var tmp0 = _get_head__d7jo8b($this);
       // Inline function 'kotlin.Long.plus' call
       var other = _get_totalSize__xhdb3o($this);
@@ -348,7 +348,7 @@ function cleanupTailLocked($this) {
     if (!tmp) {
       break $l$loop;
     }
-    $this.d1g_1 = $this.d1g_1 - 1 | 0;
+    $this.y1f_1 = $this.y1f_1 - 1 | 0;
     var tmp0_0 = _get_head__d7jo8b($this);
     // Inline function 'kotlin.Long.plus' call
     var other_0 = _get_totalSize__xhdb3o($this);
@@ -365,12 +365,12 @@ function tryTakeValue($this, slot) {
   if (compare(index, new (Long())(0, 0)) < 0) {
     tmp = get_NO_VALUE();
   } else {
-    var oldIndex = slot.i1g_1;
+    var oldIndex = slot.d1g_1;
     var newValue = getPeekedValueLockedAt($this, index);
     var tmp_0 = slot;
     // Inline function 'kotlin.Long.plus' call
-    tmp_0.i1g_1 = add(index, fromInt(1));
-    resumes = $this.o1g(oldIndex);
+    tmp_0.d1g_1 = add(index, fromInt(1));
+    resumes = $this.j1g(oldIndex);
     tmp = newValue;
   }
   var value = tmp;
@@ -392,22 +392,22 @@ function tryTakeValue($this, slot) {
   return value;
 }
 function tryPeekLocked($this, slot) {
-  var index = slot.i1g_1;
+  var index = slot.d1g_1;
   if (compare(index, _get_bufferEndIndex__d2rk18($this)) < 0)
     return index;
-  if ($this.x1f_1 > 0)
+  if ($this.s1f_1 > 0)
     return new (Long())(-1, -1);
   if (compare(index, _get_head__d7jo8b($this)) > 0)
     return new (Long())(-1, -1);
-  if ($this.d1g_1 === 0)
+  if ($this.y1f_1 === 0)
     return new (Long())(-1, -1);
   return index;
 }
 function getPeekedValueLockedAt($this, index) {
-  var item = getBufferAt(ensureNotNull($this.z1f_1), index);
+  var item = getBufferAt(ensureNotNull($this.u1f_1), index);
   var tmp;
   if (item instanceof Emitter()) {
-    tmp = item.m1g_1;
+    tmp = item.h1g_1;
   } else {
     tmp = item;
   }
@@ -419,13 +419,13 @@ function *awaitValue($this, slot, $completion) {
   (yield () => {
     var uCont = $completion;
     var cancellable = new (CancellableContinuationImpl())(intercepted(uCont), 1);
-    cancellable.w10();
+    cancellable.r10();
     // Inline function 'kotlinx.coroutines.internal.synchronized' call
     // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
     $l$block: {
       var index = tryPeekLocked($this, slot);
       if (compare(index, new (Long())(0, 0)) < 0) {
-        slot.j1g_1 = cancellable;
+        slot.e1g_1 = cancellable;
       } else {
         // Inline function 'kotlin.coroutines.resume' call
         // Inline function 'kotlin.Companion.success' call
@@ -433,9 +433,9 @@ function *awaitValue($this, slot, $completion) {
         cancellable.yc(tmp$ret$8);
         break $l$block;
       }
-      slot.j1g_1 = cancellable;
+      slot.e1g_1 = cancellable;
     }
-    return cancellable.x10();
+    return cancellable.s10();
   });
   return Unit_instance;
 }
@@ -444,10 +444,10 @@ function findSlotsToResumeLocked($this, resumesIn) {
   var resumeCount = resumesIn.length;
   $l$block: {
     // Inline function 'kotlinx.coroutines.flow.internal.AbstractSharedFlow.forEachSlotLocked' call
-    if ($this.f1g_1 === 0) {
+    if ($this.a1g_1 === 0) {
       break $l$block;
     }
-    var tmp0_safe_receiver = $this.e1g_1;
+    var tmp0_safe_receiver = $this.z1f_1;
     if (tmp0_safe_receiver == null)
       null;
     else {
@@ -459,7 +459,7 @@ function findSlotsToResumeLocked($this, resumesIn) {
         inductionVariable = inductionVariable + 1 | 0;
         if (!(element == null)) {
           $l$block_1: {
-            var tmp0_elvis_lhs = element.j1g_1;
+            var tmp0_elvis_lhs = element.e1g_1;
             var tmp;
             if (tmp0_elvis_lhs == null) {
               break $l$block_1;
@@ -481,7 +481,7 @@ function findSlotsToResumeLocked($this, resumesIn) {
             var _unary__edvuaz = resumeCount;
             resumeCount = _unary__edvuaz + 1 | 0;
             tmp_1[_unary__edvuaz] = cont;
-            element.j1g_1 = null;
+            element.e1g_1 = null;
           }
         }
       }
@@ -494,13 +494,13 @@ function Emitter() {
   if (EmitterClass === VOID) {
     class $ {
       constructor(flow, index, value, cont) {
-        this.k1g_1 = flow;
-        this.l1g_1 = index;
-        this.m1g_1 = value;
-        this.n1g_1 = cont;
+        this.f1g_1 = flow;
+        this.g1g_1 = index;
+        this.h1g_1 = value;
+        this.i1g_1 = cont;
       }
-      wz() {
-        return cancelEmitter(this.k1g_1, this);
+      rz() {
+        return cancelEmitter(this.f1g_1, this);
       }
     }
     initMetadataForClass($, 'Emitter');
@@ -514,18 +514,18 @@ function SharedFlowImpl() {
     class $ extends AbstractSharedFlow() {
       constructor(replay, bufferCapacity, onBufferOverflow) {
         super();
-        this.w1f_1 = replay;
-        this.x1f_1 = bufferCapacity;
-        this.y1f_1 = onBufferOverflow;
-        this.z1f_1 = null;
-        this.a1g_1 = new (Long())(0, 0);
-        this.b1g_1 = new (Long())(0, 0);
-        this.c1g_1 = 0;
-        this.d1g_1 = 0;
+        this.r1f_1 = replay;
+        this.s1f_1 = bufferCapacity;
+        this.t1f_1 = onBufferOverflow;
+        this.u1f_1 = null;
+        this.v1f_1 = new (Long())(0, 0);
+        this.w1f_1 = new (Long())(0, 0);
+        this.x1f_1 = 0;
+        this.y1f_1 = 0;
       }
-      p1g() {
-        var tmp = ensureNotNull(this.z1f_1);
-        var tmp0 = this.a1g_1;
+      k1g() {
+        var tmp = ensureNotNull(this.u1f_1);
+        var tmp0 = this.v1f_1;
         // Inline function 'kotlin.Long.plus' call
         var other = _get_replaySize__dxgnb1(this);
         // Inline function 'kotlin.Long.minus' call
@@ -533,11 +533,11 @@ function SharedFlowImpl() {
         var tmp$ret$1 = subtract(this_0, fromInt(1));
         return getBufferAt(tmp, tmp$ret$1);
       }
-      *q1g(collector, $completion) {
-        var slot = this.r1g();
+      *l1g(collector, $completion) {
+        var slot = this.m1g();
         try {
           if (collector instanceof SubscribedFlowCollector())
-            yield* collector.u1g($completion);
+            yield* collector.p1g($completion);
           // Inline function 'kotlinx.coroutines.currentCoroutineContext' call
           // Inline function 'kotlin.js.getCoroutineContext' call
           var collectorJob = $completion.wc().id(Key_instance);
@@ -554,16 +554,16 @@ function SharedFlowImpl() {
             else {
               ensureActive(collectorJob);
             }
-            yield* collector.m1f(newValue, $completion);
+            yield* collector.h1f(newValue, $completion);
           }
         }finally {
-          this.v1g(slot);
+          this.q1g(slot);
         }
       }
-      u1e(collector, $completion) {
-        return this.q1g(collector, $completion);
+      p1e(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
-      w1g(value) {
+      r1g(value) {
         var resumes = get_EMPTY_RESUMES();
         // Inline function 'kotlinx.coroutines.internal.synchronized' call
         // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
@@ -592,36 +592,36 @@ function SharedFlowImpl() {
         }
         return emitted;
       }
-      *m1f(value, $completion) {
-        if (this.w1g(value))
+      *h1f(value, $completion) {
+        if (this.r1g(value))
           return Unit_instance;
         yield* /*#__NOINLINE__*/emitSuspend(this, value, $completion);
         return Unit_instance;
       }
-      x1g() {
-        var index = this.a1g_1;
-        if (compare(index, this.b1g_1) < 0)
-          this.b1g_1 = index;
+      s1g() {
+        var index = this.v1f_1;
+        if (compare(index, this.w1f_1) < 0)
+          this.w1f_1 = index;
         return index;
       }
-      o1g(oldIndex) {
+      j1g(oldIndex) {
         // Inline function 'kotlinx.coroutines.assert' call
-        if (compare(oldIndex, this.b1g_1) > 0)
+        if (compare(oldIndex, this.w1f_1) > 0)
           return get_EMPTY_RESUMES();
         var head = _get_head__d7jo8b(this);
         // Inline function 'kotlin.Long.plus' call
-        var other = this.c1g_1;
+        var other = this.x1f_1;
         var newMinCollectorIndex = add(head, fromInt(other));
-        if (this.x1f_1 === 0 && this.d1g_1 > 0) {
+        if (this.s1f_1 === 0 && this.y1f_1 > 0) {
           var _unary__edvuaz = newMinCollectorIndex;
           newMinCollectorIndex = add(_unary__edvuaz, get_ONE());
         }
         $l$block: {
           // Inline function 'kotlinx.coroutines.flow.internal.AbstractSharedFlow.forEachSlotLocked' call
-          if (this.f1g_1 === 0) {
+          if (this.a1g_1 === 0) {
             break $l$block;
           }
-          var tmp0_safe_receiver = this.e1g_1;
+          var tmp0_safe_receiver = this.z1f_1;
           if (tmp0_safe_receiver == null)
             null;
           else {
@@ -632,37 +632,37 @@ function SharedFlowImpl() {
               var element = tmp0_safe_receiver[inductionVariable];
               inductionVariable = inductionVariable + 1 | 0;
               if (!(element == null)) {
-                if (compare(element.i1g_1, new (Long())(0, 0)) >= 0 && compare(element.i1g_1, newMinCollectorIndex) < 0)
-                  newMinCollectorIndex = element.i1g_1;
+                if (compare(element.d1g_1, new (Long())(0, 0)) >= 0 && compare(element.d1g_1, newMinCollectorIndex) < 0)
+                  newMinCollectorIndex = element.d1g_1;
               }
             }
           }
         }
         // Inline function 'kotlinx.coroutines.assert' call
-        if (compare(newMinCollectorIndex, this.b1g_1) <= 0)
+        if (compare(newMinCollectorIndex, this.w1f_1) <= 0)
           return get_EMPTY_RESUMES();
         var newBufferEndIndex = _get_bufferEndIndex__d2rk18(this);
         var tmp;
-        if (this.f1g_1 > 0) {
+        if (this.a1g_1 > 0) {
           var newBufferSize0 = convertToInt(subtract(newBufferEndIndex, newMinCollectorIndex));
-          var tmp0 = this.d1g_1;
+          var tmp0 = this.y1f_1;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = this.x1f_1 - newBufferSize0 | 0;
+          var b = this.s1f_1 - newBufferSize0 | 0;
           tmp = Math.min(tmp0, b);
         } else {
-          tmp = this.d1g_1;
+          tmp = this.y1f_1;
         }
         var maxResumeCount = tmp;
         var resumes = get_EMPTY_RESUMES();
         var tmp0_0 = newBufferEndIndex;
         // Inline function 'kotlin.Long.plus' call
-        var other_0 = this.d1g_1;
+        var other_0 = this.y1f_1;
         var newQueueEndIndex = add(tmp0_0, fromInt(other_0));
         if (maxResumeCount > 0) {
           // Inline function 'kotlin.arrayOfNulls' call
           resumes = Array(maxResumeCount);
           var resumeCount = 0;
-          var buffer = ensureNotNull(this.z1f_1);
+          var buffer = ensureNotNull(this.u1f_1);
           var inductionVariable_0 = newBufferEndIndex;
           if (compare(inductionVariable_0, newQueueEndIndex) < 0)
             $l$loop: do {
@@ -675,9 +675,9 @@ function SharedFlowImpl() {
                 var tmp_0 = resumes;
                 var _unary__edvuaz_0 = resumeCount;
                 resumeCount = _unary__edvuaz_0 + 1 | 0;
-                tmp_0[_unary__edvuaz_0] = emitter.n1g_1;
+                tmp_0[_unary__edvuaz_0] = emitter.i1g_1;
                 setBufferAt(buffer, curEmitterIndex, get_NO_VALUE());
-                setBufferAt(buffer, newBufferEndIndex, emitter.m1g_1);
+                setBufferAt(buffer, newBufferEndIndex, emitter.h1g_1);
                 var _unary__edvuaz_1 = newBufferEndIndex;
                 newBufferEndIndex = add(_unary__edvuaz_1, get_ONE());
                 if (resumeCount >= maxResumeCount)
@@ -687,18 +687,18 @@ function SharedFlowImpl() {
              while (compare(inductionVariable_0, newQueueEndIndex) < 0);
         }
         var newBufferSize1 = convertToInt(subtract(newBufferEndIndex, head));
-        if (this.f1g_1 === 0)
+        if (this.a1g_1 === 0)
           newMinCollectorIndex = newBufferEndIndex;
-        var tmp0_1 = this.a1g_1;
+        var tmp0_1 = this.v1f_1;
         var tmp0_2 = newBufferEndIndex;
         // Inline function 'kotlin.comparisons.minOf' call
-        var a = this.w1f_1;
+        var a = this.r1f_1;
         // Inline function 'kotlin.Long.minus' call
         var other_1 = Math.min(a, newBufferSize1);
         // Inline function 'kotlin.comparisons.maxOf' call
         var b_0 = subtract(tmp0_2, fromInt(other_1));
         var newReplayIndex = compare(tmp0_1, b_0) >= 0 ? tmp0_1 : b_0;
-        if (this.x1f_1 === 0 && compare(newReplayIndex, newQueueEndIndex) < 0 && equals(getBufferAt(ensureNotNull(this.z1f_1), newReplayIndex), get_NO_VALUE())) {
+        if (this.s1f_1 === 0 && compare(newReplayIndex, newQueueEndIndex) < 0 && equals(getBufferAt(ensureNotNull(this.u1f_1), newReplayIndex), get_NO_VALUE())) {
           var _unary__edvuaz_2 = newBufferEndIndex;
           newBufferEndIndex = add(_unary__edvuaz_2, get_ONE());
           var _unary__edvuaz_3 = newReplayIndex;
@@ -712,18 +712,18 @@ function SharedFlowImpl() {
           resumes = findSlotsToResumeLocked(this, resumes);
         return resumes;
       }
-      y1g() {
+      t1g() {
         return new (SharedFlowSlot())();
       }
-      z1g(size) {
+      u1g(size) {
         // Inline function 'kotlin.arrayOfNulls' call
         return Array(size);
       }
-      g1f(context, capacity, onBufferOverflow) {
+      b1f(context, capacity, onBufferOverflow) {
         return fuseSharedFlow(this, context, capacity, onBufferOverflow);
       }
     }
-    protoOf($).h1f = fuse$default;
+    protoOf($).c1f = fuse$default;
     initMetadataForClass($, 'SharedFlowImpl', VOID, VOID, [FlowCollector(), FusibleFlow()], [1]);
     SharedFlowImplClass = $;
   }
@@ -735,27 +735,27 @@ function SharedFlowSlot() {
     class $ extends AbstractSharedFlowSlot() {
       constructor() {
         super();
-        this.i1g_1 = new (Long())(-1, -1);
-        this.j1g_1 = null;
+        this.d1g_1 = new (Long())(-1, -1);
+        this.e1g_1 = null;
       }
-      b1h(flow) {
-        if (compare(this.i1g_1, new (Long())(0, 0)) >= 0)
+      w1g(flow) {
+        if (compare(this.d1g_1, new (Long())(0, 0)) >= 0)
           return false;
-        this.i1g_1 = flow.x1g();
+        this.d1g_1 = flow.s1g();
         return true;
       }
-      c1h(flow) {
-        return this.b1h(flow instanceof SharedFlowImpl() ? flow : THROW_CCE());
+      x1g(flow) {
+        return this.w1g(flow instanceof SharedFlowImpl() ? flow : THROW_CCE());
       }
-      d1h(flow) {
+      y1g(flow) {
         // Inline function 'kotlinx.coroutines.assert' call
-        var oldIndex = this.i1g_1;
-        this.i1g_1 = new (Long())(-1, -1);
-        this.j1g_1 = null;
-        return flow.o1g(oldIndex);
+        var oldIndex = this.d1g_1;
+        this.d1g_1 = new (Long())(-1, -1);
+        this.e1g_1 = null;
+        return flow.j1g(oldIndex);
       }
-      e1h(flow) {
-        return this.d1h(flow instanceof SharedFlowImpl() ? flow : THROW_CCE());
+      z1g(flow) {
+        return this.y1g(flow instanceof SharedFlowImpl() ? flow : THROW_CCE());
       }
     }
     initMetadataForClass($, 'SharedFlowSlot', SharedFlowSlot);