@attocash/commons-test 6.0.0

package/kotlinx-coroutines-core/kotlinx/coroutines/channels/BufferedChannel.mjs

@@ -0,0 +1,2791 @@
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  Segmentqmq1glevgieu as Segment,
+  closefimrnzr4lu35 as close,
+  findSegmentInternal35lxp6iondi3q as findSegmentInternal,
+  _SegmentOrClosed___get_segment__impl__jvcr9l1chmpjvbuseuk as _SegmentOrClosed___get_segment__impl__jvcr9l,
+  _SegmentOrClosed___get_isClosed__impl__qmxmlo3e3mrt157zasn as _SegmentOrClosed___get_isClosed__impl__qmxmlo,
+  SegmentOrCloseds3xpxfs4wrg9 as SegmentOrClosed,
+} from '../internal/ConcurrentLinkedList.mjs';
+import { atomicfu$AtomicRefArray$ofNulls2kz3j9ehigwa3 as atomicfu$AtomicRefArray$ofNulls } from '../../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.common.mjs';
+import {
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Waiter3lxa2a79zyo0g as Waiter } from '../Waiter.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { toString30pk9tzaqopn as toString } from '../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import {
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  NoSuchElementException679xzhnp5bpj as NoSuchElementException,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString_0,
+  protoOf180f3jzyo7rfj as protoOf,
+  equals2au1ep9vhcato as equals,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  callUndeliveredElement5xsmnofvtcme as callUndeliveredElement,
+  callUndeliveredElementCatchingException6xwxmojd3rq1 as callUndeliveredElementCatchingException,
+} from '../internal/OnUndeliveredElement.mjs';
+import {
+  fromInt2ii0rejb1w62w as fromInt,
+  multiply2k9eolhnz1bjv as multiply,
+  add2suhfggl4zvkk as add,
+  dividelr0uqtdj497z as divide,
+  modulooi4g1kq3dmtt as modulo,
+  convertToInty04h231mmjoh as convertToInt,
+  shiftRight2gqph14wydb8s as shiftRight,
+  subtract2orl8z9upxd9l as subtract,
+  shiftLeft3tsh2sstjchzn as shiftLeft,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  recoverStackTrace3k4hvtb53ci4z as recoverStackTrace,
+  recoverStackTrace2i3si2i8nvw1k as recoverStackTrace_0,
+} from '../internal/StackTraceRecovery.mjs';
+import {
+  intercepted2ogpsikxxj4u0 as intercepted,
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import {
+  getOrCreateCancellableContinuation2t1o0dr9l9i36 as getOrCreateCancellableContinuation,
+  CancellableContinuationpb2x00mxmcbt as CancellableContinuation,
+} from '../CancellableContinuation.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  createFailure8paxfkfa5dc7 as createFailure,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl } from '../CancellableContinuationImpl.mjs';
+import { addSuppressedu5jwjfvsc039 as addSuppressed } from '../../../../kotlin-kotlin-stdlib/kotlin/throwableExtensions.mjs';
+import {
+  Companion_getInstance8sxi3cktwbr5 as Companion_getInstance,
+  ChannelResult2y4k69ac6y3du as ChannelResult,
+  ClosedReceiveChannelException3ofg6gf5f5b38 as ClosedReceiveChannelException,
+  ChannelResult__getOrNull_impl_f5e07h1mddh1y59r3zw as ChannelResult__getOrNull_impl_f5e07h,
+  ClosedSendChannelException29m33prpq9jaw as ClosedSendChannelException,
+  close$default3plsfhsdbsvbv as close$default,
+  cancel$default2g4arzbcb5isa as cancel$default,
+  SendChannel38sllbxw662ws as SendChannel,
+  ReceiveChannel24wu5e2tj9lbp as ReceiveChannel,
+} from './Channel.mjs';
+import {
+  SelectInstance2isepgzfsd8ur as SelectInstance,
+  SelectImplementation59ci94k9x9wm as SelectImplementation,
+  TrySelectDetailedResult_REREGISTER_getInstance2a0bjw99yymto as TrySelectDetailedResult_REREGISTER_getInstance,
+  TrySelectDetailedResult_SUCCESSFUL_getInstance2uasownw8ahu5 as TrySelectDetailedResult_SUCCESSFUL_getInstance,
+} from '../selects/Select.mjs';
+import {
+  _InlineList___init__impl__z8n562662s9jzwcbcg as _InlineList___init__impl__z8n56,
+  InlineList__plus_impl_nuetvo2kefjf4xs4r0z as InlineList__plus_impl_nuetvo,
+  access$_get_holder__kkflen2dpfhuyt7ng33 as access$_get_holder__kkflen,
+} from '../internal/InlineList.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import {
+  atomic$long$129k9zwo6n9ogd as atomic$long$1,
+  atomic$ref$130aurmcwdfdf1 as atomic$ref$1,
+} from '../../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs';
+import { CancellationException3b36o9qz53rgr as CancellationException } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/cancellation/CancellationException.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../../../../kotlin-kotlin-stdlib/kotlin/text/StringBuilderJs.mjs';
+import { listOf1jh22dvmctj1r as listOf } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { compareTo3ankvs086tmwq as compareTo } from '../../../../kotlin-kotlin-stdlib/kotlin/js/compareTo.mjs';
+import { last2n4gf5az1lkn4 as last } from '../../../../kotlin-kotlin-stdlib/kotlin/text/_Strings.mjs';
+import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { systemProp2qpti4y1f5b4b as systemProp } from '../internal/SystemProps.common.mjs';
+import { Symbol17xuwzgi5g8ve as Symbol } from '../internal/Symbol.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function get_NULL_SEGMENT() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return NULL_SEGMENT;
+}
+var NULL_SEGMENT;
+function get_SEGMENT_SIZE() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return SEGMENT_SIZE;
+}
+var SEGMENT_SIZE;
+function get_EXPAND_BUFFER_COMPLETION_WAIT_ITERATIONS() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return EXPAND_BUFFER_COMPLETION_WAIT_ITERATIONS;
+}
+var EXPAND_BUFFER_COMPLETION_WAIT_ITERATIONS;
+function get_BUFFERED() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return BUFFERED;
+}
+var BUFFERED;
+function get_IN_BUFFER() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return IN_BUFFER;
+}
+var IN_BUFFER;
+function get_RESUMING_BY_RCV() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return RESUMING_BY_RCV;
+}
+var RESUMING_BY_RCV;
+function get_RESUMING_BY_EB() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return RESUMING_BY_EB;
+}
+var RESUMING_BY_EB;
+function get_POISONED() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return POISONED;
+}
+var POISONED;
+function get_DONE_RCV() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return DONE_RCV;
+}
+var DONE_RCV;
+function get_INTERRUPTED_SEND() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return INTERRUPTED_SEND;
+}
+var INTERRUPTED_SEND;
+function get_INTERRUPTED_RCV() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return INTERRUPTED_RCV;
+}
+var INTERRUPTED_RCV;
+function get_CHANNEL_CLOSED() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return CHANNEL_CLOSED;
+}
+var CHANNEL_CLOSED;
+function get_SUSPEND() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return SUSPEND;
+}
+var SUSPEND;
+function get_SUSPEND_NO_WAITER() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return SUSPEND_NO_WAITER;
+}
+var SUSPEND_NO_WAITER;
+function get_FAILED() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return FAILED;
+}
+var FAILED;
+function get_NO_RECEIVE_RESULT() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return NO_RECEIVE_RESULT;
+}
+var NO_RECEIVE_RESULT;
+function get_CLOSE_HANDLER_CLOSED() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return CLOSE_HANDLER_CLOSED;
+}
+var CLOSE_HANDLER_CLOSED;
+function get_CLOSE_HANDLER_INVOKED() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return CLOSE_HANDLER_INVOKED;
+}
+var CLOSE_HANDLER_INVOKED;
+function get_NO_CLOSE_CAUSE() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return NO_CLOSE_CAUSE;
+}
+var NO_CLOSE_CAUSE;
+function setElementLazy($this, index, value) {
+  // Inline function 'kotlinx.atomicfu.AtomicRef.lazySet' call
+  $this.e14_1.atomicfu$get(imul(index, 2)).kotlinx$atomicfu$value = value;
+}
+var ChannelSegmentClass;
+function ChannelSegment() {
+  if (ChannelSegmentClass === VOID) {
+    class $ extends Segment() {
+      constructor(id, prev, channel, pointers) {
+        super(id, prev, pointers);
+        this.d14_1 = channel;
+        this.e14_1 = atomicfu$AtomicRefArray$ofNulls(imul(get_SEGMENT_SIZE(), 2));
+      }
+      f14() {
+        return ensureNotNull(this.d14_1);
+      }
+      g14() {
+        return get_SEGMENT_SIZE();
+      }
+      h14(index, element) {
+        setElementLazy(this, index, element);
+      }
+      i14(index) {
+        var tmp = this.e14_1.atomicfu$get(imul(index, 2)).kotlinx$atomicfu$value;
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      j14(index) {
+        // Inline function 'kotlin.also' call
+        var this_0 = this.i14(index);
+        this.k14(index);
+        return this_0;
+      }
+      k14(index) {
+        setElementLazy(this, index, null);
+      }
+      l14(index) {
+        return this.e14_1.atomicfu$get(imul(index, 2) + 1 | 0).kotlinx$atomicfu$value;
+      }
+      m14(index, value) {
+        this.e14_1.atomicfu$get(imul(index, 2) + 1 | 0).kotlinx$atomicfu$value = value;
+      }
+      n14(index, from, to) {
+        return this.e14_1.atomicfu$get(imul(index, 2) + 1 | 0).atomicfu$compareAndSet(from, to);
+      }
+      o14(index, update) {
+        return this.e14_1.atomicfu$get(imul(index, 2) + 1 | 0).atomicfu$getAndSet(update);
+      }
+      zw(index, cause, context) {
+        var isSender = index >= get_SEGMENT_SIZE();
+        var index_0 = isSender ? index - get_SEGMENT_SIZE() | 0 : index;
+        var element = this.i14(index_0);
+        $l$loop: while (true) {
+          var cur = this.l14(index_0);
+          var tmp;
+          if (!(cur == null) ? isInterface(cur, Waiter()) : false) {
+            tmp = true;
+          } else {
+            tmp = cur instanceof WaiterEB();
+          }
+          if (tmp) {
+            var update = isSender ? get_INTERRUPTED_SEND() : get_INTERRUPTED_RCV();
+            if (this.n14(index_0, cur, update)) {
+              this.k14(index_0);
+              this.b15(index_0, !isSender);
+              if (isSender) {
+                var tmp0_safe_receiver = this.f14().q14_1;
+                if (tmp0_safe_receiver == null)
+                  null;
+                else {
+                  callUndeliveredElement(tmp0_safe_receiver, element, context);
+                }
+              }
+              return Unit_instance;
+            }
+          } else {
+            if (cur === get_INTERRUPTED_SEND() || cur === get_INTERRUPTED_RCV()) {
+              this.k14(index_0);
+              if (isSender) {
+                var tmp1_safe_receiver = this.f14().q14_1;
+                if (tmp1_safe_receiver == null)
+                  null;
+                else {
+                  callUndeliveredElement(tmp1_safe_receiver, element, context);
+                }
+              }
+              return Unit_instance;
+            } else {
+              if (cur === get_RESUMING_BY_EB() || cur === get_RESUMING_BY_RCV())
+                continue $l$loop;
+              else {
+                if (cur === get_DONE_RCV() || cur === get_BUFFERED())
+                  return Unit_instance;
+                else {
+                  if (cur === get_CHANNEL_CLOSED())
+                    return Unit_instance;
+                  else {
+                    // Inline function 'kotlin.error' call
+                    var message = 'unexpected state: ' + toString(cur);
+                    throw IllegalStateException().w4(toString_0(message));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      b15(index, receiver) {
+        if (receiver) {
+          var tmp = this.f14();
+          var tmp0 = this.xw_1;
+          // Inline function 'kotlin.Long.times' call
+          var other = get_SEGMENT_SIZE();
+          // Inline function 'kotlin.Long.plus' call
+          var this_0 = multiply(tmp0, fromInt(other));
+          var tmp$ret$1 = add(this_0, fromInt(index));
+          tmp.c15(tmp$ret$1);
+        }
+        this.d15();
+      }
+    }
+    initMetadataForClass($, 'ChannelSegment');
+    ChannelSegmentClass = $;
+  }
+  return ChannelSegmentClass;
+}
+function *_generator_hasNext__q471nr($this, $completion) {
+  var tmp;
+  if (!($this.p15_1 === get_NO_RECEIVE_RESULT()) && !($this.p15_1 === get_CHANNEL_CLOSED())) {
+    tmp = true;
+  } else {
+    var tmp0 = $this.r15_1;
+    var tmp$ret$1;
+    $l$block_0: {
+      // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+      var segment = tmp0.w14_1.kotlinx$atomicfu$value;
+      $l$loop_0: while (true) {
+        if (tmp0.s15()) {
+          tmp$ret$1 = onClosedHasNext($this);
+          break $l$block_0;
+        }
+        var r = tmp0.s14_1.atomicfu$getAndIncrement$long();
+        // Inline function 'kotlin.Long.div' call
+        var other = get_SEGMENT_SIZE();
+        var id = divide(r, fromInt(other));
+        // Inline function 'kotlin.Long.rem' call
+        var other_0 = get_SEGMENT_SIZE();
+        var tmp$ret$3 = modulo(r, fromInt(other_0));
+        var i = convertToInt(tmp$ret$3);
+        if (!(segment.xw_1 === id)) {
+          var tmp0_elvis_lhs = findSegmentReceive(tmp0, id, segment);
+          var tmp_0;
+          if (tmp0_elvis_lhs == null) {
+            continue $l$loop_0;
+          } else {
+            tmp_0 = tmp0_elvis_lhs;
+          }
+          segment = tmp_0;
+        }
+        var updCellResult = updateCellReceive(tmp0, segment, i, r, null);
+        var tmp_1;
+        if (updCellResult === get_SUSPEND()) {
+          var tmp1_safe_receiver = (!(null == null) ? isInterface(null, Waiter()) : false) ? null : null;
+          if (tmp1_safe_receiver == null)
+            null;
+          else {
+            prepareReceiverForSuspension(tmp0, tmp1_safe_receiver, segment, i);
+          }
+          var message = 'unreachable';
+          throw IllegalStateException().w4(toString_0(message));
+        } else if (updCellResult === get_FAILED()) {
+          if (r < tmp0.t15()) {
+            segment.n15();
+          }
+          continue $l$loop_0;
+        } else if (updCellResult === get_SUSPEND_NO_WAITER()) {
+          var segm = segment;
+          var tmp_2 = hasNextOnNoWaiterSuspend($this, segm, i, r, $completion);
+          if (tmp_2 === get_COROUTINE_SUSPENDED())
+            tmp_2 = yield tmp_2;
+          return tmp_2;
+        } else {
+          segment.n15();
+          $this.p15_1 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+          tmp_1 = true;
+        }
+        tmp$ret$1 = tmp_1;
+        break $l$block_0;
+      }
+    }
+    tmp = tmp$ret$1;
+  }
+  return tmp;
+}
+function onClosedHasNext($this) {
+  $this.p15_1 = get_CHANNEL_CLOSED();
+  var tmp0_elvis_lhs = $this.r15_1.u15();
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var cause = tmp;
+  throw recoverStackTrace(cause);
+}
+function hasNextOnNoWaiterSuspend($this, segment, index, r, $completion) {
+  var cancellable = getOrCreateCancellableContinuation(intercepted($completion));
+  try {
+    $this.q15_1 = cancellable;
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImplOnNoWaiter' call
+    var this_0 = $this.r15_1;
+    var updCellResult = updateCellReceive(this_0, segment, index, r, $this);
+    if (updCellResult === get_SUSPEND()) {
+      prepareReceiverForSuspension(this_0, $this, segment, index);
+    } else if (updCellResult === get_FAILED()) {
+      if (r < this_0.t15()) {
+        segment.n15();
+      }
+      $l$block_0: {
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+        var segment_0 = this_0.w14_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          if (this_0.s15()) {
+            onClosedHasNextNoWaiterSuspend($this);
+            break $l$block_0;
+          }
+          var r_0 = this_0.s14_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(r_0, fromInt(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$3 = modulo(r_0, fromInt(other_0));
+          var i = convertToInt(tmp$ret$3);
+          if (!(segment_0.xw_1 === id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this_0, id, segment_0);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              continue $l$loop_0;
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment_0 = tmp;
+          }
+          var updCellResult_0 = updateCellReceive(this_0, segment_0, i, r_0, $this);
+          if (updCellResult_0 === get_SUSPEND()) {
+            var tmp1_safe_receiver = (!($this == null) ? isInterface($this, Waiter()) : false) ? $this : null;
+            if (tmp1_safe_receiver == null)
+              null;
+            else {
+              prepareReceiverForSuspension(this_0, tmp1_safe_receiver, segment_0, i);
+            }
+          } else if (updCellResult_0 === get_FAILED()) {
+            if (r_0 < this_0.t15()) {
+              segment_0.n15();
+            }
+            continue $l$loop_0;
+          } else if (updCellResult_0 === get_SUSPEND_NO_WAITER()) {
+            // Inline function 'kotlin.error' call
+            var message = 'unexpected';
+            throw IllegalStateException().w4(toString_0(message));
+          } else {
+            segment_0.n15();
+            var element = (updCellResult_0 == null ? true : !(updCellResult_0 == null)) ? updCellResult_0 : THROW_CCE();
+            $this.p15_1 = element;
+            $this.q15_1 = null;
+            var tmp0_safe_receiver = $this.r15_1.q14_1;
+            cancellable.yv(true, tmp0_safe_receiver == null ? null : bindCancellationFun($this.r15_1, tmp0_safe_receiver, element));
+          }
+          break $l$block_0;
+        }
+      }
+    } else {
+      segment.n15();
+      var element_0 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+      $this.p15_1 = element_0;
+      $this.q15_1 = null;
+      var tmp0_safe_receiver_0 = $this.r15_1.q14_1;
+      cancellable.yv(true, tmp0_safe_receiver_0 == null ? null : bindCancellationFun($this.r15_1, tmp0_safe_receiver_0, element_0));
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.yx();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.xx();
+}
+function onClosedHasNextNoWaiterSuspend($this) {
+  var cont = ensureNotNull($this.q15_1);
+  $this.q15_1 = null;
+  $this.p15_1 = get_CHANNEL_CLOSED();
+  var cause = $this.r15_1.u15();
+  if (cause == null) {
+    // Inline function 'kotlin.coroutines.resume' call
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(false);
+    cont.vb(tmp$ret$0);
+  } else {
+    // Inline function 'kotlin.coroutines.resumeWithException' call
+    // Inline function 'kotlin.Companion.failure' call
+    var exception = recoverStackTrace_0(cause, cont);
+    var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(exception));
+    cont.vb(tmp$ret$2);
+  }
+}
+function _get_bufferEndCounter__2d4hee($this) {
+  return $this.t14_1.kotlinx$atomicfu$value;
+}
+function _get_isRendezvousOrUnlimited__3mdufi($this) {
+  // Inline function 'kotlin.let' call
+  var it = _get_bufferEndCounter__2d4hee($this);
+  return it === 0n || it === 9223372036854775807n;
+}
+function *_generator_send__qhx0g0($this, element, $completion) {
+  $l$block_5: {
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+    var segment = $this.v14_1.kotlinx$atomicfu$value;
+    $l$loop_0: while (true) {
+      var sendersAndCloseStatusCur = $this.r14_1.atomicfu$getAndIncrement$long();
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+      var s = sendersAndCloseStatusCur & 1152921504606846975n;
+      var closed = _get_isClosedForSend0__kxgf9m($this, sendersAndCloseStatusCur);
+      // Inline function 'kotlin.Long.div' call
+      var other = get_SEGMENT_SIZE();
+      var id = divide(s, fromInt(other));
+      // Inline function 'kotlin.Long.rem' call
+      var other_0 = get_SEGMENT_SIZE();
+      var tmp$ret$2 = modulo(s, fromInt(other_0));
+      var i = convertToInt(tmp$ret$2);
+      if (!(segment.xw_1 === id)) {
+        var tmp0_elvis_lhs = findSegmentSend($this, id, segment);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          var tmp_0;
+          if (closed) {
+            var tmp_1 = onClosedSend($this, element, $completion);
+            if (tmp_1 === get_COROUTINE_SUSPENDED())
+              tmp_1 = yield tmp_1;
+            break $l$block_5;
+          } else {
+            continue $l$loop_0;
+          }
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        segment = tmp;
+      }
+      switch (updateCellSend($this, segment, i, element, s, null, closed)) {
+        case 0:
+          segment.n15();
+          break $l$block_5;
+        case 1:
+          break $l$block_5;
+        case 2:
+          if (closed) {
+            segment.d15();
+            var tmp_2 = onClosedSend($this, element, $completion);
+            if (tmp_2 === get_COROUTINE_SUSPENDED())
+              tmp_2 = yield tmp_2;
+            break $l$block_5;
+          }
+
+          var tmp2_safe_receiver = (!(null == null) ? isInterface(null, Waiter()) : false) ? null : null;
+          if (tmp2_safe_receiver == null)
+            null;
+          else {
+            prepareSenderForSuspension($this, tmp2_safe_receiver, segment, i);
+          }
+
+          // Inline function 'kotlinx.coroutines.assert' call
+
+          break $l$block_5;
+        case 4:
+          if (s < $this.v15()) {
+            segment.n15();
+          }
+
+          var tmp_3 = onClosedSend($this, element, $completion);
+          if (tmp_3 === get_COROUTINE_SUSPENDED())
+            tmp_3 = yield tmp_3;
+          break $l$block_5;
+        case 5:
+          segment.n15();
+          continue $l$loop_0;
+        case 3:
+          var segm = segment;
+          var tmp_4 = sendOnNoWaiterSuspend($this, segm, i, element, s, $completion);
+          if (tmp_4 === get_COROUTINE_SUSPENDED())
+            tmp_4 = yield tmp_4;
+          break $l$block_5;
+      }
+    }
+  }
+  return Unit_instance;
+}
+function onClosedSend($this, element, $completion) {
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.px();
+  $l$block: {
+    var tmp0_safe_receiver = $this.q14_1;
+    var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : callUndeliveredElementCatchingException(tmp0_safe_receiver, element);
+    if (tmp1_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      addSuppressed(tmp1_safe_receiver, $this.w15());
+      // Inline function 'kotlinx.coroutines.resumeWithStackTrace' call
+      // Inline function 'kotlin.Companion.failure' call
+      var exception = recoverStackTrace_0(tmp1_safe_receiver, cancellable);
+      var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+      cancellable.vb(tmp$ret$0);
+      break $l$block;
+    }
+    // Inline function 'kotlinx.coroutines.resumeWithStackTrace' call
+    var exception_0 = $this.w15();
+    // Inline function 'kotlin.Companion.failure' call
+    var exception_1 = recoverStackTrace_0(exception_0, cancellable);
+    var tmp$ret$4 = _Result___init__impl__xyqfz8(createFailure(exception_1));
+    cancellable.vb(tmp$ret$4);
+  }
+  return cancellable.xx();
+}
+function sendOnNoWaiterSuspend($this, segment, index, element, s, $completion) {
+  var cancellable = getOrCreateCancellableContinuation(intercepted($completion));
+  try {
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImplOnNoWaiter' call
+    switch (updateCellSend($this, segment, index, element, s, cancellable, false)) {
+      case 0:
+        segment.n15();
+        // Inline function 'kotlin.coroutines.resume' call
+
+        // Inline function 'kotlin.Companion.success' call
+
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+        cancellable.vb(tmp$ret$0);
+        break;
+      case 1:
+        // Inline function 'kotlin.coroutines.resume' call
+
+        // Inline function 'kotlin.Companion.success' call
+
+        var tmp$ret$3 = _Result___init__impl__xyqfz8(Unit_instance);
+        cancellable.vb(tmp$ret$3);
+        break;
+      case 2:
+        prepareSenderForSuspension($this, cancellable, segment, index);
+        break;
+      case 4:
+        if (s < $this.v15()) {
+          segment.n15();
+        }
+
+        onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+        break;
+      case 5:
+        segment.n15();
+        $l$block_5: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+          var segment_0 = $this.v14_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            var sendersAndCloseStatusCur = $this.r14_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+            var s_0 = sendersAndCloseStatusCur & 1152921504606846975n;
+            var closed = _get_isClosedForSend0__kxgf9m($this, sendersAndCloseStatusCur);
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = divide(s_0, fromInt(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var tmp$ret$9 = modulo(s_0, fromInt(other_0));
+            var i = convertToInt(tmp$ret$9);
+            if (!(segment_0.xw_1 === id)) {
+              var tmp0_elvis_lhs = findSegmentSend($this, id, segment_0);
+              var tmp;
+              if (tmp0_elvis_lhs == null) {
+                var tmp_0;
+                if (closed) {
+                  onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+                  break $l$block_5;
+                } else {
+                  continue $l$loop_0;
+                }
+              } else {
+                tmp = tmp0_elvis_lhs;
+              }
+              segment_0 = tmp;
+            }
+            switch (updateCellSend($this, segment_0, i, element, s_0, cancellable, closed)) {
+              case 0:
+                segment_0.n15();
+                // Inline function 'kotlin.coroutines.resume' call
+
+                // Inline function 'kotlin.Companion.success' call
+
+                var tmp$ret$12 = _Result___init__impl__xyqfz8(Unit_instance);
+                cancellable.vb(tmp$ret$12);
+                break $l$block_5;
+              case 1:
+                // Inline function 'kotlin.coroutines.resume' call
+
+                // Inline function 'kotlin.Companion.success' call
+
+                var tmp$ret$15 = _Result___init__impl__xyqfz8(Unit_instance);
+                cancellable.vb(tmp$ret$15);
+                break $l$block_5;
+              case 2:
+                if (closed) {
+                  segment_0.d15();
+                  onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+                  break $l$block_5;
+                }
+
+                var tmp2_safe_receiver = (!(cancellable == null) ? isInterface(cancellable, Waiter()) : false) ? cancellable : null;
+                if (tmp2_safe_receiver == null)
+                  null;
+                else {
+                  prepareSenderForSuspension($this, tmp2_safe_receiver, segment_0, i);
+                }
+
+                break $l$block_5;
+              case 4:
+                if (s_0 < $this.v15()) {
+                  segment_0.n15();
+                }
+
+                onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+                break $l$block_5;
+              case 5:
+                segment_0.n15();
+                continue $l$loop_0;
+              case 3:
+                // Inline function 'kotlin.error' call
+
+                var message = 'unexpected';
+                throw IllegalStateException().w4(toString_0(message));
+            }
+          }
+        }
+
+        break;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message_0 = 'unexpected';
+        throw IllegalStateException().w4(toString_0(message_0));
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.yx();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.xx();
+}
+function prepareSenderForSuspension($this, _this__u8e3s4, segment, index) {
+  _this__u8e3s4.ey(segment, index + get_SEGMENT_SIZE() | 0);
+}
+function onClosedSendOnNoWaiterSuspend($this, element, cont) {
+  var tmp0_safe_receiver = $this.q14_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    callUndeliveredElement(tmp0_safe_receiver, element, cont.tb());
+  }
+  // Inline function 'kotlin.coroutines.resumeWithException' call
+  // Inline function 'kotlin.Companion.failure' call
+  var exception = recoverStackTrace_0($this.w15(), cont);
+  var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+  cont.vb(tmp$ret$0);
+}
+var SendBroadcastClass;
+function SendBroadcast() {
+  if (SendBroadcastClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'SendBroadcast', VOID, VOID, [Waiter()]);
+    SendBroadcastClass = $;
+  }
+  return SendBroadcastClass;
+}
+function updateCellSend($this, segment, index, element, s, waiter, closed) {
+  segment.h14(index, element);
+  if (closed)
+    return updateCellSendSlow($this, segment, index, element, s, waiter, closed);
+  var state = segment.l14(index);
+  if (state === null) {
+    if (bufferOrRendezvousSend($this, s)) {
+      if (segment.n14(index, null, get_BUFFERED())) {
+        return 1;
+      }
+    } else {
+      if (waiter == null) {
+        return 3;
+      } else {
+        if (segment.n14(index, null, waiter))
+          return 2;
+      }
+    }
+  } else {
+    if (!(state == null) ? isInterface(state, Waiter()) : false) {
+      segment.k14(index);
+      var tmp;
+      if (tryResumeReceiver($this, state, element)) {
+        segment.m14(index, get_DONE_RCV());
+        $this.x15();
+        tmp = 0;
+      } else {
+        if (!(segment.o14(index, get_INTERRUPTED_RCV()) === get_INTERRUPTED_RCV())) {
+          segment.b15(index, true);
+        }
+        tmp = 5;
+      }
+      return tmp;
+    }
+  }
+  return updateCellSendSlow($this, segment, index, element, s, waiter, closed);
+}
+function updateCellSendSlow($this, segment, index, element, s, waiter, closed) {
+  while (true) {
+    var state = segment.l14(index);
+    if (state === null) {
+      if (bufferOrRendezvousSend($this, s) && !closed) {
+        if (segment.n14(index, null, get_BUFFERED())) {
+          return 1;
+        }
+      } else {
+        if (closed) {
+          if (segment.n14(index, null, get_INTERRUPTED_SEND())) {
+            segment.b15(index, false);
+            return 4;
+          }
+        } else if (waiter == null)
+          return 3;
+        else if (segment.n14(index, null, waiter))
+          return 2;
+      }
+    } else if (state === get_IN_BUFFER()) {
+      if (segment.n14(index, state, get_BUFFERED())) {
+        return 1;
+      }
+    } else if (state === get_INTERRUPTED_RCV()) {
+      segment.k14(index);
+      return 5;
+    } else if (state === get_POISONED()) {
+      segment.k14(index);
+      return 5;
+    } else if (state === get_CHANNEL_CLOSED()) {
+      segment.k14(index);
+      completeCloseOrCancel($this);
+      return 4;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      segment.k14(index);
+      var tmp;
+      if (state instanceof WaiterEB()) {
+        tmp = state.y15_1;
+      } else {
+        tmp = state;
+      }
+      var receiver = tmp;
+      var tmp_0;
+      if (tryResumeReceiver($this, receiver, element)) {
+        segment.m14(index, get_DONE_RCV());
+        $this.x15();
+        tmp_0 = 0;
+      } else {
+        if (!(segment.o14(index, get_INTERRUPTED_RCV()) === get_INTERRUPTED_RCV())) {
+          segment.b15(index, true);
+        }
+        tmp_0 = 5;
+      }
+      return tmp_0;
+    }
+  }
+}
+function shouldSendSuspend0($this, curSendersAndCloseStatus) {
+  if (_get_isClosedForSend0__kxgf9m($this, curSendersAndCloseStatus))
+    return false;
+  // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+  var tmp$ret$0 = curSendersAndCloseStatus & 1152921504606846975n;
+  return !bufferOrRendezvousSend($this, tmp$ret$0);
+}
+function bufferOrRendezvousSend($this, curSenders) {
+  var tmp;
+  if (curSenders < _get_bufferEndCounter__2d4hee($this)) {
+    tmp = true;
+  } else {
+    var tmp0 = $this.v15();
+    // Inline function 'kotlin.Long.plus' call
+    var other = $this.p14_1;
+    tmp = curSenders < add(tmp0, fromInt(other));
+  }
+  return tmp;
+}
+function tryResumeReceiver($this, _this__u8e3s4, element) {
+  var tmp;
+  if (isInterface(_this__u8e3s4, SelectInstance())) {
+    tmp = _this__u8e3s4.d16($this, element);
+  } else {
+    if (_this__u8e3s4 instanceof ReceiveCatching()) {
+      if (!(_this__u8e3s4 instanceof ReceiveCatching()))
+        THROW_CCE();
+      var tmp_0 = Companion_getInstance().b16(element);
+      var tmp1_safe_receiver = $this.q14_1;
+      tmp = tryResume0(_this__u8e3s4.c16_1, new (ChannelResult())(tmp_0), tmp1_safe_receiver == null ? null : bindCancellationFunResult($this, tmp1_safe_receiver));
+    } else {
+      if (_this__u8e3s4 instanceof BufferedChannelIterator()) {
+        if (!(_this__u8e3s4 instanceof BufferedChannelIterator()))
+          THROW_CCE();
+        tmp = _this__u8e3s4.z15(element);
+      } else {
+        if (isInterface(_this__u8e3s4, CancellableContinuation())) {
+          if (!isInterface(_this__u8e3s4, CancellableContinuation()))
+            THROW_CCE();
+          var tmp2_safe_receiver = $this.q14_1;
+          tmp = tryResume0(_this__u8e3s4, element, tmp2_safe_receiver == null ? null : bindCancellationFun_0($this, tmp2_safe_receiver));
+        } else {
+          var message = 'Unexpected receiver type: ' + toString_0(_this__u8e3s4);
+          throw IllegalStateException().w4(toString_0(message));
+        }
+      }
+    }
+  }
+  return tmp;
+}
+function prepareReceiverForSuspension($this, _this__u8e3s4, segment, index) {
+  $this.e16();
+  _this__u8e3s4.ey(segment, index);
+}
+function updateCellReceive($this, segment, index, r, waiter) {
+  var state = segment.l14(index);
+  if (state === null) {
+    // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+    var senders = $this.r14_1.kotlinx$atomicfu$value & 1152921504606846975n;
+    if (r >= senders) {
+      if (waiter === null) {
+        return get_SUSPEND_NO_WAITER();
+      }
+      if (segment.n14(index, state, waiter)) {
+        expandBuffer($this);
+        return get_SUSPEND();
+      }
+    }
+  } else if (state === get_BUFFERED())
+    if (segment.n14(index, state, get_DONE_RCV())) {
+      expandBuffer($this);
+      return segment.j14(index);
+    }
+  return updateCellReceiveSlow($this, segment, index, r, waiter);
+}
+function updateCellReceiveSlow($this, segment, index, r, waiter) {
+  $l$loop: while (true) {
+    var state = segment.l14(index);
+    if (state === null || state === get_IN_BUFFER()) {
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+      var senders = $this.r14_1.kotlinx$atomicfu$value & 1152921504606846975n;
+      if (r < senders) {
+        if (segment.n14(index, state, get_POISONED())) {
+          expandBuffer($this);
+          return get_FAILED();
+        }
+      } else {
+        if (waiter === null) {
+          return get_SUSPEND_NO_WAITER();
+        }
+        if (segment.n14(index, state, waiter)) {
+          expandBuffer($this);
+          return get_SUSPEND();
+        }
+      }
+    } else if (state === get_BUFFERED()) {
+      if (segment.n14(index, state, get_DONE_RCV())) {
+        expandBuffer($this);
+        return segment.j14(index);
+      }
+    } else if (state === get_INTERRUPTED_SEND())
+      return get_FAILED();
+    else if (state === get_POISONED())
+      return get_FAILED();
+    else if (state === get_CHANNEL_CLOSED()) {
+      expandBuffer($this);
+      return get_FAILED();
+    } else if (state === get_RESUMING_BY_EB())
+      continue $l$loop;
+    else {
+      if (segment.n14(index, state, get_RESUMING_BY_RCV())) {
+        var helpExpandBuffer = state instanceof WaiterEB();
+        var tmp;
+        if (state instanceof WaiterEB()) {
+          tmp = state.y15_1;
+        } else {
+          tmp = state;
+        }
+        var sender = tmp;
+        var tmp_0;
+        if (tryResumeSender($this, sender, segment, index)) {
+          segment.m14(index, get_DONE_RCV());
+          expandBuffer($this);
+          tmp_0 = segment.j14(index);
+        } else {
+          segment.m14(index, get_INTERRUPTED_SEND());
+          segment.b15(index, false);
+          if (helpExpandBuffer) {
+            expandBuffer($this);
+          }
+          tmp_0 = get_FAILED();
+        }
+        return tmp_0;
+      }
+    }
+  }
+}
+function tryResumeSender($this, _this__u8e3s4, segment, index) {
+  var tmp;
+  if (isInterface(_this__u8e3s4, CancellableContinuation())) {
+    if (!isInterface(_this__u8e3s4, CancellableContinuation()))
+      THROW_CCE();
+    tmp = tryResume0(_this__u8e3s4, Unit_instance);
+  } else {
+    if (isInterface(_this__u8e3s4, SelectInstance())) {
+      if (!(_this__u8e3s4 instanceof SelectImplementation()))
+        THROW_CCE();
+      var trySelectResult = _this__u8e3s4.j16($this, Unit_instance);
+      if (trySelectResult === TrySelectDetailedResult_REREGISTER_getInstance()) {
+        segment.k14(index);
+      }
+      tmp = trySelectResult === TrySelectDetailedResult_SUCCESSFUL_getInstance();
+    } else {
+      if (_this__u8e3s4 instanceof SendBroadcast()) {
+        tmp = tryResume0(_this__u8e3s4.f16_1, true);
+      } else {
+        var message = 'Unexpected waiter: ' + toString_0(_this__u8e3s4);
+        throw IllegalStateException().w4(toString_0(message));
+      }
+    }
+  }
+  return tmp;
+}
+function expandBuffer($this) {
+  if (_get_isRendezvousOrUnlimited__3mdufi($this))
+    return Unit_instance;
+  var segment = $this.x14_1.kotlinx$atomicfu$value;
+  try_again: while (true) {
+    var b = $this.t14_1.atomicfu$getAndIncrement$long();
+    // Inline function 'kotlin.Long.div' call
+    var other = get_SEGMENT_SIZE();
+    var id = divide(b, fromInt(other));
+    var s = $this.t15();
+    if (s <= b) {
+      if (segment.xw_1 < id && !(segment.j15() == null)) {
+        moveSegmentBufferEndToSpecifiedOrLast($this, id, segment);
+      }
+      incCompletedExpandBufferAttempts$default($this);
+      return Unit_instance;
+    }
+    if (!(segment.xw_1 === id)) {
+      var tmp0_elvis_lhs = findSegmentBufferEnd($this, id, segment, b);
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        continue try_again;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      segment = tmp;
+    }
+    // Inline function 'kotlin.Long.rem' call
+    var other_0 = get_SEGMENT_SIZE();
+    var tmp$ret$1 = modulo(b, fromInt(other_0));
+    var i = convertToInt(tmp$ret$1);
+    if (updateCellExpandBuffer($this, segment, i, b)) {
+      incCompletedExpandBufferAttempts$default($this);
+      return Unit_instance;
+    } else {
+      incCompletedExpandBufferAttempts$default($this);
+      continue try_again;
+    }
+  }
+}
+function updateCellExpandBuffer($this, segment, index, b) {
+  var state = segment.l14(index);
+  if (!(state == null) ? isInterface(state, Waiter()) : false) {
+    if (b >= $this.s14_1.kotlinx$atomicfu$value) {
+      if (segment.n14(index, state, get_RESUMING_BY_EB())) {
+        var tmp;
+        if (tryResumeSender($this, state, segment, index)) {
+          segment.m14(index, get_BUFFERED());
+          tmp = true;
+        } else {
+          segment.m14(index, get_INTERRUPTED_SEND());
+          segment.b15(index, false);
+          tmp = false;
+        }
+        return tmp;
+      }
+    }
+  }
+  return updateCellExpandBufferSlow($this, segment, index, b);
+}
+function updateCellExpandBufferSlow($this, segment, index, b) {
+  $l$loop: while (true) {
+    var state = segment.l14(index);
+    if (!(state == null) ? isInterface(state, Waiter()) : false) {
+      if (b < $this.s14_1.kotlinx$atomicfu$value) {
+        if (segment.n14(index, state, new (WaiterEB())(state)))
+          return true;
+      } else {
+        if (segment.n14(index, state, get_RESUMING_BY_EB())) {
+          var tmp;
+          if (tryResumeSender($this, state, segment, index)) {
+            segment.m14(index, get_BUFFERED());
+            tmp = true;
+          } else {
+            segment.m14(index, get_INTERRUPTED_SEND());
+            segment.b15(index, false);
+            tmp = false;
+          }
+          return tmp;
+        }
+      }
+    } else {
+      if (state === get_INTERRUPTED_SEND())
+        return false;
+      else {
+        if (state === null) {
+          if (segment.n14(index, state, get_IN_BUFFER()))
+            return true;
+        } else {
+          if (state === get_BUFFERED())
+            return true;
+          else {
+            if (state === get_POISONED() || state === get_DONE_RCV() || state === get_INTERRUPTED_RCV())
+              return true;
+            else {
+              if (state === get_CHANNEL_CLOSED())
+                return true;
+              else {
+                if (state === get_RESUMING_BY_RCV())
+                  continue $l$loop;
+                else {
+                  // Inline function 'kotlin.error' call
+                  var message = 'Unexpected cell state: ' + toString(state);
+                  throw IllegalStateException().w4(toString_0(message));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function incCompletedExpandBufferAttempts($this, nAttempts) {
+  // Inline function 'kotlin.also' call
+  // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+  if (!(($this.u14_1.atomicfu$addAndGet$long(nAttempts) & 4611686018427387904n) === 0n)) {
+    $l$loop: while (true) {
+      // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+      if (!!(($this.u14_1.kotlinx$atomicfu$value & 4611686018427387904n) === 0n)) {
+        break $l$loop;
+      }
+    }
+  }
+}
+function incCompletedExpandBufferAttempts$default($this, nAttempts, $super) {
+  nAttempts = nAttempts === VOID ? 1n : nAttempts;
+  return incCompletedExpandBufferAttempts($this, nAttempts);
+}
+var BufferedChannelIteratorClass;
+function BufferedChannelIterator() {
+  if (BufferedChannelIteratorClass === VOID) {
+    class $ {
+      constructor($outer) {
+        this.r15_1 = $outer;
+        this.p15_1 = get_NO_RECEIVE_RESULT();
+        this.q15_1 = null;
+      }
+      k16($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_hasNext__q471nr.bind(VOID, this), $completion);
+      }
+      ey(segment, index) {
+        var tmp0_safe_receiver = this.q15_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          tmp0_safe_receiver.ey(segment, index);
+        }
+      }
+      m1() {
+        var result = this.p15_1;
+        // Inline function 'kotlin.check' call
+        if (!!(result === get_NO_RECEIVE_RESULT())) {
+          var message = '`hasNext()` has not been invoked';
+          throw IllegalStateException().w4(toString_0(message));
+        }
+        this.p15_1 = get_NO_RECEIVE_RESULT();
+        if (result === get_CHANNEL_CLOSED())
+          throw recoverStackTrace(_get_receiveException__foorc1(this.r15_1));
+        return (result == null ? true : !(result == null)) ? result : THROW_CCE();
+      }
+      z15(element) {
+        var cont = ensureNotNull(this.q15_1);
+        this.q15_1 = null;
+        this.p15_1 = element;
+        var tmp0_safe_receiver = this.r15_1.q14_1;
+        return tryResume0(cont, true, tmp0_safe_receiver == null ? null : bindCancellationFun(this.r15_1, tmp0_safe_receiver, element));
+      }
+      l16() {
+        var cont = ensureNotNull(this.q15_1);
+        this.q15_1 = null;
+        this.p15_1 = get_CHANNEL_CLOSED();
+        var cause = this.r15_1.u15();
+        if (cause == null) {
+          // Inline function 'kotlin.coroutines.resume' call
+          // Inline function 'kotlin.Companion.success' call
+          var tmp$ret$0 = _Result___init__impl__xyqfz8(false);
+          cont.vb(tmp$ret$0);
+        } else {
+          // Inline function 'kotlin.coroutines.resumeWithException' call
+          // Inline function 'kotlin.Companion.failure' call
+          var exception = recoverStackTrace_0(cause, cont);
+          var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(exception));
+          cont.vb(tmp$ret$2);
+        }
+      }
+    }
+    initMetadataForClass($, 'BufferedChannelIterator', VOID, VOID, [Waiter()], [0, 3]);
+    BufferedChannelIteratorClass = $;
+  }
+  return BufferedChannelIteratorClass;
+}
+function _get_receiveException__foorc1($this) {
+  var tmp0_elvis_lhs = $this.u15();
+  return tmp0_elvis_lhs == null ? ClosedReceiveChannelException().q16('Channel was closed') : tmp0_elvis_lhs;
+}
+function invokeCloseHandler($this) {
+  var tmp0 = $this.a15_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlinx.atomicfu.getAndUpdate' call
+    while (true) {
+      var cur = tmp0.kotlinx$atomicfu$value;
+      var tmp;
+      if (cur === null) {
+        tmp = get_CLOSE_HANDLER_CLOSED();
+      } else {
+        tmp = get_CLOSE_HANDLER_INVOKED();
+      }
+      var upd = tmp;
+      if (tmp0.atomicfu$compareAndSet(cur, upd)) {
+        tmp$ret$1 = cur;
+        break $l$block;
+      }
+    }
+  }
+  var tmp0_elvis_lhs = tmp$ret$1;
+  var tmp_0;
+  if (tmp0_elvis_lhs == null) {
+    return Unit_instance;
+  } else {
+    tmp_0 = tmp0_elvis_lhs;
+  }
+  var closeHandler = tmp_0;
+  if (typeof closeHandler !== 'function')
+    THROW_CCE();
+  closeHandler($this.u15());
+}
+function markClosed($this) {
+  var tmp0 = $this.r14_1;
+  var tmp$ret$4;
+  $l$block: {
+    // Inline function 'kotlinx.atomicfu.update' call
+    while (true) {
+      var cur = tmp0.kotlinx$atomicfu$value;
+      // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+      var tmp;
+      switch (convertToInt(shiftRight(cur, 60))) {
+        case 0:
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+          var tmp$ret$1 = cur & 1152921504606846975n;
+          tmp = constructSendersAndCloseStatus(tmp$ret$1, 2);
+          break;
+        case 1:
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+          var tmp$ret$2 = cur & 1152921504606846975n;
+          tmp = constructSendersAndCloseStatus(tmp$ret$2, 3);
+          break;
+        default:
+          return Unit_instance;
+      }
+      var upd = tmp;
+      if (tmp0.atomicfu$compareAndSet(cur, upd)) {
+        tmp$ret$4 = Unit_instance;
+        break $l$block;
+      }
+    }
+    tmp$ret$4 = Unit_instance;
+  }
+  return tmp$ret$4;
+}
+function markCancelled($this) {
+  var tmp0 = $this.r14_1;
+  var tmp$ret$2;
+  $l$block: {
+    // Inline function 'kotlinx.atomicfu.update' call
+    while (true) {
+      var cur = tmp0.kotlinx$atomicfu$value;
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+      var tmp$ret$0 = cur & 1152921504606846975n;
+      var upd = constructSendersAndCloseStatus(tmp$ret$0, 3);
+      if (tmp0.atomicfu$compareAndSet(cur, upd)) {
+        tmp$ret$2 = Unit_instance;
+        break $l$block;
+      }
+    }
+    tmp$ret$2 = Unit_instance;
+  }
+  return tmp$ret$2;
+}
+function markCancellationStarted($this) {
+  var tmp0 = $this.r14_1;
+  var tmp$ret$3;
+  $l$block: {
+    // Inline function 'kotlinx.atomicfu.update' call
+    while (true) {
+      var cur = tmp0.kotlinx$atomicfu$value;
+      var tmp;
+      // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+      if (convertToInt(shiftRight(cur, 60)) === 0) {
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        var tmp$ret$1 = cur & 1152921504606846975n;
+        tmp = constructSendersAndCloseStatus(tmp$ret$1, 1);
+      } else {
+        return Unit_instance;
+      }
+      var upd = tmp;
+      if (tmp0.atomicfu$compareAndSet(cur, upd)) {
+        tmp$ret$3 = Unit_instance;
+        break $l$block;
+      }
+    }
+    tmp$ret$3 = Unit_instance;
+  }
+  return tmp$ret$3;
+}
+function completeCloseOrCancel($this) {
+  $this.r16();
+}
+function completeClose($this, sendersCur) {
+  var lastSegment = closeLinkedList($this);
+  if ($this.t16()) {
+    var lastBufferedCellGlobalIndex = markAllEmptyCellsAsClosed($this, lastSegment);
+    if (!(lastBufferedCellGlobalIndex === -1n)) {
+      $this.s16(lastBufferedCellGlobalIndex);
+    }
+  }
+  cancelSuspendedReceiveRequests($this, lastSegment, sendersCur);
+  return lastSegment;
+}
+function completeCancel($this, sendersCur) {
+  var lastSegment = completeClose($this, sendersCur);
+  removeUnprocessedElements($this, lastSegment);
+}
+function closeLinkedList($this) {
+  var lastSegment = $this.x14_1.kotlinx$atomicfu$value;
+  // Inline function 'kotlin.let' call
+  var it = $this.v14_1.kotlinx$atomicfu$value;
+  if (it.xw_1 > lastSegment.xw_1)
+    lastSegment = it;
+  // Inline function 'kotlin.let' call
+  var it_0 = $this.w14_1.kotlinx$atomicfu$value;
+  if (it_0.xw_1 > lastSegment.xw_1)
+    lastSegment = it_0;
+  return close(lastSegment);
+}
+function markAllEmptyCellsAsClosed($this, lastSegment) {
+  var segment = lastSegment;
+  while (true) {
+    var inductionVariable = get_SEGMENT_SIZE() - 1 | 0;
+    if (0 <= inductionVariable)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + -1 | 0;
+        var tmp0 = segment.xw_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var this_0 = multiply(tmp0, fromInt(other));
+        var globalIndex = add(this_0, fromInt(index));
+        if (globalIndex < $this.v15())
+          return -1n;
+        cell_update: while (true) {
+          var state = segment.l14(index);
+          if (state === null || state === get_IN_BUFFER()) {
+            if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+              segment.d15();
+              break cell_update;
+            }
+          } else if (state === get_BUFFERED())
+            return globalIndex;
+          else
+            break cell_update;
+        }
+      }
+       while (0 <= inductionVariable);
+    var tmp0_elvis_lhs = segment.m15();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return -1n;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    segment = tmp;
+  }
+}
+function removeUnprocessedElements($this, lastSegment) {
+  var onUndeliveredElement = $this.q14_1;
+  var undeliveredElementException = null;
+  var suspendedSenders = _InlineList___init__impl__z8n56();
+  var segment = lastSegment;
+  process_segments: while (true) {
+    var inductionVariable = get_SEGMENT_SIZE() - 1 | 0;
+    if (0 <= inductionVariable)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + -1 | 0;
+        var tmp0 = segment.xw_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var this_0 = multiply(tmp0, fromInt(other));
+        var globalIndex = add(this_0, fromInt(index));
+        update_cell: while (true) {
+          var state = segment.l14(index);
+          if (state === get_DONE_RCV())
+            break process_segments;
+          else {
+            if (state === get_BUFFERED()) {
+              if (globalIndex < $this.v15())
+                break process_segments;
+              if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+                if (!(onUndeliveredElement == null)) {
+                  var element = segment.i14(index);
+                  undeliveredElementException = callUndeliveredElementCatchingException(onUndeliveredElement, element, undeliveredElementException);
+                }
+                segment.k14(index);
+                segment.d15();
+                break update_cell;
+              }
+            } else {
+              if (state === get_IN_BUFFER() || state === null) {
+                if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+                  segment.d15();
+                  break update_cell;
+                }
+              } else {
+                var tmp;
+                if (!(state == null) ? isInterface(state, Waiter()) : false) {
+                  tmp = true;
+                } else {
+                  tmp = state instanceof WaiterEB();
+                }
+                if (tmp) {
+                  if (globalIndex < $this.v15())
+                    break process_segments;
+                  var tmp_0;
+                  if (state instanceof WaiterEB()) {
+                    tmp_0 = state.y15_1;
+                  } else {
+                    tmp_0 = (!(state == null) ? isInterface(state, Waiter()) : false) ? state : THROW_CCE();
+                  }
+                  var sender = tmp_0;
+                  if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+                    if (!(onUndeliveredElement == null)) {
+                      var element_0 = segment.i14(index);
+                      undeliveredElementException = callUndeliveredElementCatchingException(onUndeliveredElement, element_0, undeliveredElementException);
+                    }
+                    suspendedSenders = InlineList__plus_impl_nuetvo(suspendedSenders, sender);
+                    segment.k14(index);
+                    segment.d15();
+                    break update_cell;
+                  }
+                } else {
+                  if (state === get_RESUMING_BY_EB() || state === get_RESUMING_BY_RCV())
+                    break process_segments;
+                  else {
+                    if (state === get_RESUMING_BY_EB())
+                      continue update_cell;
+                    else {
+                      break update_cell;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+       while (0 <= inductionVariable);
+    var tmp0_elvis_lhs = segment.m15();
+    var tmp_1;
+    if (tmp0_elvis_lhs == null) {
+      break process_segments;
+    } else {
+      tmp_1 = tmp0_elvis_lhs;
+    }
+    segment = tmp_1;
+  }
+  var tmp0_0 = suspendedSenders;
+  $l$block: {
+    // Inline function 'kotlinx.coroutines.internal.InlineList.forEachReversed' call
+    var tmp0_subject = access$_get_holder__kkflen(tmp0_0);
+    if (tmp0_subject == null) {
+      break $l$block;
+    } else {
+      if (!(tmp0_subject instanceof ArrayList())) {
+        var tmp_2 = access$_get_holder__kkflen(tmp0_0);
+        var it = (tmp_2 == null ? true : !(tmp_2 == null)) ? tmp_2 : THROW_CCE();
+        resumeSenderOnCancelledChannel($this, it);
+      } else {
+        var tmp_3 = access$_get_holder__kkflen(tmp0_0);
+        var list = tmp_3 instanceof ArrayList() ? tmp_3 : THROW_CCE();
+        var inductionVariable_0 = list.n1() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var i = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            var it_0 = list.o1(i);
+            resumeSenderOnCancelledChannel($this, it_0);
+          }
+           while (0 <= inductionVariable_0);
+      }
+    }
+  }
+  var tmp1_safe_receiver = undeliveredElementException;
+  if (tmp1_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp1_safe_receiver;
+  }
+}
+function cancelSuspendedReceiveRequests($this, lastSegment, sendersCounter) {
+  var suspendedReceivers = _InlineList___init__impl__z8n56();
+  var segment = lastSegment;
+  process_segments: while (!(segment == null)) {
+    var inductionVariable = get_SEGMENT_SIZE() - 1 | 0;
+    if (0 <= inductionVariable)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + -1 | 0;
+        var tmp0 = segment.xw_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var this_0 = multiply(tmp0, fromInt(other));
+        if (add(this_0, fromInt(index)) < sendersCounter)
+          break process_segments;
+        cell_update: while (true) {
+          var state = segment.l14(index);
+          if (state === null || state === get_IN_BUFFER()) {
+            if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+              segment.d15();
+              break cell_update;
+            }
+          } else {
+            if (state instanceof WaiterEB()) {
+              if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+                suspendedReceivers = InlineList__plus_impl_nuetvo(suspendedReceivers, state.y15_1);
+                segment.b15(index, true);
+                break cell_update;
+              }
+            } else {
+              if (!(state == null) ? isInterface(state, Waiter()) : false) {
+                if (segment.n14(index, state, get_CHANNEL_CLOSED())) {
+                  suspendedReceivers = InlineList__plus_impl_nuetvo(suspendedReceivers, state);
+                  segment.b15(index, true);
+                  break cell_update;
+                }
+              } else {
+                break cell_update;
+              }
+            }
+          }
+        }
+      }
+       while (0 <= inductionVariable);
+    segment = segment.m15();
+  }
+  var tmp0_0 = suspendedReceivers;
+  $l$block: {
+    // Inline function 'kotlinx.coroutines.internal.InlineList.forEachReversed' call
+    var tmp0_subject = access$_get_holder__kkflen(tmp0_0);
+    if (tmp0_subject == null) {
+      break $l$block;
+    } else {
+      if (!(tmp0_subject instanceof ArrayList())) {
+        var tmp = access$_get_holder__kkflen(tmp0_0);
+        var it = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+        resumeReceiverOnClosedChannel($this, it);
+      } else {
+        var tmp_0 = access$_get_holder__kkflen(tmp0_0);
+        var list = tmp_0 instanceof ArrayList() ? tmp_0 : THROW_CCE();
+        var inductionVariable_0 = list.n1() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var i = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            var it_0 = list.o1(i);
+            resumeReceiverOnClosedChannel($this, it_0);
+          }
+           while (0 <= inductionVariable_0);
+      }
+    }
+  }
+}
+function resumeReceiverOnClosedChannel($this, _this__u8e3s4) {
+  return resumeWaiterOnClosedChannel($this, _this__u8e3s4, true);
+}
+function resumeSenderOnCancelledChannel($this, _this__u8e3s4) {
+  return resumeWaiterOnClosedChannel($this, _this__u8e3s4, false);
+}
+function resumeWaiterOnClosedChannel($this, _this__u8e3s4, receiver) {
+  if (_this__u8e3s4 instanceof SendBroadcast()) {
+    // Inline function 'kotlin.coroutines.resume' call
+    var this_0 = _this__u8e3s4.f16_1;
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(false);
+    this_0.vb(tmp$ret$0);
+  } else {
+    if (isInterface(_this__u8e3s4, CancellableContinuation())) {
+      // Inline function 'kotlin.coroutines.resumeWithException' call
+      // Inline function 'kotlin.Companion.failure' call
+      var exception = receiver ? _get_receiveException__foorc1($this) : $this.w15();
+      var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(exception));
+      _this__u8e3s4.vb(tmp$ret$2);
+    } else {
+      if (_this__u8e3s4 instanceof ReceiveCatching()) {
+        var tmp0 = _this__u8e3s4.c16_1;
+        // Inline function 'kotlin.coroutines.resume' call
+        // Inline function 'kotlin.Companion.success' call
+        var value = new (ChannelResult())(Companion_getInstance().u16($this.u15()));
+        var tmp$ret$4 = _Result___init__impl__xyqfz8(value);
+        tmp0.vb(tmp$ret$4);
+      } else {
+        if (_this__u8e3s4 instanceof BufferedChannelIterator()) {
+          _this__u8e3s4.l16();
+        } else {
+          if (isInterface(_this__u8e3s4, SelectInstance()))
+            _this__u8e3s4.d16($this, get_CHANNEL_CLOSED());
+          else {
+            // Inline function 'kotlin.error' call
+            var message = 'Unexpected waiter: ' + toString_0(_this__u8e3s4);
+            throw IllegalStateException().w4(toString_0(message));
+          }
+        }
+      }
+    }
+  }
+}
+function _get_isClosedForSend0__kxgf9m($this, _this__u8e3s4) {
+  return isClosed($this, _this__u8e3s4, false);
+}
+function _get_isClosedForReceive0__f7qknl($this, _this__u8e3s4) {
+  return isClosed($this, _this__u8e3s4, true);
+}
+function isClosed($this, sendersAndCloseStatusCur, isClosedForReceive) {
+  // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+  var tmp;
+  switch (convertToInt(shiftRight(sendersAndCloseStatusCur, 60))) {
+    case 0:
+      tmp = false;
+      break;
+    case 1:
+      tmp = false;
+      break;
+    case 2:
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+      var tmp$ret$1 = sendersAndCloseStatusCur & 1152921504606846975n;
+      completeClose($this, tmp$ret$1);
+      tmp = isClosedForReceive ? !$this.v16() : true;
+      break;
+    case 3:
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+      var tmp$ret$2 = sendersAndCloseStatusCur & 1152921504606846975n;
+      completeCancel($this, tmp$ret$2);
+      tmp = true;
+      break;
+    default:
+      // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+
+      var message = 'unexpected close status: ' + convertToInt(shiftRight(sendersAndCloseStatusCur, 60));
+      throw IllegalStateException().w4(toString_0(message));
+  }
+  return tmp;
+}
+function isCellNonEmpty($this, segment, index, globalIndex) {
+  while (true) {
+    var state = segment.l14(index);
+    if (state === null || state === get_IN_BUFFER()) {
+      if (segment.n14(index, state, get_POISONED())) {
+        expandBuffer($this);
+        return false;
+      }
+    } else if (state === get_BUFFERED())
+      return true;
+    else if (state === get_INTERRUPTED_SEND())
+      return false;
+    else if (state === get_CHANNEL_CLOSED())
+      return false;
+    else if (state === get_DONE_RCV())
+      return false;
+    else if (state === get_POISONED())
+      return false;
+    else if (state === get_RESUMING_BY_EB())
+      return true;
+    else if (state === get_RESUMING_BY_RCV())
+      return false;
+    else
+      return globalIndex === $this.v15();
+  }
+}
+function findSegmentSend($this, id, startFrom) {
+  var tmp0 = $this.v14_1;
+  var tmp6 = createSegmentFunction();
+  var tmp$ret$2;
+  $l$block_2: {
+    // Inline function 'kotlinx.coroutines.internal.findSegmentAndMoveForward' call
+    while (true) {
+      var s = findSegmentInternal(startFrom, id, tmp6);
+      var tmp;
+      if (_SegmentOrClosed___get_isClosed__impl__qmxmlo(s)) {
+        tmp = true;
+      } else {
+        var tmp2 = _SegmentOrClosed___get_segment__impl__jvcr9l(s);
+        var tmp$ret$0;
+        $l$block_1: {
+          // Inline function 'kotlinx.coroutines.internal.moveForward' call
+          while (true) {
+            var cur = tmp0.kotlinx$atomicfu$value;
+            if (cur.xw_1 >= tmp2.xw_1) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.f15()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.g15()) {
+                cur.e6();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.g15()) {
+              tmp2.e6();
+            }
+          }
+          tmp$ret$0 = Unit_instance;
+        }
+        tmp = tmp$ret$0;
+      }
+      if (tmp) {
+        tmp$ret$2 = s;
+        break $l$block_2;
+      }
+    }
+  }
+  // Inline function 'kotlin.let' call
+  var it = tmp$ret$2;
+  var tmp_0;
+  if (_SegmentOrClosed___get_isClosed__impl__qmxmlo(it)) {
+    completeCloseOrCancel($this);
+    var tmp0_0 = startFrom.xw_1;
+    // Inline function 'kotlin.Long.times' call
+    var other = get_SEGMENT_SIZE();
+    if (multiply(tmp0_0, fromInt(other)) < $this.v15()) {
+      startFrom.n15();
+    }
+    tmp_0 = null;
+  } else {
+    var segment = _SegmentOrClosed___get_segment__impl__jvcr9l(it);
+    var tmp_1;
+    if (segment.xw_1 > id) {
+      var tmp0_1 = segment.xw_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_0 = get_SEGMENT_SIZE();
+      var tmp$ret$4 = multiply(tmp0_1, fromInt(other_0));
+      updateSendersCounterIfLower($this, tmp$ret$4);
+      var tmp0_2 = segment.xw_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_1 = get_SEGMENT_SIZE();
+      if (multiply(tmp0_2, fromInt(other_1)) < $this.v15()) {
+        segment.n15();
+      }
+      tmp_1 = null;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      tmp_1 = segment;
+    }
+    tmp_0 = tmp_1;
+  }
+  return tmp_0;
+}
+function findSegmentReceive($this, id, startFrom) {
+  var tmp0 = $this.w14_1;
+  var tmp6 = createSegmentFunction();
+  var tmp$ret$2;
+  $l$block_2: {
+    // Inline function 'kotlinx.coroutines.internal.findSegmentAndMoveForward' call
+    while (true) {
+      var s = findSegmentInternal(startFrom, id, tmp6);
+      var tmp;
+      if (_SegmentOrClosed___get_isClosed__impl__qmxmlo(s)) {
+        tmp = true;
+      } else {
+        var tmp2 = _SegmentOrClosed___get_segment__impl__jvcr9l(s);
+        var tmp$ret$0;
+        $l$block_1: {
+          // Inline function 'kotlinx.coroutines.internal.moveForward' call
+          while (true) {
+            var cur = tmp0.kotlinx$atomicfu$value;
+            if (cur.xw_1 >= tmp2.xw_1) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.f15()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.g15()) {
+                cur.e6();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.g15()) {
+              tmp2.e6();
+            }
+          }
+          tmp$ret$0 = Unit_instance;
+        }
+        tmp = tmp$ret$0;
+      }
+      if (tmp) {
+        tmp$ret$2 = s;
+        break $l$block_2;
+      }
+    }
+  }
+  // Inline function 'kotlin.let' call
+  var it = tmp$ret$2;
+  var tmp_0;
+  if (_SegmentOrClosed___get_isClosed__impl__qmxmlo(it)) {
+    completeCloseOrCancel($this);
+    var tmp0_0 = startFrom.xw_1;
+    // Inline function 'kotlin.Long.times' call
+    var other = get_SEGMENT_SIZE();
+    if (multiply(tmp0_0, fromInt(other)) < $this.t15()) {
+      startFrom.n15();
+    }
+    tmp_0 = null;
+  } else {
+    var segment = _SegmentOrClosed___get_segment__impl__jvcr9l(it);
+    var tmp_1;
+    if (!_get_isRendezvousOrUnlimited__3mdufi($this)) {
+      var tmp0_1 = _get_bufferEndCounter__2d4hee($this);
+      // Inline function 'kotlin.Long.div' call
+      var other_0 = get_SEGMENT_SIZE();
+      tmp_1 = id <= divide(tmp0_1, fromInt(other_0));
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      var tmp0_2 = $this.x14_1;
+      $l$block_5: {
+        // Inline function 'kotlinx.coroutines.internal.moveForward' call
+        while (true) {
+          var cur_0 = tmp0_2.kotlinx$atomicfu$value;
+          if (cur_0.xw_1 >= segment.xw_1) {
+            break $l$block_5;
+          }
+          if (!segment.f15()) {
+            break $l$block_5;
+          }
+          if (tmp0_2.atomicfu$compareAndSet(cur_0, segment)) {
+            if (cur_0.g15()) {
+              cur_0.e6();
+            }
+            break $l$block_5;
+          }
+          if (segment.g15()) {
+            segment.e6();
+          }
+        }
+      }
+    }
+    var tmp_2;
+    if (segment.xw_1 > id) {
+      var tmp0_3 = segment.xw_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_1 = get_SEGMENT_SIZE();
+      var tmp$ret$7 = multiply(tmp0_3, fromInt(other_1));
+      updateReceiversCounterIfLower($this, tmp$ret$7);
+      var tmp0_4 = segment.xw_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_2 = get_SEGMENT_SIZE();
+      if (multiply(tmp0_4, fromInt(other_2)) < $this.t15()) {
+        segment.n15();
+      }
+      tmp_2 = null;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      tmp_2 = segment;
+    }
+    tmp_0 = tmp_2;
+  }
+  return tmp_0;
+}
+function findSegmentBufferEnd($this, id, startFrom, currentBufferEndCounter) {
+  var tmp0 = $this.x14_1;
+  var tmp6 = createSegmentFunction();
+  var tmp$ret$2;
+  $l$block_2: {
+    // Inline function 'kotlinx.coroutines.internal.findSegmentAndMoveForward' call
+    while (true) {
+      var s = findSegmentInternal(startFrom, id, tmp6);
+      var tmp;
+      if (_SegmentOrClosed___get_isClosed__impl__qmxmlo(s)) {
+        tmp = true;
+      } else {
+        var tmp2 = _SegmentOrClosed___get_segment__impl__jvcr9l(s);
+        var tmp$ret$0;
+        $l$block_1: {
+          // Inline function 'kotlinx.coroutines.internal.moveForward' call
+          while (true) {
+            var cur = tmp0.kotlinx$atomicfu$value;
+            if (cur.xw_1 >= tmp2.xw_1) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.f15()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.g15()) {
+                cur.e6();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.g15()) {
+              tmp2.e6();
+            }
+          }
+          tmp$ret$0 = Unit_instance;
+        }
+        tmp = tmp$ret$0;
+      }
+      if (tmp) {
+        tmp$ret$2 = s;
+        break $l$block_2;
+      }
+    }
+  }
+  // Inline function 'kotlin.let' call
+  var it = tmp$ret$2;
+  var tmp_0;
+  if (_SegmentOrClosed___get_isClosed__impl__qmxmlo(it)) {
+    completeCloseOrCancel($this);
+    moveSegmentBufferEndToSpecifiedOrLast($this, id, startFrom);
+    incCompletedExpandBufferAttempts$default($this);
+    tmp_0 = null;
+  } else {
+    var segment = _SegmentOrClosed___get_segment__impl__jvcr9l(it);
+    var tmp_1;
+    if (segment.xw_1 > id) {
+      // Inline function 'kotlin.Long.plus' call
+      var tmp_2 = add(currentBufferEndCounter, fromInt(1));
+      var tmp0_0 = segment.xw_1;
+      // Inline function 'kotlin.Long.times' call
+      var other = get_SEGMENT_SIZE();
+      var tmp$ret$4 = multiply(tmp0_0, fromInt(other));
+      if ($this.t14_1.atomicfu$compareAndSet(tmp_2, tmp$ret$4)) {
+        var tmp0_1 = segment.xw_1;
+        // Inline function 'kotlin.Long.times' call
+        var other_0 = get_SEGMENT_SIZE();
+        var tmp$ret$5 = multiply(tmp0_1, fromInt(other_0));
+        incCompletedExpandBufferAttempts($this, subtract(tmp$ret$5, currentBufferEndCounter));
+      } else {
+        incCompletedExpandBufferAttempts$default($this);
+      }
+      tmp_1 = null;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      tmp_1 = segment;
+    }
+    tmp_0 = tmp_1;
+  }
+  return tmp_0;
+}
+function moveSegmentBufferEndToSpecifiedOrLast($this, id, startFrom) {
+  var segment = startFrom;
+  $l$loop: while (segment.xw_1 < id) {
+    var tmp0_elvis_lhs = segment.j15();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      break $l$loop;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    segment = tmp;
+  }
+  while (true) {
+    $l$loop_0: while (segment.e15()) {
+      var tmp1_elvis_lhs = segment.j15();
+      var tmp_0;
+      if (tmp1_elvis_lhs == null) {
+        break $l$loop_0;
+      } else {
+        tmp_0 = tmp1_elvis_lhs;
+      }
+      segment = tmp_0;
+    }
+    var tmp0 = $this.x14_1;
+    var tmp2 = segment;
+    var tmp$ret$0;
+    $l$block_1: {
+      // Inline function 'kotlinx.coroutines.internal.moveForward' call
+      while (true) {
+        var cur = tmp0.kotlinx$atomicfu$value;
+        if (cur.xw_1 >= tmp2.xw_1) {
+          tmp$ret$0 = true;
+          break $l$block_1;
+        }
+        if (!tmp2.f15()) {
+          tmp$ret$0 = false;
+          break $l$block_1;
+        }
+        if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+          if (cur.g15()) {
+            cur.e6();
+          }
+          tmp$ret$0 = true;
+          break $l$block_1;
+        }
+        if (tmp2.g15()) {
+          tmp2.e6();
+        }
+      }
+      tmp$ret$0 = Unit_instance;
+    }
+    if (tmp$ret$0)
+      return Unit_instance;
+  }
+}
+function updateSendersCounterIfLower($this, value) {
+  var this_0 = $this.r14_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+    var curCounter = cur & 1152921504606846975n;
+    if (curCounter >= value)
+      return Unit_instance;
+    // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+    var tmp$ret$1 = convertToInt(shiftRight(cur, 60));
+    var update = constructSendersAndCloseStatus(curCounter, tmp$ret$1);
+    if ($this.r14_1.atomicfu$compareAndSet(cur, update))
+      return Unit_instance;
+  }
+  return Unit_instance;
+}
+function updateReceiversCounterIfLower($this, value) {
+  var this_0 = $this.s14_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    if (cur >= value)
+      return Unit_instance;
+    if ($this.s14_1.atomicfu$compareAndSet(cur, value))
+      return Unit_instance;
+  }
+  return Unit_instance;
+}
+function bindCancellationFunResult($this, _this__u8e3s4) {
+  return BufferedChannel$onCancellationChannelResultImplDoNotCall$ref($this);
+}
+function onCancellationChannelResultImplDoNotCall($this, cause, element, context) {
+  callUndeliveredElement(ensureNotNull($this.q14_1), ensureNotNull(ChannelResult__getOrNull_impl_f5e07h(element)), context);
+}
+function bindCancellationFun($this, _this__u8e3s4, element) {
+  return BufferedChannel$bindCancellationFun$lambda(_this__u8e3s4, element);
+}
+function bindCancellationFun_0($this, _this__u8e3s4) {
+  return BufferedChannel$onCancellationImplDoNotCall$ref($this);
+}
+function onCancellationImplDoNotCall($this, cause, element, context) {
+  callUndeliveredElement(ensureNotNull($this.q14_1), element, context);
+}
+function BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda$lambda($element, this$0, $select) {
+  return (_unused_var__etf5q3, _unused_var__etf5q3_0, _unused_var__etf5q3_1) => {
+    var tmp;
+    if (!($element === get_CHANNEL_CLOSED())) {
+      callUndeliveredElement(this$0.q14_1, ($element == null ? true : !($element == null)) ? $element : THROW_CCE(), $select.tb());
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda(this$0) {
+  return (select, _unused_var__etf5q3, element) => BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda$lambda(element, this$0, select);
+}
+function BufferedChannel$onCancellationChannelResultImplDoNotCall$ref(p0) {
+  var l = (_this__u8e3s4, p0_0, p1) => {
+    var tmp0 = p0;
+    onCancellationChannelResultImplDoNotCall(tmp0, _this__u8e3s4, p0_0.x16_1, p1);
+    return Unit_instance;
+  };
+  l.callableName = 'onCancellationChannelResultImplDoNotCall';
+  return l;
+}
+function BufferedChannel$bindCancellationFun$lambda($this_bindCancellationFun, $element) {
+  return (_unused_var__etf5q3, _unused_var__etf5q3_0, context) => {
+    callUndeliveredElement($this_bindCancellationFun, $element, context);
+    return Unit_instance;
+  };
+}
+function BufferedChannel$onCancellationImplDoNotCall$ref(p0) {
+  var l = (_this__u8e3s4, p0_0, p1) => {
+    var tmp0 = p0;
+    onCancellationImplDoNotCall(tmp0, _this__u8e3s4, p0_0, p1);
+    return Unit_instance;
+  };
+  l.callableName = 'onCancellationImplDoNotCall';
+  return l;
+}
+var BufferedChannelClass;
+function BufferedChannel() {
+  if (BufferedChannelClass === VOID) {
+    class $ {
+      constructor(capacity, onUndeliveredElement) {
+        onUndeliveredElement = onUndeliveredElement === VOID ? null : onUndeliveredElement;
+        this.p14_1 = capacity;
+        this.q14_1 = onUndeliveredElement;
+        // Inline function 'kotlin.require' call
+        if (!(this.p14_1 >= 0)) {
+          var message = 'Invalid channel capacity: ' + this.p14_1 + ', should be >=0';
+          throw IllegalArgumentException().i1(toString_0(message));
+        }
+        this.r14_1 = atomic$long$1(0n);
+        this.s14_1 = atomic$long$1(0n);
+        this.t14_1 = atomic$long$1(initialBufferEnd(this.p14_1));
+        this.u14_1 = atomic$long$1(_get_bufferEndCounter__2d4hee(this));
+        var firstSegment = new (ChannelSegment())(0n, null, this, 3);
+        this.v14_1 = atomic$ref$1(firstSegment);
+        this.w14_1 = atomic$ref$1(firstSegment);
+        var tmp = this;
+        var tmp_0;
+        if (_get_isRendezvousOrUnlimited__3mdufi(this)) {
+          var tmp_1 = get_NULL_SEGMENT();
+          tmp_0 = tmp_1 instanceof ChannelSegment() ? tmp_1 : THROW_CCE();
+        } else {
+          tmp_0 = firstSegment;
+        }
+        tmp.x14_1 = atomic$ref$1(tmp_0);
+        var tmp_2 = this;
+        var tmp_3;
+        if (this.q14_1 == null) {
+          tmp_3 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_3 = BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda(this);
+        }
+        tmp_2.y14_1 = tmp_3;
+        this.z14_1 = atomic$ref$1(get_NO_CLOSE_CAUSE());
+        this.a15_1 = atomic$ref$1(null);
+      }
+      t15() {
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        return this.r14_1.kotlinx$atomicfu$value & 1152921504606846975n;
+      }
+      v15() {
+        return this.s14_1.kotlinx$atomicfu$value;
+      }
+      y16(element, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_send__qhx0g0.bind(VOID, this, element), $completion);
+      }
+      z16(element) {
+        if (shouldSendSuspend0(this, this.r14_1.kotlinx$atomicfu$value))
+          return Companion_getInstance().a17();
+        var tmp4 = get_INTERRUPTED_SEND();
+        var tmp$ret$4;
+        $l$block_4: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+          var segment = this.v14_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            var sendersAndCloseStatusCur = this.r14_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+            var s = sendersAndCloseStatusCur & 1152921504606846975n;
+            var closed = _get_isClosedForSend0__kxgf9m(this, sendersAndCloseStatusCur);
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = divide(s, fromInt(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var tmp$ret$2 = modulo(s, fromInt(other_0));
+            var i = convertToInt(tmp$ret$2);
+            if (!(segment.xw_1 === id)) {
+              var tmp0_elvis_lhs = findSegmentSend(this, id, segment);
+              var tmp;
+              if (tmp0_elvis_lhs == null) {
+                var tmp_0;
+                if (closed) {
+                  tmp$ret$4 = Companion_getInstance().u16(this.w15());
+                  break $l$block_4;
+                } else {
+                  continue $l$loop_0;
+                }
+              } else {
+                tmp = tmp0_elvis_lhs;
+              }
+              segment = tmp;
+            }
+            switch (updateCellSend(this, segment, i, element, s, tmp4, closed)) {
+              case 0:
+                segment.n15();
+                tmp$ret$4 = Companion_getInstance().b16(Unit_instance);
+                break $l$block_4;
+              case 1:
+                tmp$ret$4 = Companion_getInstance().b16(Unit_instance);
+                break $l$block_4;
+              case 2:
+                if (closed) {
+                  segment.d15();
+                  tmp$ret$4 = Companion_getInstance().u16(this.w15());
+                  break $l$block_4;
+                }
+
+                var tmp2_safe_receiver = (!(tmp4 == null) ? isInterface(tmp4, Waiter()) : false) ? tmp4 : null;
+                if (tmp2_safe_receiver == null)
+                  null;
+                else {
+                  prepareSenderForSuspension(this, tmp2_safe_receiver, segment, i);
+                }
+
+                segment.d15();
+                tmp$ret$4 = Companion_getInstance().a17();
+                break $l$block_4;
+              case 4:
+                if (s < this.v15()) {
+                  segment.n15();
+                }
+
+                tmp$ret$4 = Companion_getInstance().u16(this.w15());
+                break $l$block_4;
+              case 5:
+                segment.n15();
+                continue $l$loop_0;
+              case 3:
+                var message = 'unexpected';
+                throw IllegalStateException().w4(toString_0(message));
+            }
+          }
+        }
+        return tmp$ret$4;
+      }
+      b17(element) {
+        var tmp$ret$3;
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+        var waiter = get_BUFFERED();
+        var segment = this.v14_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          var sendersAndCloseStatusCur = this.r14_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+          var s = sendersAndCloseStatusCur & 1152921504606846975n;
+          var closed = _get_isClosedForSend0__kxgf9m(this, sendersAndCloseStatusCur);
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(s, fromInt(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$2 = modulo(s, fromInt(other_0));
+          var i = convertToInt(tmp$ret$2);
+          if (!(segment.xw_1 === id)) {
+            var tmp0_elvis_lhs = findSegmentSend(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var tmp_0;
+              if (closed) {
+                return Companion_getInstance().u16(this.w15());
+              } else {
+                continue $l$loop_0;
+              }
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          switch (updateCellSend(this, segment, i, element, s, waiter, closed)) {
+            case 0:
+              segment.n15();
+              return Companion_getInstance().b16(Unit_instance);
+            case 1:
+              return Companion_getInstance().b16(Unit_instance);
+            case 2:
+              if (closed) {
+                segment.d15();
+                return Companion_getInstance().u16(this.w15());
+              }
+
+              var tmp2_safe_receiver = (!(waiter == null) ? isInterface(waiter, Waiter()) : false) ? waiter : null;
+              if (tmp2_safe_receiver == null)
+                null;
+              else {
+                prepareSenderForSuspension(this, tmp2_safe_receiver, segment, i);
+              }
+
+              var tmp0 = segment.xw_1;
+              // Inline function 'kotlin.Long.times' call
+
+              var other_1 = get_SEGMENT_SIZE();
+              // Inline function 'kotlin.Long.plus' call
+
+              var this_0 = multiply(tmp0, fromInt(other_1));
+              var tmp$ret$5 = add(this_0, fromInt(i));
+              this.s16(tmp$ret$5);
+              return Companion_getInstance().b16(Unit_instance);
+            case 4:
+              if (s < this.v15()) {
+                segment.n15();
+              }
+
+              return Companion_getInstance().u16(this.w15());
+            case 5:
+              segment.n15();
+              continue $l$loop_0;
+            case 3:
+              var message = 'unexpected';
+              throw IllegalStateException().w4(toString_0(message));
+          }
+        }
+        return tmp$ret$3;
+      }
+      e16() {
+      }
+      x15() {
+      }
+      s16(globalCellIndex) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        var segment = this.w14_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          var r = this.s14_1.kotlinx$atomicfu$value;
+          // Inline function 'kotlin.Long.plus' call
+          var other = this.p14_1;
+          var tmp0 = add(r, fromInt(other));
+          // Inline function 'kotlin.math.max' call
+          var b = _get_bufferEndCounter__2d4hee(this);
+          if (globalCellIndex < (tmp0 >= b ? tmp0 : b))
+            return Unit_instance;
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$3 = add(r, fromInt(1));
+          if (!this.s14_1.atomicfu$compareAndSet(r, tmp$ret$3))
+            continue $l$loop_0;
+          // Inline function 'kotlin.Long.div' call
+          var other_0 = get_SEGMENT_SIZE();
+          var id = divide(r, fromInt(other_0));
+          // Inline function 'kotlin.Long.rem' call
+          var other_1 = get_SEGMENT_SIZE();
+          var tmp$ret$5 = modulo(r, fromInt(other_1));
+          var i = convertToInt(tmp$ret$5);
+          if (!(segment.xw_1 === id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              continue $l$loop_0;
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          var updCellResult = updateCellReceive(this, segment, i, r, null);
+          if (updCellResult === get_FAILED()) {
+            if (r < this.t15()) {
+              segment.n15();
+            }
+          } else {
+            segment.n15();
+            var tmp1_safe_receiver = this.q14_1;
+            var tmp_0;
+            if (tmp1_safe_receiver == null) {
+              tmp_0 = null;
+            } else {
+              tmp_0 = callUndeliveredElementCatchingException(tmp1_safe_receiver, (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE());
+            }
+            var tmp2_safe_receiver = tmp_0;
+            if (tmp2_safe_receiver == null)
+              null;
+            else {
+              // Inline function 'kotlin.let' call
+              throw tmp2_safe_receiver;
+            }
+          }
+        }
+      }
+      c15(globalIndex) {
+        if (_get_isRendezvousOrUnlimited__3mdufi(this))
+          return Unit_instance;
+        while (_get_bufferEndCounter__2d4hee(this) <= globalIndex) {
+        }
+        // Inline function 'kotlin.repeat' call
+        var times = get_EXPAND_BUFFER_COMPLETION_WAIT_ITERATIONS();
+        var inductionVariable = 0;
+        if (inductionVariable < times)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var b = _get_bufferEndCounter__2d4hee(this);
+            // Inline function 'kotlinx.coroutines.channels.ebCompletedCounter' call
+            var ebCompleted = this.u14_1.kotlinx$atomicfu$value & 4611686018427387903n;
+            if (b === ebCompleted && b === _get_bufferEndCounter__2d4hee(this))
+              return Unit_instance;
+          }
+           while (inductionVariable < times);
+        var tmp0 = this.u14_1;
+        $l$block: {
+          // Inline function 'kotlinx.atomicfu.update' call
+          while (true) {
+            var cur = tmp0.kotlinx$atomicfu$value;
+            // Inline function 'kotlinx.coroutines.channels.ebCompletedCounter' call
+            var tmp$ret$3 = cur & 4611686018427387903n;
+            var upd = constructEBCompletedAndPauseFlag(tmp$ret$3, true);
+            if (tmp0.atomicfu$compareAndSet(cur, upd)) {
+              break $l$block;
+            }
+          }
+        }
+        while (true) {
+          var b_0 = _get_bufferEndCounter__2d4hee(this);
+          var ebCompletedAndBit = this.u14_1.kotlinx$atomicfu$value;
+          // Inline function 'kotlinx.coroutines.channels.ebCompletedCounter' call
+          var ebCompleted_0 = ebCompletedAndBit & 4611686018427387903n;
+          // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+          var pauseExpandBuffers = !((ebCompletedAndBit & 4611686018427387904n) === 0n);
+          if (b_0 === ebCompleted_0 && b_0 === _get_bufferEndCounter__2d4hee(this)) {
+            var tmp0_0 = this.u14_1;
+            $l$block_0: {
+              // Inline function 'kotlinx.atomicfu.update' call
+              while (true) {
+                var cur_0 = tmp0_0.kotlinx$atomicfu$value;
+                // Inline function 'kotlinx.coroutines.channels.ebCompletedCounter' call
+                var tmp$ret$8 = cur_0 & 4611686018427387903n;
+                var upd_0 = constructEBCompletedAndPauseFlag(tmp$ret$8, false);
+                if (tmp0_0.atomicfu$compareAndSet(cur_0, upd_0)) {
+                  break $l$block_0;
+                }
+              }
+            }
+            return Unit_instance;
+          }
+          if (!pauseExpandBuffers) {
+            this.u14_1.atomicfu$compareAndSet(ebCompletedAndBit, constructEBCompletedAndPauseFlag(ebCompleted_0, true));
+          }
+        }
+      }
+      k1() {
+        return new (BufferedChannelIterator())(this);
+      }
+      u15() {
+        var tmp = this.z14_1.kotlinx$atomicfu$value;
+        return (tmp == null ? true : tmp instanceof Error) ? tmp : THROW_CCE();
+      }
+      w15() {
+        var tmp0_elvis_lhs = this.u15();
+        return tmp0_elvis_lhs == null ? ClosedSendChannelException().g17('Channel was closed') : tmp0_elvis_lhs;
+      }
+      h17() {
+      }
+      i17(cause) {
+        return this.j17(cause, false);
+      }
+      lu(cause) {
+        this.l17(cause);
+      }
+      l17(cause) {
+        return this.j17(cause == null ? CancellationException().vc('Channel was cancelled') : cause, true);
+      }
+      j17(cause, cancel) {
+        if (cancel) {
+          markCancellationStarted(this);
+        }
+        var closedByThisOperation = this.z14_1.atomicfu$compareAndSet(get_NO_CLOSE_CAUSE(), cause);
+        if (cancel) {
+          markCancelled(this);
+        } else {
+          markClosed(this);
+        }
+        completeCloseOrCancel(this);
+        // Inline function 'kotlin.also' call
+        this.h17();
+        if (closedByThisOperation) {
+          invokeCloseHandler(this);
+        }
+        return closedByThisOperation;
+      }
+      t16() {
+        return false;
+      }
+      r16() {
+        return _get_isClosedForSend0__kxgf9m(this, this.r14_1.kotlinx$atomicfu$value);
+      }
+      s15() {
+        return _get_isClosedForReceive0__f7qknl(this, this.r14_1.kotlinx$atomicfu$value);
+      }
+      v16() {
+        $l$loop: while (true) {
+          var segment = this.w14_1.kotlinx$atomicfu$value;
+          var r = this.v15();
+          var s = this.t15();
+          if (s <= r)
+            return false;
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(r, fromInt(other));
+          if (!(segment.xw_1 === id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var tmp_0;
+              if (this.w14_1.kotlinx$atomicfu$value.xw_1 < id) {
+                return false;
+              } else {
+                continue $l$loop;
+              }
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          segment.n15();
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$1 = modulo(r, fromInt(other_0));
+          var i = convertToInt(tmp$ret$1);
+          if (isCellNonEmpty(this, segment, i, r))
+            return true;
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$2 = add(r, fromInt(1));
+          this.s14_1.atomicfu$compareAndSet(r, tmp$ret$2);
+        }
+      }
+      toString() {
+        var sb = StringBuilder().a1();
+        // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+        var this_0 = this.r14_1.kotlinx$atomicfu$value;
+        var tmp0_subject = convertToInt(shiftRight(this_0, 60));
+        if (tmp0_subject === 2) {
+          sb.ib('closed,');
+        } else if (tmp0_subject === 3) {
+          sb.ib('cancelled,');
+        }
+        sb.ib('capacity=' + this.p14_1 + ',');
+        sb.ib('data=[');
+        // Inline function 'kotlin.collections.filter' call
+        var tmp0 = listOf([this.w14_1.kotlinx$atomicfu$value, this.v14_1.kotlinx$atomicfu$value, this.x14_1.kotlinx$atomicfu$value]);
+        // Inline function 'kotlin.collections.filterTo' call
+        var destination = ArrayList().r1();
+        var _iterator__ex2g4s = tmp0.k1();
+        while (_iterator__ex2g4s.l1()) {
+          var element = _iterator__ex2g4s.m1();
+          if (!(element === get_NULL_SEGMENT())) {
+            destination.v(element);
+          }
+        }
+        var tmp$ret$4;
+        $l$block: {
+          // Inline function 'kotlin.collections.minBy' call
+          var iterator = destination.k1();
+          if (!iterator.l1())
+            throw NoSuchElementException().i6();
+          var minElem = iterator.m1();
+          if (!iterator.l1()) {
+            tmp$ret$4 = minElem;
+            break $l$block;
+          }
+          var minValue = minElem.xw_1;
+          do {
+            var e = iterator.m1();
+            var v = e.xw_1;
+            if (compareTo(minValue, v) > 0) {
+              minElem = e;
+              minValue = v;
+            }
+          }
+           while (iterator.l1());
+          tmp$ret$4 = minElem;
+        }
+        var firstSegment = tmp$ret$4;
+        var r = this.v15();
+        var s = this.t15();
+        var segment = firstSegment;
+        append_elements: while (true) {
+          var inductionVariable = 0;
+          var last_0 = get_SEGMENT_SIZE();
+          if (inductionVariable < last_0)
+            process_cell: do {
+              var i = inductionVariable;
+              inductionVariable = inductionVariable + 1 | 0;
+              var tmp0_0 = segment.xw_1;
+              // Inline function 'kotlin.Long.times' call
+              var other = get_SEGMENT_SIZE();
+              // Inline function 'kotlin.Long.plus' call
+              var this_1 = multiply(tmp0_0, fromInt(other));
+              var globalCellIndex = add(this_1, fromInt(i));
+              if (globalCellIndex >= s && globalCellIndex >= r)
+                break append_elements;
+              var cellState = segment.l14(i);
+              var element_0 = segment.i14(i);
+              var tmp;
+              if (!(cellState == null) ? isInterface(cellState, CancellableContinuation()) : false) {
+                tmp = globalCellIndex < r && globalCellIndex >= s ? 'receive' : globalCellIndex < s && globalCellIndex >= r ? 'send' : 'cont';
+              } else {
+                if (!(cellState == null) ? isInterface(cellState, SelectInstance()) : false) {
+                  tmp = globalCellIndex < r && globalCellIndex >= s ? 'onReceive' : globalCellIndex < s && globalCellIndex >= r ? 'onSend' : 'select';
+                } else {
+                  if (cellState instanceof ReceiveCatching()) {
+                    tmp = 'receiveCatching';
+                  } else {
+                    if (cellState instanceof SendBroadcast()) {
+                      tmp = 'sendBroadcast';
+                    } else {
+                      if (cellState instanceof WaiterEB()) {
+                        tmp = 'EB(' + cellState.toString() + ')';
+                      } else {
+                        if (equals(cellState, get_RESUMING_BY_RCV()) || equals(cellState, get_RESUMING_BY_EB())) {
+                          tmp = 'resuming_sender';
+                        } else {
+                          if (cellState == null || (equals(cellState, get_IN_BUFFER()) || equals(cellState, get_DONE_RCV())) || (equals(cellState, get_POISONED()) || equals(cellState, get_INTERRUPTED_RCV()) || (equals(cellState, get_INTERRUPTED_SEND()) || equals(cellState, get_CHANNEL_CLOSED())))) {
+                            continue process_cell;
+                          } else {
+                            tmp = toString_0(cellState);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              var cellStateString = tmp;
+              if (!(element_0 == null)) {
+                sb.ib('(' + cellStateString + ',' + toString(element_0) + '),');
+              } else {
+                sb.ib(cellStateString + ',');
+              }
+            }
+             while (inductionVariable < last_0);
+          var tmp2_elvis_lhs = segment.j15();
+          var tmp_0;
+          if (tmp2_elvis_lhs == null) {
+            break append_elements;
+          } else {
+            tmp_0 = tmp2_elvis_lhs;
+          }
+          segment = tmp_0;
+        }
+        if (last(sb) === _Char___init__impl__6a9atx(44)) {
+          sb.ug(sb.a() - 1 | 0);
+        }
+        sb.ib(']');
+        return sb.toString();
+      }
+    }
+    protoOf($).k17 = close$default;
+    protoOf($).m17 = cancel$default;
+    initMetadataForClass($, 'BufferedChannel', VOID, VOID, [SendChannel(), ReceiveChannel()], [1, 4, 0, 3]);
+    BufferedChannelClass = $;
+  }
+  return BufferedChannelClass;
+}
+var WaiterEBClass;
+function WaiterEB() {
+  if (WaiterEBClass === VOID) {
+    class $ {
+      constructor(waiter) {
+        this.y15_1 = waiter;
+      }
+      toString() {
+        return 'WaiterEB(' + toString_0(this.y15_1) + ')';
+      }
+    }
+    initMetadataForClass($, 'WaiterEB');
+    WaiterEBClass = $;
+  }
+  return WaiterEBClass;
+}
+function initialBufferEnd(capacity) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  switch (capacity) {
+    case 0:
+      return 0n;
+    case 2147483647:
+      return 9223372036854775807n;
+    default:
+      return fromInt(capacity);
+  }
+}
+var ReceiveCatchingClass;
+function ReceiveCatching() {
+  if (ReceiveCatchingClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'ReceiveCatching', VOID, VOID, [Waiter()]);
+    ReceiveCatchingClass = $;
+  }
+  return ReceiveCatchingClass;
+}
+function tryResume0(_this__u8e3s4, value, onCancellation) {
+  onCancellation = onCancellation === VOID ? null : onCancellation;
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  // Inline function 'kotlin.let' call
+  var token = _this__u8e3s4.uv(value, null, onCancellation);
+  var tmp;
+  if (!(token == null)) {
+    _this__u8e3s4.vv(token);
+    tmp = true;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function constructEBCompletedAndPauseFlag(counter, pauseEB) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return add(pauseEB ? 4611686018427387904n : 0n, counter);
+}
+function constructSendersAndCloseStatus(counter, closeStatus) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return add(shiftLeft(fromInt(closeStatus), 60), counter);
+}
+function createSegmentFunction() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return createSegment$ref();
+}
+function createSegment(id, prev) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return new (ChannelSegment())(id, prev, prev.f14(), 0);
+}
+function createSegment$ref() {
+  var l = (p0, p1) => createSegment(p0, p1);
+  l.callableName = 'createSegment';
+  return l;
+}
+var properties_initialized_BufferedChannel_kt_58tjvw;
+function _init_properties_BufferedChannel_kt__d6uc4y() {
+  if (!properties_initialized_BufferedChannel_kt_58tjvw) {
+    properties_initialized_BufferedChannel_kt_58tjvw = true;
+    NULL_SEGMENT = new (ChannelSegment())(-1n, null, null, 0);
+    SEGMENT_SIZE = systemProp('kotlinx.coroutines.bufferedChannel.segmentSize', 32);
+    EXPAND_BUFFER_COMPLETION_WAIT_ITERATIONS = systemProp('kotlinx.coroutines.bufferedChannel.expandBufferCompletionWaitIterations', 10000);
+    BUFFERED = new (Symbol())('BUFFERED');
+    IN_BUFFER = new (Symbol())('SHOULD_BUFFER');
+    RESUMING_BY_RCV = new (Symbol())('S_RESUMING_BY_RCV');
+    RESUMING_BY_EB = new (Symbol())('RESUMING_BY_EB');
+    POISONED = new (Symbol())('POISONED');
+    DONE_RCV = new (Symbol())('DONE_RCV');
+    INTERRUPTED_SEND = new (Symbol())('INTERRUPTED_SEND');
+    INTERRUPTED_RCV = new (Symbol())('INTERRUPTED_RCV');
+    CHANNEL_CLOSED = new (Symbol())('CHANNEL_CLOSED');
+    SUSPEND = new (Symbol())('SUSPEND');
+    SUSPEND_NO_WAITER = new (Symbol())('SUSPEND_NO_WAITER');
+    FAILED = new (Symbol())('FAILED');
+    NO_RECEIVE_RESULT = new (Symbol())('NO_RECEIVE_RESULT');
+    CLOSE_HANDLER_CLOSED = new (Symbol())('CLOSE_HANDLER_CLOSED');
+    CLOSE_HANDLER_INVOKED = new (Symbol())('CLOSE_HANDLER_INVOKED');
+    NO_CLOSE_CAUSE = new (Symbol())('NO_CLOSE_CAUSE');
+  }
+}
+//region block: exports
+export {
+  BufferedChannel as BufferedChannel3lgkhzot5gmk6,
+};
+//endregion
+
+//# sourceMappingURL=BufferedChannel.mjs.map