@attocash/commons-js 5.0.0

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

@@ -0,0 +1,3352 @@
+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 { toLongw1zpgk99d84b as toLong } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  recoverStackTrace3k4hvtb53ci4z as recoverStackTrace,
+  recoverStackTrace2i3si2i8nvw1k as recoverStackTrace_0,
+} from '../internal/StackTraceRecovery.mjs';
+import { intercepted2ogpsikxxj4u0 as intercepted } 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 { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../kotlin-kotlin-stdlib/kotlin/Primitives.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.x2b_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.w2b_1 = channel;
+        this.x2b_1 = atomicfu$AtomicRefArray$ofNulls(imul(get_SEGMENT_SIZE(), 2));
+      }
+      y2b() {
+        return ensureNotNull(this.w2b_1);
+      }
+      z2b() {
+        return get_SEGMENT_SIZE();
+      }
+      a2c(index, element) {
+        setElementLazy(this, index, element);
+      }
+      b2c(index) {
+        var tmp = this.x2b_1.atomicfu$get(imul(index, 2)).kotlinx$atomicfu$value;
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      c2c(index) {
+        // Inline function 'kotlin.also' call
+        var this_0 = this.b2c(index);
+        this.d2c(index);
+        return this_0;
+      }
+      d2c(index) {
+        setElementLazy(this, index, null);
+      }
+      e2c(index) {
+        return this.x2b_1.atomicfu$get(imul(index, 2) + 1 | 0).kotlinx$atomicfu$value;
+      }
+      f2c(index, value) {
+        this.x2b_1.atomicfu$get(imul(index, 2) + 1 | 0).kotlinx$atomicfu$value = value;
+      }
+      g2c(index, from, to) {
+        return this.x2b_1.atomicfu$get(imul(index, 2) + 1 | 0).atomicfu$compareAndSet(from, to);
+      }
+      h2c(index, update) {
+        return this.x2b_1.atomicfu$get(imul(index, 2) + 1 | 0).atomicfu$getAndSet(update);
+      }
+      k22(index, cause, context) {
+        var isSender = index >= get_SEGMENT_SIZE();
+        var index_0 = isSender ? index - get_SEGMENT_SIZE() | 0 : index;
+        var element = this.b2c(index_0);
+        $l$loop: while (true) {
+          var cur = this.e2c(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.g2c(index_0, cur, update)) {
+              this.d2c(index_0);
+              this.u2c(index_0, !isSender);
+              if (isSender) {
+                var tmp0_safe_receiver = this.y2b().j2c_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.d2c(index_0);
+              if (isSender) {
+                var tmp1_safe_receiver = this.y2b().j2c_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().o4(toString_0(message));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      u2c(index, receiver) {
+        if (receiver) {
+          var tmp = this.y2b();
+          var tmp0 = this.i22_1;
+          // Inline function 'kotlin.Long.times' call
+          var other = get_SEGMENT_SIZE();
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$1 = tmp0.r3(toLong(other)).p3(toLong(index));
+          tmp.v2c(tmp$ret$1);
+        }
+        this.w2c();
+      }
+    }
+    initMetadataForClass($, 'ChannelSegment');
+    ChannelSegmentClass = $;
+  }
+  return ChannelSegmentClass;
+}
+function onClosedHasNext($this) {
+  $this.i2d_1 = get_CHANNEL_CLOSED();
+  var tmp0_elvis_lhs = $this.k2d_1.l2d();
+  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.j2d_1 = cancellable;
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImplOnNoWaiter' call
+    var this_0 = $this.k2d_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.a2(this_0.m2d()) < 0) {
+        segment.g2d();
+      }
+      $l$block_0: {
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+        var segment_0 = this_0.p2c_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          if (this_0.n2d()) {
+            onClosedHasNextNoWaiterSuspend($this);
+            break $l$block_0;
+          }
+          var r_0 = this_0.l2c_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = r_0.s3(toLong(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var i = r_0.t3(toLong(other_0)).c2();
+          if (!segment_0.i22_1.equals(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.a2(this_0.m2d()) < 0) {
+              segment_0.g2d();
+            }
+            continue $l$loop_0;
+          } else if (updCellResult_0 === get_SUSPEND_NO_WAITER()) {
+            // Inline function 'kotlin.error' call
+            var message = 'unexpected';
+            throw IllegalStateException().o4(toString_0(message));
+          } else {
+            segment_0.g2d();
+            var element = (updCellResult_0 == null ? true : !(updCellResult_0 == null)) ? updCellResult_0 : THROW_CCE();
+            $this.i2d_1 = element;
+            $this.j2d_1 = null;
+            var tmp0_safe_receiver = $this.k2d_1.j2c_1;
+            cancellable.k21(true, tmp0_safe_receiver == null ? null : bindCancellationFun($this.k2d_1, tmp0_safe_receiver, element));
+          }
+          break $l$block_0;
+        }
+      }
+    } else {
+      segment.g2d();
+      var element_0 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+      $this.i2d_1 = element_0;
+      $this.j2d_1 = null;
+      var tmp0_safe_receiver_0 = $this.k2d_1.j2c_1;
+      cancellable.k21(true, tmp0_safe_receiver_0 == null ? null : bindCancellationFun($this.k2d_1, tmp0_safe_receiver_0, element_0));
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.i23();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.b20();
+}
+function onClosedHasNextNoWaiterSuspend($this) {
+  var cont = ensureNotNull($this.j2d_1);
+  $this.j2d_1 = null;
+  $this.i2d_1 = get_CHANNEL_CLOSED();
+  var cause = $this.k2d_1.l2d();
+  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.lc(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.lc(tmp$ret$2);
+  }
+}
+var $hasNextCOROUTINE$Class;
+function $hasNextCOROUTINE$() {
+  if ($hasNextCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.w2d_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 8;
+                if (!(this.w2d_1.i2d_1 === get_NO_RECEIVE_RESULT()) && !(this.w2d_1.i2d_1 === get_CHANNEL_CLOSED())) {
+                  var tmp_0 = this;
+                  tmp_0.x2d_1 = true;
+                  this.ac_1 = 11;
+                  continue $sm;
+                } else {
+                  var tmp_1 = this;
+                  tmp_1.y2d_1 = this.w2d_1.k2d_1;
+                  var tmp_2 = this;
+                  tmp_2.z2d_1 = null;
+                  this.ac_1 = 1;
+                  continue $sm;
+                }
+
+              case 1:
+                this.b2e_1 = this.y2d_1;
+                this.c2e_1 = this.z2d_1;
+                this.d2e_1 = this.b2e_1.p2c_1.kotlinx$atomicfu$value;
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (!true) {
+                  this.ac_1 = 9;
+                  continue $sm;
+                }
+
+                if (this.b2e_1.n2d()) {
+                  var tmp_3 = this;
+                  tmp_3.a2e_1 = onClosedHasNext(this.w2d_1);
+                  this.ac_1 = 10;
+                  continue $sm;
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 3:
+                this.e2e_1 = this.b2e_1.l2c_1.atomicfu$getAndIncrement$long();
+                var tmp_4 = this;
+                var tmp0 = this.e2e_1;
+                var other = get_SEGMENT_SIZE();
+                tmp_4.f2e_1 = tmp0.s3(toLong(other));
+                var tmp_5 = this;
+                var tmp0_0 = this.e2e_1;
+                var other_0 = get_SEGMENT_SIZE();
+                tmp_5.g2e_1 = tmp0_0.t3(toLong(other_0)).c2();
+                if (!this.d2e_1.i22_1.equals(this.f2e_1)) {
+                  this.h2e_1 = findSegmentReceive(this.b2e_1, this.f2e_1, this.d2e_1);
+                  if (this.h2e_1 == null) {
+                    this.ac_1 = 2;
+                    var tmp_6 = this;
+                    continue $sm;
+                  } else {
+                    this.i2e_1 = this.h2e_1;
+                    this.ac_1 = 4;
+                    continue $sm;
+                  }
+                } else {
+                  this.ac_1 = 5;
+                  continue $sm;
+                }
+
+              case 4:
+                this.d2e_1 = this.i2e_1;
+                this.ac_1 = 5;
+                continue $sm;
+              case 5:
+                this.j2e_1 = updateCellReceive(this.b2e_1, this.d2e_1, this.g2e_1, this.e2e_1, this.c2e_1);
+                if (this.j2e_1 === get_SUSPEND()) {
+                  var tmp_7 = this;
+                  var tmp_8 = this.c2e_1;
+                  var tmp1_safe_receiver = (!(tmp_8 == null) ? isInterface(tmp_8, Waiter()) : false) ? tmp_8 : null;
+                  if (tmp1_safe_receiver == null)
+                    null;
+                  else {
+                    prepareReceiverForSuspension(this.b2e_1, tmp1_safe_receiver, this.d2e_1, this.g2e_1);
+                  }
+                  this.d2e_1;
+                  this.g2e_1;
+                  this.e2e_1;
+                  var message = 'unreachable';
+                  throw IllegalStateException().o4(toString_0(message));
+                } else {
+                  if (this.j2e_1 === get_FAILED()) {
+                    if (this.e2e_1.a2(this.b2e_1.m2d()) < 0) {
+                      this.d2e_1.g2d();
+                    }
+                    this.ac_1 = 2;
+                    var tmp_9 = this;
+                    continue $sm;
+                  } else {
+                    if (this.j2e_1 === get_SUSPEND_NO_WAITER()) {
+                      var tmp_10 = this;
+                      tmp_10.l2e_1 = this.d2e_1;
+                      var tmp_11 = this;
+                      tmp_11.m2e_1 = this.g2e_1;
+                      var tmp_12 = this;
+                      tmp_12.n2e_1 = this.e2e_1;
+                      this.o2e_1 = this.l2e_1;
+                      this.p2e_1 = this.m2e_1;
+                      this.q2e_1 = this.n2e_1;
+                      this.ac_1 = 6;
+                      suspendResult = hasNextOnNoWaiterSuspend(this.w2d_1, this.o2e_1, this.p2e_1, this.q2e_1, this);
+                      if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                        return suspendResult;
+                      }
+                      continue $sm;
+                    } else {
+                      var tmp_13 = this;
+                      this.d2e_1.g2d();
+                      var tmp_14 = this.j2e_1;
+                      var element = (tmp_14 == null ? true : !(tmp_14 == null)) ? tmp_14 : THROW_CCE();
+                      this.w2d_1.i2d_1 = element;
+                      tmp_13.k2e_1 = true;
+                      this.ac_1 = 7;
+                      continue $sm;
+                    }
+                  }
+                }
+
+              case 6:
+                var tmp_15 = this;
+                return suspendResult;
+              case 7:
+                this.a2e_1 = this.k2e_1;
+                this.ac_1 = 10;
+                continue $sm;
+              case 8:
+                throw this.dc_1;
+              case 9:
+                if (false) {
+                  this.ac_1 = 1;
+                  continue $sm;
+                }
+
+                this.ac_1 = 10;
+                continue $sm;
+              case 10:
+                this.x2d_1 = this.a2e_1;
+                this.ac_1 = 11;
+                continue $sm;
+              case 11:
+                return this.x2d_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 8) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $hasNextCOROUTINE$Class = $;
+  }
+  return $hasNextCOROUTINE$Class;
+}
+function _get_bufferEndCounter__2d4hee($this) {
+  return $this.m2c_1.kotlinx$atomicfu$value;
+}
+function _get_isRendezvousOrUnlimited__3mdufi($this) {
+  // Inline function 'kotlin.let' call
+  var it = _get_bufferEndCounter__2d4hee($this);
+  return it.equals(new (Long())(0, 0)) || it.equals(new (Long())(-1, 2147483647));
+}
+function onClosedSend($this, element, $completion) {
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.a23();
+  $l$block: {
+    var tmp0_safe_receiver = $this.j2c_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.r2e());
+      // 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.lc(tmp$ret$0);
+      break $l$block;
+    }
+    // Inline function 'kotlinx.coroutines.resumeWithStackTrace' call
+    var exception_0 = $this.r2e();
+    // 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.lc(tmp$ret$4);
+  }
+  return cancellable.b20();
+}
+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.g2d();
+        // Inline function 'kotlin.coroutines.resume' call
+
+        // Inline function 'kotlin.Companion.success' call
+
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+        cancellable.lc(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.lc(tmp$ret$3);
+        break;
+      case 2:
+        prepareSenderForSuspension($this, cancellable, segment, index);
+        break;
+      case 4:
+        if (s.a2($this.s2e()) < 0) {
+          segment.g2d();
+        }
+
+        onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+        break;
+      case 5:
+        segment.g2d();
+        $l$block_5: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+          var segment_0 = $this.o2c_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            var sendersAndCloseStatusCur = $this.k2c_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+            var s_0 = sendersAndCloseStatusCur.c4(new (Long())(-1, 268435455));
+            var closed = _get_isClosedForSend0__kxgf9m($this, sendersAndCloseStatusCur);
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = s_0.s3(toLong(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var i = s_0.t3(toLong(other_0)).c2();
+            if (!segment_0.i22_1.equals(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.g2d();
+                // Inline function 'kotlin.coroutines.resume' call
+
+                // Inline function 'kotlin.Companion.success' call
+
+                var tmp$ret$12 = _Result___init__impl__xyqfz8(Unit_instance);
+                cancellable.lc(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.lc(tmp$ret$15);
+                break $l$block_5;
+              case 2:
+                if (closed) {
+                  segment_0.w2c();
+                  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.a2($this.s2e()) < 0) {
+                  segment_0.g2d();
+                }
+
+                onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+                break $l$block_5;
+              case 5:
+                segment_0.g2d();
+                continue $l$loop_0;
+              case 3:
+                // Inline function 'kotlin.error' call
+
+                var message = 'unexpected';
+                throw IllegalStateException().o4(toString_0(message));
+            }
+          }
+        }
+
+        break;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message_0 = 'unexpected';
+        throw IllegalStateException().o4(toString_0(message_0));
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.i23();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.b20();
+}
+function prepareSenderForSuspension($this, _this__u8e3s4, segment, index) {
+  _this__u8e3s4.n23(segment, index + get_SEGMENT_SIZE() | 0);
+}
+function onClosedSendOnNoWaiterSuspend($this, element, cont) {
+  var tmp0_safe_receiver = $this.j2c_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    callUndeliveredElement(tmp0_safe_receiver, element, cont.gc());
+  }
+  // Inline function 'kotlin.coroutines.resumeWithException' call
+  // Inline function 'kotlin.Companion.failure' call
+  var exception = recoverStackTrace_0($this.r2e(), cont);
+  var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+  cont.lc(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.a2c(index, element);
+  if (closed)
+    return updateCellSendSlow($this, segment, index, element, s, waiter, closed);
+  var state = segment.e2c(index);
+  if (state === null) {
+    if (bufferOrRendezvousSend($this, s)) {
+      if (segment.g2c(index, null, get_BUFFERED())) {
+        return 1;
+      }
+    } else {
+      if (waiter == null) {
+        return 3;
+      } else {
+        if (segment.g2c(index, null, waiter))
+          return 2;
+      }
+    }
+  } else {
+    if (!(state == null) ? isInterface(state, Waiter()) : false) {
+      segment.d2c(index);
+      var tmp;
+      if (tryResumeReceiver($this, state, element)) {
+        segment.f2c(index, get_DONE_RCV());
+        $this.t2e();
+        tmp = 0;
+      } else {
+        if (!(segment.h2c(index, get_INTERRUPTED_RCV()) === get_INTERRUPTED_RCV())) {
+          segment.u2c(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.e2c(index);
+    if (state === null) {
+      if (bufferOrRendezvousSend($this, s) && !closed) {
+        if (segment.g2c(index, null, get_BUFFERED())) {
+          return 1;
+        }
+      } else {
+        if (closed) {
+          if (segment.g2c(index, null, get_INTERRUPTED_SEND())) {
+            segment.u2c(index, false);
+            return 4;
+          }
+        } else if (waiter == null)
+          return 3;
+        else if (segment.g2c(index, null, waiter))
+          return 2;
+      }
+    } else if (state === get_IN_BUFFER()) {
+      if (segment.g2c(index, state, get_BUFFERED())) {
+        return 1;
+      }
+    } else if (state === get_INTERRUPTED_RCV()) {
+      segment.d2c(index);
+      return 5;
+    } else if (state === get_POISONED()) {
+      segment.d2c(index);
+      return 5;
+    } else if (state === get_CHANNEL_CLOSED()) {
+      segment.d2c(index);
+      completeCloseOrCancel($this);
+      return 4;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      segment.d2c(index);
+      var tmp;
+      if (state instanceof WaiterEB()) {
+        tmp = state.u2e_1;
+      } else {
+        tmp = state;
+      }
+      var receiver = tmp;
+      var tmp_0;
+      if (tryResumeReceiver($this, receiver, element)) {
+        segment.f2c(index, get_DONE_RCV());
+        $this.t2e();
+        tmp_0 = 0;
+      } else {
+        if (!(segment.h2c(index, get_INTERRUPTED_RCV()) === get_INTERRUPTED_RCV())) {
+          segment.u2c(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.c4(new (Long())(-1, 268435455));
+  return !bufferOrRendezvousSend($this, tmp$ret$0);
+}
+function bufferOrRendezvousSend($this, curSenders) {
+  var tmp;
+  if (curSenders.a2(_get_bufferEndCounter__2d4hee($this)) < 0) {
+    tmp = true;
+  } else {
+    var tmp0 = $this.s2e();
+    // Inline function 'kotlin.Long.plus' call
+    var other = $this.i2c_1;
+    var tmp$ret$0 = tmp0.p3(toLong(other));
+    tmp = curSenders.a2(tmp$ret$0) < 0;
+  }
+  return tmp;
+}
+function tryResumeReceiver($this, _this__u8e3s4, element) {
+  var tmp;
+  if (isInterface(_this__u8e3s4, SelectInstance())) {
+    tmp = _this__u8e3s4.z2e($this, element);
+  } else {
+    if (_this__u8e3s4 instanceof ReceiveCatching()) {
+      if (!(_this__u8e3s4 instanceof ReceiveCatching()))
+        THROW_CCE();
+      var tmp_0 = Companion_getInstance().x2e(element);
+      var tmp1_safe_receiver = $this.j2c_1;
+      tmp = tryResume0(_this__u8e3s4.y2e_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.v2e(element);
+      } else {
+        if (isInterface(_this__u8e3s4, CancellableContinuation())) {
+          if (!isInterface(_this__u8e3s4, CancellableContinuation()))
+            THROW_CCE();
+          var tmp2_safe_receiver = $this.j2c_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().o4(toString_0(message));
+        }
+      }
+    }
+  }
+  return tmp;
+}
+function receiveOnNoWaiterSuspend($this, segment, index, r, $completion) {
+  var cancellable = getOrCreateCancellableContinuation(intercepted($completion));
+  try {
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImplOnNoWaiter' call
+    var updCellResult = updateCellReceive($this, segment, index, r, cancellable);
+    if (updCellResult === get_SUSPEND()) {
+      prepareReceiverForSuspension($this, cancellable, segment, index);
+    } else if (updCellResult === get_FAILED()) {
+      if (r.a2($this.m2d()) < 0) {
+        segment.g2d();
+      }
+      $l$block_0: {
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+        var segment_0 = $this.p2c_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          if ($this.n2d()) {
+            onClosedReceiveOnNoWaiterSuspend($this, cancellable);
+            break $l$block_0;
+          }
+          var r_0 = $this.l2c_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = r_0.s3(toLong(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var i = r_0.t3(toLong(other_0)).c2();
+          if (!segment_0.i22_1.equals(id)) {
+            var tmp0_elvis_lhs = findSegmentReceive($this, 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, segment_0, i, r_0, cancellable);
+          if (updCellResult_0 === get_SUSPEND()) {
+            var tmp1_safe_receiver = (!(cancellable == null) ? isInterface(cancellable, Waiter()) : false) ? cancellable : null;
+            if (tmp1_safe_receiver == null)
+              null;
+            else {
+              prepareReceiverForSuspension($this, tmp1_safe_receiver, segment_0, i);
+            }
+          } else if (updCellResult_0 === get_FAILED()) {
+            if (r_0.a2($this.m2d()) < 0) {
+              segment_0.g2d();
+            }
+            continue $l$loop_0;
+          } else if (updCellResult_0 === get_SUSPEND_NO_WAITER()) {
+            // Inline function 'kotlin.error' call
+            var message = 'unexpected';
+            throw IllegalStateException().o4(toString_0(message));
+          } else {
+            segment_0.g2d();
+            var element = (updCellResult_0 == null ? true : !(updCellResult_0 == null)) ? updCellResult_0 : THROW_CCE();
+            var tmp0_safe_receiver = $this.j2c_1;
+            var onCancellation = tmp0_safe_receiver == null ? null : bindCancellationFun_0($this, tmp0_safe_receiver);
+            cancellable.k21(element, onCancellation);
+          }
+          break $l$block_0;
+        }
+      }
+    } else {
+      segment.g2d();
+      var element_0 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+      var tmp0_safe_receiver_0 = $this.j2c_1;
+      var onCancellation_0 = tmp0_safe_receiver_0 == null ? null : bindCancellationFun_0($this, tmp0_safe_receiver_0);
+      cancellable.k21(element_0, onCancellation_0);
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.i23();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.b20();
+}
+function prepareReceiverForSuspension($this, _this__u8e3s4, segment, index) {
+  $this.a2f();
+  _this__u8e3s4.n23(segment, index);
+}
+function onClosedReceiveOnNoWaiterSuspend($this, cont) {
+  // Inline function 'kotlin.coroutines.resumeWithException' call
+  // Inline function 'kotlin.Companion.failure' call
+  var exception = _get_receiveException__foorc1($this);
+  var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+  cont.lc(tmp$ret$0);
+}
+function updateCellReceive($this, segment, index, r, waiter) {
+  var state = segment.e2c(index);
+  if (state === null) {
+    // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+    var senders = $this.k2c_1.kotlinx$atomicfu$value.c4(new (Long())(-1, 268435455));
+    if (r.a2(senders) >= 0) {
+      if (waiter === null) {
+        return get_SUSPEND_NO_WAITER();
+      }
+      if (segment.g2c(index, state, waiter)) {
+        expandBuffer($this);
+        return get_SUSPEND();
+      }
+    }
+  } else if (state === get_BUFFERED())
+    if (segment.g2c(index, state, get_DONE_RCV())) {
+      expandBuffer($this);
+      return segment.c2c(index);
+    }
+  return updateCellReceiveSlow($this, segment, index, r, waiter);
+}
+function updateCellReceiveSlow($this, segment, index, r, waiter) {
+  $l$loop: while (true) {
+    var state = segment.e2c(index);
+    if (state === null || state === get_IN_BUFFER()) {
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+      var senders = $this.k2c_1.kotlinx$atomicfu$value.c4(new (Long())(-1, 268435455));
+      if (r.a2(senders) < 0) {
+        if (segment.g2c(index, state, get_POISONED())) {
+          expandBuffer($this);
+          return get_FAILED();
+        }
+      } else {
+        if (waiter === null) {
+          return get_SUSPEND_NO_WAITER();
+        }
+        if (segment.g2c(index, state, waiter)) {
+          expandBuffer($this);
+          return get_SUSPEND();
+        }
+      }
+    } else if (state === get_BUFFERED()) {
+      if (segment.g2c(index, state, get_DONE_RCV())) {
+        expandBuffer($this);
+        return segment.c2c(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.g2c(index, state, get_RESUMING_BY_RCV())) {
+        var helpExpandBuffer = state instanceof WaiterEB();
+        var tmp;
+        if (state instanceof WaiterEB()) {
+          tmp = state.u2e_1;
+        } else {
+          tmp = state;
+        }
+        var sender = tmp;
+        var tmp_0;
+        if (tryResumeSender($this, sender, segment, index)) {
+          segment.f2c(index, get_DONE_RCV());
+          expandBuffer($this);
+          tmp_0 = segment.c2c(index);
+        } else {
+          segment.f2c(index, get_INTERRUPTED_SEND());
+          segment.u2c(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.f2f($this, Unit_instance);
+      if (trySelectResult === TrySelectDetailedResult_REREGISTER_getInstance()) {
+        segment.d2c(index);
+      }
+      tmp = trySelectResult === TrySelectDetailedResult_SUCCESSFUL_getInstance();
+    } else {
+      if (_this__u8e3s4 instanceof SendBroadcast()) {
+        tmp = tryResume0(_this__u8e3s4.b2f_1, true);
+      } else {
+        var message = 'Unexpected waiter: ' + toString_0(_this__u8e3s4);
+        throw IllegalStateException().o4(toString_0(message));
+      }
+    }
+  }
+  return tmp;
+}
+function expandBuffer($this) {
+  if (_get_isRendezvousOrUnlimited__3mdufi($this))
+    return Unit_instance;
+  var segment = $this.q2c_1.kotlinx$atomicfu$value;
+  try_again: while (true) {
+    var b = $this.m2c_1.atomicfu$getAndIncrement$long();
+    // Inline function 'kotlin.Long.div' call
+    var other = get_SEGMENT_SIZE();
+    var id = b.s3(toLong(other));
+    var s = $this.m2d();
+    if (s.a2(b) <= 0) {
+      if (segment.i22_1.a2(id) < 0 && !(segment.c2d() == null)) {
+        moveSegmentBufferEndToSpecifiedOrLast($this, id, segment);
+      }
+      incCompletedExpandBufferAttempts$default($this);
+      return Unit_instance;
+    }
+    if (!segment.i22_1.equals(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 i = b.t3(toLong(other_0)).c2();
+    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.e2c(index);
+  if (!(state == null) ? isInterface(state, Waiter()) : false) {
+    if (b.a2($this.l2c_1.kotlinx$atomicfu$value) >= 0) {
+      if (segment.g2c(index, state, get_RESUMING_BY_EB())) {
+        var tmp;
+        if (tryResumeSender($this, state, segment, index)) {
+          segment.f2c(index, get_BUFFERED());
+          tmp = true;
+        } else {
+          segment.f2c(index, get_INTERRUPTED_SEND());
+          segment.u2c(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.e2c(index);
+    if (!(state == null) ? isInterface(state, Waiter()) : false) {
+      if (b.a2($this.l2c_1.kotlinx$atomicfu$value) < 0) {
+        if (segment.g2c(index, state, new (WaiterEB())(state)))
+          return true;
+      } else {
+        if (segment.g2c(index, state, get_RESUMING_BY_EB())) {
+          var tmp;
+          if (tryResumeSender($this, state, segment, index)) {
+            segment.f2c(index, get_BUFFERED());
+            tmp = true;
+          } else {
+            segment.f2c(index, get_INTERRUPTED_SEND());
+            segment.u2c(index, false);
+            tmp = false;
+          }
+          return tmp;
+        }
+      }
+    } else {
+      if (state === get_INTERRUPTED_SEND())
+        return false;
+      else {
+        if (state === null) {
+          if (segment.g2c(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().o4(toString_0(message));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function incCompletedExpandBufferAttempts($this, nAttempts) {
+  // Inline function 'kotlin.also' call
+  // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+  if (!$this.n2c_1.atomicfu$addAndGet$long(nAttempts).c4(new (Long())(0, 1073741824)).equals(new (Long())(0, 0))) {
+    $l$loop: while (true) {
+      // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+      if (!!$this.n2c_1.kotlinx$atomicfu$value.c4(new (Long())(0, 1073741824)).equals(new (Long())(0, 0))) {
+        break $l$loop;
+      }
+    }
+  }
+}
+function incCompletedExpandBufferAttempts$default($this, nAttempts, $super) {
+  nAttempts = nAttempts === VOID ? new (Long())(1, 0) : nAttempts;
+  return incCompletedExpandBufferAttempts($this, nAttempts);
+}
+var BufferedChannelIteratorClass;
+function BufferedChannelIterator() {
+  if (BufferedChannelIteratorClass === VOID) {
+    class $ {
+      constructor($outer) {
+        this.k2d_1 = $outer;
+        this.i2d_1 = get_NO_RECEIVE_RESULT();
+        this.j2d_1 = null;
+      }
+      g2f($completion) {
+        var tmp = new ($hasNextCOROUTINE$())(this, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      n23(segment, index) {
+        var tmp0_safe_receiver = this.j2d_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          tmp0_safe_receiver.n23(segment, index);
+        }
+      }
+      f1() {
+        var result = this.i2d_1;
+        // Inline function 'kotlin.check' call
+        if (!!(result === get_NO_RECEIVE_RESULT())) {
+          var message = '`hasNext()` has not been invoked';
+          throw IllegalStateException().o4(toString_0(message));
+        }
+        this.i2d_1 = get_NO_RECEIVE_RESULT();
+        if (result === get_CHANNEL_CLOSED())
+          throw recoverStackTrace(_get_receiveException__foorc1(this.k2d_1));
+        return (result == null ? true : !(result == null)) ? result : THROW_CCE();
+      }
+      v2e(element) {
+        var cont = ensureNotNull(this.j2d_1);
+        this.j2d_1 = null;
+        this.i2d_1 = element;
+        var tmp0_safe_receiver = this.k2d_1.j2c_1;
+        return tryResume0(cont, true, tmp0_safe_receiver == null ? null : bindCancellationFun(this.k2d_1, tmp0_safe_receiver, element));
+      }
+      h2f() {
+        var cont = ensureNotNull(this.j2d_1);
+        this.j2d_1 = null;
+        this.i2d_1 = get_CHANNEL_CLOSED();
+        var cause = this.k2d_1.l2d();
+        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.lc(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.lc(tmp$ret$2);
+        }
+      }
+    }
+    initMetadataForClass($, 'BufferedChannelIterator', VOID, VOID, [Waiter()], [0, 3]);
+    BufferedChannelIteratorClass = $;
+  }
+  return BufferedChannelIteratorClass;
+}
+function _get_receiveException__foorc1($this) {
+  var tmp0_elvis_lhs = $this.l2d();
+  return tmp0_elvis_lhs == null ? ClosedReceiveChannelException().m2f('Channel was closed') : tmp0_elvis_lhs;
+}
+function invokeCloseHandler($this) {
+  var tmp0 = $this.t2c_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.l2d());
+}
+function markClosed($this) {
+  var tmp0 = $this.k2c_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 (cur.a4(60).c2()) {
+        case 0:
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+          var tmp$ret$1 = cur.c4(new (Long())(-1, 268435455));
+          tmp = constructSendersAndCloseStatus(tmp$ret$1, 2);
+          break;
+        case 1:
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+          var tmp$ret$2 = cur.c4(new (Long())(-1, 268435455));
+          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.k2c_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.c4(new (Long())(-1, 268435455));
+      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.k2c_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 (cur.a4(60).c2() === 0) {
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        var tmp$ret$1 = cur.c4(new (Long())(-1, 268435455));
+        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.n2f();
+}
+function completeClose($this, sendersCur) {
+  var lastSegment = closeLinkedList($this);
+  if ($this.p2f()) {
+    var lastBufferedCellGlobalIndex = markAllEmptyCellsAsClosed($this, lastSegment);
+    if (!lastBufferedCellGlobalIndex.equals(new (Long())(-1, -1))) {
+      $this.o2f(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.q2c_1.kotlinx$atomicfu$value;
+  // Inline function 'kotlin.let' call
+  var it = $this.o2c_1.kotlinx$atomicfu$value;
+  if (it.i22_1.a2(lastSegment.i22_1) > 0)
+    lastSegment = it;
+  // Inline function 'kotlin.let' call
+  var it_0 = $this.p2c_1.kotlinx$atomicfu$value;
+  if (it_0.i22_1.a2(lastSegment.i22_1) > 0)
+    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.i22_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var globalIndex = tmp0.r3(toLong(other)).p3(toLong(index));
+        if (globalIndex.a2($this.s2e()) < 0)
+          return new (Long())(-1, -1);
+        cell_update: while (true) {
+          var state = segment.e2c(index);
+          if (state === null || state === get_IN_BUFFER()) {
+            if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+              segment.w2c();
+              break cell_update;
+            }
+          } else if (state === get_BUFFERED())
+            return globalIndex;
+          else
+            break cell_update;
+        }
+      }
+       while (0 <= inductionVariable);
+    var tmp0_elvis_lhs = segment.f2d();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return new (Long())(-1, -1);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    segment = tmp;
+  }
+}
+function removeUnprocessedElements($this, lastSegment) {
+  var onUndeliveredElement = $this.j2c_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.i22_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var globalIndex = tmp0.r3(toLong(other)).p3(toLong(index));
+        update_cell: while (true) {
+          var state = segment.e2c(index);
+          if (state === get_DONE_RCV())
+            break process_segments;
+          else {
+            if (state === get_BUFFERED()) {
+              if (globalIndex.a2($this.s2e()) < 0)
+                break process_segments;
+              if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+                if (!(onUndeliveredElement == null)) {
+                  var element = segment.b2c(index);
+                  undeliveredElementException = callUndeliveredElementCatchingException(onUndeliveredElement, element, undeliveredElementException);
+                }
+                segment.d2c(index);
+                segment.w2c();
+                break update_cell;
+              }
+            } else {
+              if (state === get_IN_BUFFER() || state === null) {
+                if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+                  segment.w2c();
+                  break update_cell;
+                }
+              } else {
+                var tmp;
+                if (!(state == null) ? isInterface(state, Waiter()) : false) {
+                  tmp = true;
+                } else {
+                  tmp = state instanceof WaiterEB();
+                }
+                if (tmp) {
+                  if (globalIndex.a2($this.s2e()) < 0)
+                    break process_segments;
+                  var tmp_0;
+                  if (state instanceof WaiterEB()) {
+                    tmp_0 = state.u2e_1;
+                  } else {
+                    tmp_0 = (!(state == null) ? isInterface(state, Waiter()) : false) ? state : THROW_CCE();
+                  }
+                  var sender = tmp_0;
+                  if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+                    if (!(onUndeliveredElement == null)) {
+                      var element_0 = segment.b2c(index);
+                      undeliveredElementException = callUndeliveredElementCatchingException(onUndeliveredElement, element_0, undeliveredElementException);
+                    }
+                    suspendedSenders = InlineList__plus_impl_nuetvo(suspendedSenders, sender);
+                    segment.d2c(index);
+                    segment.w2c();
+                    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.f2d();
+    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.i1() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var i = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            var it_0 = list.j1(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.i22_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        if (tmp0.r3(toLong(other)).p3(toLong(index)).a2(sendersCounter) < 0)
+          break process_segments;
+        cell_update: while (true) {
+          var state = segment.e2c(index);
+          if (state === null || state === get_IN_BUFFER()) {
+            if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+              segment.w2c();
+              break cell_update;
+            }
+          } else {
+            if (state instanceof WaiterEB()) {
+              if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+                suspendedReceivers = InlineList__plus_impl_nuetvo(suspendedReceivers, state.u2e_1);
+                segment.u2c(index, true);
+                break cell_update;
+              }
+            } else {
+              if (!(state == null) ? isInterface(state, Waiter()) : false) {
+                if (segment.g2c(index, state, get_CHANNEL_CLOSED())) {
+                  suspendedReceivers = InlineList__plus_impl_nuetvo(suspendedReceivers, state);
+                  segment.u2c(index, true);
+                  break cell_update;
+                }
+              } else {
+                break cell_update;
+              }
+            }
+          }
+        }
+      }
+       while (0 <= inductionVariable);
+    segment = segment.f2d();
+  }
+  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.i1() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var i = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            var it_0 = list.j1(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.b2f_1;
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(false);
+    this_0.lc(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.r2e();
+      var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(exception));
+      _this__u8e3s4.lc(tmp$ret$2);
+    } else {
+      if (_this__u8e3s4 instanceof ReceiveCatching()) {
+        var tmp0 = _this__u8e3s4.y2e_1;
+        // Inline function 'kotlin.coroutines.resume' call
+        // Inline function 'kotlin.Companion.success' call
+        var value = new (ChannelResult())(Companion_getInstance().q2f($this.l2d()));
+        var tmp$ret$4 = _Result___init__impl__xyqfz8(value);
+        tmp0.lc(tmp$ret$4);
+      } else {
+        if (_this__u8e3s4 instanceof BufferedChannelIterator()) {
+          _this__u8e3s4.h2f();
+        } else {
+          if (isInterface(_this__u8e3s4, SelectInstance()))
+            _this__u8e3s4.z2e($this, get_CHANNEL_CLOSED());
+          else {
+            // Inline function 'kotlin.error' call
+            var message = 'Unexpected waiter: ' + toString_0(_this__u8e3s4);
+            throw IllegalStateException().o4(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 (sendersAndCloseStatusCur.a4(60).c2()) {
+    case 0:
+      tmp = false;
+      break;
+    case 1:
+      tmp = false;
+      break;
+    case 2:
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+      var tmp$ret$1 = sendersAndCloseStatusCur.c4(new (Long())(-1, 268435455));
+      completeClose($this, tmp$ret$1);
+      tmp = isClosedForReceive ? !$this.r2f() : true;
+      break;
+    case 3:
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+      var tmp$ret$2 = sendersAndCloseStatusCur.c4(new (Long())(-1, 268435455));
+      completeCancel($this, tmp$ret$2);
+      tmp = true;
+      break;
+    default:
+      // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+
+      var message = 'unexpected close status: ' + sendersAndCloseStatusCur.a4(60).c2();
+      throw IllegalStateException().o4(toString_0(message));
+  }
+  return tmp;
+}
+function isCellNonEmpty($this, segment, index, globalIndex) {
+  while (true) {
+    var state = segment.e2c(index);
+    if (state === null || state === get_IN_BUFFER()) {
+      if (segment.g2c(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.equals($this.s2e());
+  }
+}
+function findSegmentSend($this, id, startFrom) {
+  var tmp0 = $this.o2c_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.i22_1.a2(tmp2.i22_1) >= 0) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.y2c()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.z2c()) {
+                cur.z5();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.z2c()) {
+              tmp2.z5();
+            }
+          }
+          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.i22_1;
+    // Inline function 'kotlin.Long.times' call
+    var other = get_SEGMENT_SIZE();
+    if (tmp0_0.r3(toLong(other)).a2($this.s2e()) < 0) {
+      startFrom.g2d();
+    }
+    tmp_0 = null;
+  } else {
+    var segment = _SegmentOrClosed___get_segment__impl__jvcr9l(it);
+    var tmp_1;
+    if (segment.i22_1.a2(id) > 0) {
+      var tmp0_1 = segment.i22_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_0 = get_SEGMENT_SIZE();
+      var tmp$ret$4 = tmp0_1.r3(toLong(other_0));
+      updateSendersCounterIfLower($this, tmp$ret$4);
+      var tmp0_2 = segment.i22_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_1 = get_SEGMENT_SIZE();
+      if (tmp0_2.r3(toLong(other_1)).a2($this.s2e()) < 0) {
+        segment.g2d();
+      }
+      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.p2c_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.i22_1.a2(tmp2.i22_1) >= 0) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.y2c()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.z2c()) {
+                cur.z5();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.z2c()) {
+              tmp2.z5();
+            }
+          }
+          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.i22_1;
+    // Inline function 'kotlin.Long.times' call
+    var other = get_SEGMENT_SIZE();
+    if (tmp0_0.r3(toLong(other)).a2($this.m2d()) < 0) {
+      startFrom.g2d();
+    }
+    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();
+      var tmp$ret$4 = tmp0_1.s3(toLong(other_0));
+      tmp_1 = id.a2(tmp$ret$4) <= 0;
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      var tmp0_2 = $this.q2c_1;
+      $l$block_5: {
+        // Inline function 'kotlinx.coroutines.internal.moveForward' call
+        while (true) {
+          var cur_0 = tmp0_2.kotlinx$atomicfu$value;
+          if (cur_0.i22_1.a2(segment.i22_1) >= 0) {
+            break $l$block_5;
+          }
+          if (!segment.y2c()) {
+            break $l$block_5;
+          }
+          if (tmp0_2.atomicfu$compareAndSet(cur_0, segment)) {
+            if (cur_0.z2c()) {
+              cur_0.z5();
+            }
+            break $l$block_5;
+          }
+          if (segment.z2c()) {
+            segment.z5();
+          }
+        }
+      }
+    }
+    var tmp_2;
+    if (segment.i22_1.a2(id) > 0) {
+      var tmp0_3 = segment.i22_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_1 = get_SEGMENT_SIZE();
+      var tmp$ret$7 = tmp0_3.r3(toLong(other_1));
+      updateReceiversCounterIfLower($this, tmp$ret$7);
+      var tmp0_4 = segment.i22_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_2 = get_SEGMENT_SIZE();
+      if (tmp0_4.r3(toLong(other_2)).a2($this.m2d()) < 0) {
+        segment.g2d();
+      }
+      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.q2c_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.i22_1.a2(tmp2.i22_1) >= 0) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.y2c()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.z2c()) {
+                cur.z5();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.z2c()) {
+              tmp2.z5();
+            }
+          }
+          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.i22_1.a2(id) > 0) {
+      // Inline function 'kotlin.Long.plus' call
+      var tmp_2 = currentBufferEndCounter.p3(toLong(1));
+      var tmp0_0 = segment.i22_1;
+      // Inline function 'kotlin.Long.times' call
+      var other = get_SEGMENT_SIZE();
+      var tmp$ret$4 = tmp0_0.r3(toLong(other));
+      if ($this.m2c_1.atomicfu$compareAndSet(tmp_2, tmp$ret$4)) {
+        var tmp0_1 = segment.i22_1;
+        // Inline function 'kotlin.Long.times' call
+        var other_0 = get_SEGMENT_SIZE();
+        var tmp$ret$5 = tmp0_1.r3(toLong(other_0));
+        incCompletedExpandBufferAttempts($this, tmp$ret$5.q3(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.i22_1.a2(id) < 0) {
+    var tmp0_elvis_lhs = segment.c2d();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      break $l$loop;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    segment = tmp;
+  }
+  while (true) {
+    $l$loop_0: while (segment.x2c()) {
+      var tmp1_elvis_lhs = segment.c2d();
+      var tmp_0;
+      if (tmp1_elvis_lhs == null) {
+        break $l$loop_0;
+      } else {
+        tmp_0 = tmp1_elvis_lhs;
+      }
+      segment = tmp_0;
+    }
+    var tmp0 = $this.q2c_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.i22_1.a2(tmp2.i22_1) >= 0) {
+          tmp$ret$0 = true;
+          break $l$block_1;
+        }
+        if (!tmp2.y2c()) {
+          tmp$ret$0 = false;
+          break $l$block_1;
+        }
+        if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+          if (cur.z2c()) {
+            cur.z5();
+          }
+          tmp$ret$0 = true;
+          break $l$block_1;
+        }
+        if (tmp2.z2c()) {
+          tmp2.z5();
+        }
+      }
+      tmp$ret$0 = Unit_instance;
+    }
+    if (tmp$ret$0)
+      return Unit_instance;
+  }
+}
+function updateSendersCounterIfLower($this, value) {
+  var this_0 = $this.k2c_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+    var curCounter = cur.c4(new (Long())(-1, 268435455));
+    if (curCounter.a2(value) >= 0)
+      return Unit_instance;
+    // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+    var tmp$ret$1 = cur.a4(60).c2();
+    var update = constructSendersAndCloseStatus(curCounter, tmp$ret$1);
+    if ($this.k2c_1.atomicfu$compareAndSet(cur, update))
+      return Unit_instance;
+  }
+  return Unit_instance;
+}
+function updateReceiversCounterIfLower($this, value) {
+  var this_0 = $this.l2c_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    if (cur.a2(value) >= 0)
+      return Unit_instance;
+    if ($this.l2c_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.j2c_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.j2c_1), element, context);
+}
+function BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda$lambda($element, this$0, $select) {
+  return function (_unused_var__etf5q3, _unused_var__etf5q3_0, _unused_var__etf5q3_1) {
+    var tmp;
+    if (!($element === get_CHANNEL_CLOSED())) {
+      callUndeliveredElement(this$0.j2c_1, ($element == null ? true : !($element == null)) ? $element : THROW_CCE(), $select.gc());
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda(this$0) {
+  return function (select, _unused_var__etf5q3, element) {
+    return BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda$lambda(element, this$0, select);
+  };
+}
+function BufferedChannel$onCancellationChannelResultImplDoNotCall$ref(p0) {
+  var l = function (_this__u8e3s4, p0_0, p1) {
+    var tmp0 = p0;
+    onCancellationChannelResultImplDoNotCall(tmp0, _this__u8e3s4, p0_0.t2f_1, p1);
+    return Unit_instance;
+  };
+  l.callableName = 'onCancellationChannelResultImplDoNotCall';
+  return l;
+}
+function BufferedChannel$bindCancellationFun$lambda($this_bindCancellationFun, $element) {
+  return function (_unused_var__etf5q3, _unused_var__etf5q3_0, context) {
+    callUndeliveredElement($this_bindCancellationFun, $element, context);
+    return Unit_instance;
+  };
+}
+function BufferedChannel$onCancellationImplDoNotCall$ref(p0) {
+  var l = function (_this__u8e3s4, p0_0, p1) {
+    var tmp0 = p0;
+    onCancellationImplDoNotCall(tmp0, _this__u8e3s4, p0_0, p1);
+    return Unit_instance;
+  };
+  l.callableName = 'onCancellationImplDoNotCall';
+  return l;
+}
+var $sendCOROUTINE$Class;
+function $sendCOROUTINE$() {
+  if ($sendCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, element, resultContinuation) {
+        super(resultContinuation);
+        this.c2g_1 = _this__u8e3s4;
+        this.d2g_1 = element;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 11;
+                var tmp_0 = this;
+                tmp_0.e2g_1 = this.c2g_1;
+                var tmp_1 = this;
+                tmp_1.f2g_1 = this.d2g_1;
+                var tmp_2 = this;
+                tmp_2.g2g_1 = null;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.i2g_1 = this.e2g_1;
+                this.j2g_1 = this.f2g_1;
+                this.k2g_1 = this.g2g_1;
+                this.l2g_1 = this.i2g_1.o2c_1.kotlinx$atomicfu$value;
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (!true) {
+                  this.ac_1 = 12;
+                  continue $sm;
+                }
+
+                this.m2g_1 = this.i2g_1.k2c_1.atomicfu$getAndIncrement$long();
+                var tmp_3 = this;
+                tmp_3.n2g_1 = this.m2g_1.c4(new (Long())(-1, 268435455));
+                this.o2g_1 = _get_isClosedForSend0__kxgf9m(this.i2g_1, this.m2g_1);
+                var tmp_4 = this;
+                var tmp0 = this.n2g_1;
+                var other = get_SEGMENT_SIZE();
+                tmp_4.p2g_1 = tmp0.s3(toLong(other));
+                var tmp_5 = this;
+                var tmp0_0 = this.n2g_1;
+                var other_0 = get_SEGMENT_SIZE();
+                tmp_5.q2g_1 = tmp0_0.t3(toLong(other_0)).c2();
+                if (!this.l2g_1.i22_1.equals(this.p2g_1)) {
+                  this.r2g_1 = findSegmentSend(this.i2g_1, this.p2g_1, this.l2g_1);
+                  if (this.r2g_1 == null) {
+                    if (this.o2g_1) {
+                      this.ac_1 = 10;
+                      suspendResult = onClosedSend(this.c2g_1, this.d2g_1, this);
+                      if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                        return suspendResult;
+                      }
+                      continue $sm;
+                    } else {
+                      this.ac_1 = 2;
+                      continue $sm;
+                    }
+                  } else {
+                    this.s2g_1 = this.r2g_1;
+                    this.ac_1 = 3;
+                    continue $sm;
+                  }
+                } else {
+                  this.ac_1 = 4;
+                  continue $sm;
+                }
+
+              case 3:
+                this.l2g_1 = this.s2g_1;
+                this.ac_1 = 4;
+                continue $sm;
+              case 4:
+                this.t2g_1 = updateCellSend(this.i2g_1, this.l2g_1, this.q2g_1, this.j2g_1, this.n2g_1, this.k2g_1, this.o2g_1);
+                if (this.t2g_1 === 0) {
+                  this.l2g_1.g2d();
+                  var tmp_6 = this;
+                  tmp_6.h2g_1 = Unit_instance;
+                  this.ac_1 = 13;
+                  continue $sm;
+                } else {
+                  if (this.t2g_1 === 1) {
+                    var tmp_7 = this;
+                    tmp_7.h2g_1 = Unit_instance;
+                    this.ac_1 = 13;
+                    continue $sm;
+                  } else {
+                    if (this.t2g_1 === 2) {
+                      if (this.o2g_1) {
+                        this.l2g_1.w2c();
+                        this.ac_1 = 9;
+                        suspendResult = onClosedSend(this.c2g_1, this.d2g_1, this);
+                        if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                          return suspendResult;
+                        }
+                        continue $sm;
+                      } else {
+                        this.ac_1 = 8;
+                        continue $sm;
+                      }
+                    } else {
+                      if (this.t2g_1 === 4) {
+                        if (this.n2g_1.a2(this.i2g_1.s2e()) < 0) {
+                          this.l2g_1.g2d();
+                        }
+                        this.ac_1 = 7;
+                        suspendResult = onClosedSend(this.c2g_1, this.d2g_1, this);
+                        if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                          return suspendResult;
+                        }
+                        continue $sm;
+                      } else {
+                        if (this.t2g_1 === 5) {
+                          this.l2g_1.g2d();
+                          this.ac_1 = 2;
+                          continue $sm;
+                        } else {
+                          if (this.t2g_1 === 3) {
+                            var tmp_8 = this;
+                            tmp_8.u2g_1 = this.l2g_1;
+                            var tmp_9 = this;
+                            tmp_9.v2g_1 = this.q2g_1;
+                            var tmp_10 = this;
+                            tmp_10.w2g_1 = this.j2g_1;
+                            var tmp_11 = this;
+                            tmp_11.x2g_1 = this.n2g_1;
+                            this.y2g_1 = this.u2g_1;
+                            this.z2g_1 = this.v2g_1;
+                            this.a2h_1 = this.w2g_1;
+                            this.b2h_1 = this.x2g_1;
+                            this.ac_1 = 6;
+                            suspendResult = sendOnNoWaiterSuspend(this.c2g_1, this.y2g_1, this.z2g_1, this.a2h_1, this.b2h_1, this);
+                            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                              return suspendResult;
+                            }
+                            continue $sm;
+                          } else {
+                            this.ac_1 = 5;
+                            continue $sm;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+
+              case 5:
+                this.ac_1 = 2;
+                continue $sm;
+              case 6:
+                var tmp_12 = this;
+                tmp_12.h2g_1 = Unit_instance;
+                this.ac_1 = 13;
+                continue $sm;
+              case 7:
+                var tmp_13 = this;
+                tmp_13.h2g_1 = Unit_instance;
+                this.ac_1 = 13;
+                continue $sm;
+              case 8:
+                var tmp_14 = this.k2g_1;
+                var tmp2_safe_receiver = (!(tmp_14 == null) ? isInterface(tmp_14, Waiter()) : false) ? tmp_14 : null;
+                if (tmp2_safe_receiver == null)
+                  null;
+                else {
+                  prepareSenderForSuspension(this.i2g_1, tmp2_safe_receiver, this.l2g_1, this.q2g_1);
+                }
+
+                var tmp_15 = this;
+                this.l2g_1;
+                this.q2g_1;
+                tmp_15.h2g_1 = Unit_instance;
+                this.ac_1 = 13;
+                continue $sm;
+              case 9:
+                var tmp_16 = this;
+                tmp_16.h2g_1 = Unit_instance;
+                this.ac_1 = 13;
+                continue $sm;
+              case 10:
+                var tmp_17 = this;
+                tmp_17.h2g_1 = Unit_instance;
+                this.ac_1 = 13;
+                continue $sm;
+              case 11:
+                throw this.dc_1;
+              case 12:
+                if (false) {
+                  this.ac_1 = 1;
+                  continue $sm;
+                }
+
+                this.ac_1 = 13;
+                continue $sm;
+              case 13:
+                return Unit_instance;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 11) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $sendCOROUTINE$Class = $;
+  }
+  return $sendCOROUTINE$Class;
+}
+var $receiveCOROUTINE$Class;
+function $receiveCOROUTINE$() {
+  if ($receiveCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.k2h_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 8;
+                var tmp_0 = this;
+                tmp_0.l2h_1 = this.k2h_1;
+                var tmp_1 = this;
+                tmp_1.m2h_1 = null;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.o2h_1 = this.l2h_1;
+                this.p2h_1 = this.m2h_1;
+                this.q2h_1 = this.o2h_1.p2c_1.kotlinx$atomicfu$value;
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (!true) {
+                  this.ac_1 = 9;
+                  continue $sm;
+                }
+
+                if (this.o2h_1.n2d()) {
+                  var tmp_2 = this;
+                  throw recoverStackTrace(_get_receiveException__foorc1(this.k2h_1));
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 3:
+                this.r2h_1 = this.o2h_1.l2c_1.atomicfu$getAndIncrement$long();
+                var tmp_3 = this;
+                var tmp0 = this.r2h_1;
+                var other = get_SEGMENT_SIZE();
+                tmp_3.s2h_1 = tmp0.s3(toLong(other));
+                var tmp_4 = this;
+                var tmp0_0 = this.r2h_1;
+                var other_0 = get_SEGMENT_SIZE();
+                tmp_4.t2h_1 = tmp0_0.t3(toLong(other_0)).c2();
+                if (!this.q2h_1.i22_1.equals(this.s2h_1)) {
+                  this.u2h_1 = findSegmentReceive(this.o2h_1, this.s2h_1, this.q2h_1);
+                  if (this.u2h_1 == null) {
+                    this.ac_1 = 2;
+                    var tmp_5 = this;
+                    continue $sm;
+                  } else {
+                    this.v2h_1 = this.u2h_1;
+                    this.ac_1 = 4;
+                    continue $sm;
+                  }
+                } else {
+                  this.ac_1 = 5;
+                  continue $sm;
+                }
+
+              case 4:
+                this.q2h_1 = this.v2h_1;
+                this.ac_1 = 5;
+                continue $sm;
+              case 5:
+                this.w2h_1 = updateCellReceive(this.o2h_1, this.q2h_1, this.t2h_1, this.r2h_1, this.p2h_1);
+                if (this.w2h_1 === get_SUSPEND()) {
+                  var tmp_6 = this;
+                  var tmp_7 = this.p2h_1;
+                  var tmp1_safe_receiver = (!(tmp_7 == null) ? isInterface(tmp_7, Waiter()) : false) ? tmp_7 : null;
+                  if (tmp1_safe_receiver == null)
+                    null;
+                  else {
+                    prepareReceiverForSuspension(this.o2h_1, tmp1_safe_receiver, this.q2h_1, this.t2h_1);
+                  }
+                  this.q2h_1;
+                  this.t2h_1;
+                  this.r2h_1;
+                  var message = 'unexpected';
+                  throw IllegalStateException().o4(toString_0(message));
+                } else {
+                  if (this.w2h_1 === get_FAILED()) {
+                    if (this.r2h_1.a2(this.o2h_1.m2d()) < 0) {
+                      this.q2h_1.g2d();
+                    }
+                    this.ac_1 = 2;
+                    var tmp_8 = this;
+                    continue $sm;
+                  } else {
+                    if (this.w2h_1 === get_SUSPEND_NO_WAITER()) {
+                      var tmp_9 = this;
+                      tmp_9.y2h_1 = this.q2h_1;
+                      var tmp_10 = this;
+                      tmp_10.z2h_1 = this.t2h_1;
+                      var tmp_11 = this;
+                      tmp_11.a2i_1 = this.r2h_1;
+                      this.b2i_1 = this.y2h_1;
+                      this.c2i_1 = this.z2h_1;
+                      this.d2i_1 = this.a2i_1;
+                      this.ac_1 = 6;
+                      suspendResult = receiveOnNoWaiterSuspend(this.k2h_1, this.b2i_1, this.c2i_1, this.d2i_1, this);
+                      if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                        return suspendResult;
+                      }
+                      continue $sm;
+                    } else {
+                      var tmp_12 = this;
+                      this.q2h_1.g2d();
+                      var tmp_13 = this.w2h_1;
+                      return (tmp_13 == null ? true : !(tmp_13 == null)) ? tmp_13 : THROW_CCE();
+                    }
+                  }
+                }
+
+              case 6:
+                this.x2h_1 = suspendResult;
+                this.ac_1 = 7;
+                continue $sm;
+              case 7:
+                this.n2h_1 = this.x2h_1;
+                this.ac_1 = 10;
+                continue $sm;
+              case 8:
+                throw this.dc_1;
+              case 9:
+                if (false) {
+                  this.ac_1 = 1;
+                  continue $sm;
+                }
+
+                this.ac_1 = 10;
+                continue $sm;
+              case 10:
+                return this.n2h_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 8) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $receiveCOROUTINE$Class = $;
+  }
+  return $receiveCOROUTINE$Class;
+}
+var BufferedChannelClass;
+function BufferedChannel() {
+  if (BufferedChannelClass === VOID) {
+    class $ {
+      constructor(capacity, onUndeliveredElement) {
+        onUndeliveredElement = onUndeliveredElement === VOID ? null : onUndeliveredElement;
+        this.i2c_1 = capacity;
+        this.j2c_1 = onUndeliveredElement;
+        // Inline function 'kotlin.require' call
+        if (!(this.i2c_1 >= 0)) {
+          var message = 'Invalid channel capacity: ' + this.i2c_1 + ', should be >=0';
+          throw IllegalArgumentException().u(toString_0(message));
+        }
+        this.k2c_1 = atomic$long$1(new (Long())(0, 0));
+        this.l2c_1 = atomic$long$1(new (Long())(0, 0));
+        this.m2c_1 = atomic$long$1(initialBufferEnd(this.i2c_1));
+        this.n2c_1 = atomic$long$1(_get_bufferEndCounter__2d4hee(this));
+        var firstSegment = new (ChannelSegment())(new (Long())(0, 0), null, this, 3);
+        this.o2c_1 = atomic$ref$1(firstSegment);
+        this.p2c_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.q2c_1 = atomic$ref$1(tmp_0);
+        var tmp_2 = this;
+        var tmp_3;
+        if (this.j2c_1 == null) {
+          tmp_3 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_3 = BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda(this);
+        }
+        tmp_2.r2c_1 = tmp_3;
+        this.s2c_1 = atomic$ref$1(get_NO_CLOSE_CAUSE());
+        this.t2c_1 = atomic$ref$1(null);
+      }
+      m2d() {
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        return this.k2c_1.kotlinx$atomicfu$value.c4(new (Long())(-1, 268435455));
+      }
+      s2e() {
+        return this.l2c_1.kotlinx$atomicfu$value;
+      }
+      e2i(element, $completion) {
+        var tmp = new ($sendCOROUTINE$())(this, element, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      f2i(element) {
+        if (shouldSendSuspend0(this, this.k2c_1.kotlinx$atomicfu$value))
+          return Companion_getInstance().g2i();
+        var tmp4 = get_INTERRUPTED_SEND();
+        var tmp$ret$4;
+        $l$block_4: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+          var segment = this.o2c_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            var sendersAndCloseStatusCur = this.k2c_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+            var s = sendersAndCloseStatusCur.c4(new (Long())(-1, 268435455));
+            var closed = _get_isClosedForSend0__kxgf9m(this, sendersAndCloseStatusCur);
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = s.s3(toLong(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var i = s.t3(toLong(other_0)).c2();
+            if (!segment.i22_1.equals(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().q2f(this.r2e());
+                  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.g2d();
+                tmp$ret$4 = Companion_getInstance().x2e(Unit_instance);
+                break $l$block_4;
+              case 1:
+                tmp$ret$4 = Companion_getInstance().x2e(Unit_instance);
+                break $l$block_4;
+              case 2:
+                if (closed) {
+                  segment.w2c();
+                  tmp$ret$4 = Companion_getInstance().q2f(this.r2e());
+                  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.w2c();
+                tmp$ret$4 = Companion_getInstance().g2i();
+                break $l$block_4;
+              case 4:
+                if (s.a2(this.s2e()) < 0) {
+                  segment.g2d();
+                }
+
+                tmp$ret$4 = Companion_getInstance().q2f(this.r2e());
+                break $l$block_4;
+              case 5:
+                segment.g2d();
+                continue $l$loop_0;
+              case 3:
+                var message = 'unexpected';
+                throw IllegalStateException().o4(toString_0(message));
+            }
+          }
+        }
+        return tmp$ret$4;
+      }
+      h2i(element) {
+        var tmp$ret$3;
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+        var waiter = get_BUFFERED();
+        var segment = this.o2c_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          var sendersAndCloseStatusCur = this.k2c_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+          var s = sendersAndCloseStatusCur.c4(new (Long())(-1, 268435455));
+          var closed = _get_isClosedForSend0__kxgf9m(this, sendersAndCloseStatusCur);
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = s.s3(toLong(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var i = s.t3(toLong(other_0)).c2();
+          if (!segment.i22_1.equals(id)) {
+            var tmp0_elvis_lhs = findSegmentSend(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var tmp_0;
+              if (closed) {
+                return Companion_getInstance().q2f(this.r2e());
+              } else {
+                continue $l$loop_0;
+              }
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          switch (updateCellSend(this, segment, i, element, s, waiter, closed)) {
+            case 0:
+              segment.g2d();
+              return Companion_getInstance().x2e(Unit_instance);
+            case 1:
+              return Companion_getInstance().x2e(Unit_instance);
+            case 2:
+              if (closed) {
+                segment.w2c();
+                return Companion_getInstance().q2f(this.r2e());
+              }
+
+              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.i22_1;
+              // Inline function 'kotlin.Long.times' call
+
+              var other_1 = get_SEGMENT_SIZE();
+              // Inline function 'kotlin.Long.plus' call
+
+              var tmp$ret$5 = tmp0.r3(toLong(other_1)).p3(toLong(i));
+              this.o2f(tmp$ret$5);
+              return Companion_getInstance().x2e(Unit_instance);
+            case 4:
+              if (s.a2(this.s2e()) < 0) {
+                segment.g2d();
+              }
+
+              return Companion_getInstance().q2f(this.r2e());
+            case 5:
+              segment.g2d();
+              continue $l$loop_0;
+            case 3:
+              var message = 'unexpected';
+              throw IllegalStateException().o4(toString_0(message));
+          }
+        }
+        return tmp$ret$3;
+      }
+      a2f() {
+      }
+      t2e() {
+      }
+      i2i($completion) {
+        var tmp = new ($receiveCOROUTINE$())(this, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      j2i() {
+        var r = this.l2c_1.kotlinx$atomicfu$value;
+        var sendersAndCloseStatusCur = this.k2c_1.kotlinx$atomicfu$value;
+        if (_get_isClosedForReceive0__f7qknl(this, sendersAndCloseStatusCur)) {
+          return Companion_getInstance().q2f(this.l2d());
+        }
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        var s = sendersAndCloseStatusCur.c4(new (Long())(-1, 268435455));
+        if (r.a2(s) >= 0)
+          return Companion_getInstance().g2i();
+        var tmp2 = get_INTERRUPTED_RCV();
+        var tmp$ret$2;
+        $l$block_0: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+          var segment = this.p2c_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            if (this.n2d()) {
+              tmp$ret$2 = Companion_getInstance().q2f(this.l2d());
+              break $l$block_0;
+            }
+            var r_0 = this.l2c_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = r_0.s3(toLong(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var i = r_0.t3(toLong(other_0)).c2();
+            if (!segment.i22_1.equals(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_0, tmp2);
+            var tmp_0;
+            if (updCellResult === get_SUSPEND()) {
+              var tmp1_safe_receiver = (!(tmp2 == null) ? isInterface(tmp2, Waiter()) : false) ? tmp2 : null;
+              if (tmp1_safe_receiver == null)
+                null;
+              else {
+                prepareReceiverForSuspension(this, tmp1_safe_receiver, segment, i);
+              }
+              var segm = segment;
+              this.v2c(r_0);
+              segm.w2c();
+              tmp_0 = new (ChannelResult())(Companion_getInstance().g2i());
+            } else if (updCellResult === get_FAILED()) {
+              if (r_0.a2(this.m2d()) < 0) {
+                segment.g2d();
+              }
+              continue $l$loop_0;
+            } else if (updCellResult === get_SUSPEND_NO_WAITER()) {
+              var message = 'unexpected';
+              throw IllegalStateException().o4(toString_0(message));
+            } else {
+              segment.g2d();
+              var element = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+              tmp_0 = new (ChannelResult())(Companion_getInstance().x2e(element));
+            }
+            tmp$ret$2 = tmp_0.t2f_1;
+            break $l$block_0;
+          }
+        }
+        return tmp$ret$2;
+      }
+      o2f(globalCellIndex) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        var segment = this.p2c_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          var r = this.l2c_1.kotlinx$atomicfu$value;
+          // Inline function 'kotlin.Long.plus' call
+          var other = this.i2c_1;
+          var tmp0 = r.p3(toLong(other));
+          // Inline function 'kotlin.math.max' call
+          var b = _get_bufferEndCounter__2d4hee(this);
+          var tmp$ret$2 = tmp0.a2(b) >= 0 ? tmp0 : b;
+          if (globalCellIndex.a2(tmp$ret$2) < 0)
+            return Unit_instance;
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$3 = r.p3(toLong(1));
+          if (!this.l2c_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 = r.s3(toLong(other_0));
+          // Inline function 'kotlin.Long.rem' call
+          var other_1 = get_SEGMENT_SIZE();
+          var i = r.t3(toLong(other_1)).c2();
+          if (!segment.i22_1.equals(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.a2(this.m2d()) < 0) {
+              segment.g2d();
+            }
+          } else {
+            segment.g2d();
+            var tmp1_safe_receiver = this.j2c_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;
+            }
+          }
+        }
+      }
+      v2c(globalIndex) {
+        if (_get_isRendezvousOrUnlimited__3mdufi(this))
+          return Unit_instance;
+        while (_get_bufferEndCounter__2d4hee(this).a2(globalIndex) <= 0) {
+        }
+        // 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.n2c_1.kotlinx$atomicfu$value.c4(new (Long())(-1, 1073741823));
+            if (b.equals(ebCompleted) && b.equals(_get_bufferEndCounter__2d4hee(this)))
+              return Unit_instance;
+          }
+           while (inductionVariable < times);
+        var tmp0 = this.n2c_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.c4(new (Long())(-1, 1073741823));
+            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.n2c_1.kotlinx$atomicfu$value;
+          // Inline function 'kotlinx.coroutines.channels.ebCompletedCounter' call
+          var ebCompleted_0 = ebCompletedAndBit.c4(new (Long())(-1, 1073741823));
+          // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+          var pauseExpandBuffers = !ebCompletedAndBit.c4(new (Long())(0, 1073741824)).equals(new (Long())(0, 0));
+          if (b_0.equals(ebCompleted_0) && b_0.equals(_get_bufferEndCounter__2d4hee(this))) {
+            var tmp0_0 = this.n2c_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.c4(new (Long())(-1, 1073741823));
+                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.n2c_1.atomicfu$compareAndSet(ebCompletedAndBit, constructEBCompletedAndPauseFlag(ebCompleted_0, true));
+          }
+        }
+      }
+      d1() {
+        return new (BufferedChannelIterator())(this);
+      }
+      l2d() {
+        var tmp = this.s2c_1.kotlinx$atomicfu$value;
+        return (tmp == null ? true : tmp instanceof Error) ? tmp : THROW_CCE();
+      }
+      r2e() {
+        var tmp0_elvis_lhs = this.l2d();
+        return tmp0_elvis_lhs == null ? ClosedSendChannelException().o2i('Channel was closed') : tmp0_elvis_lhs;
+      }
+      p2i() {
+      }
+      q2i(cause) {
+        return this.r2i(cause, false);
+      }
+      c1z(cause) {
+        this.t2i(cause);
+      }
+      t2i(cause) {
+        return this.r2i(cause == null ? CancellationException().cd('Channel was cancelled') : cause, true);
+      }
+      r2i(cause, cancel) {
+        if (cancel) {
+          markCancellationStarted(this);
+        }
+        var closedByThisOperation = this.s2c_1.atomicfu$compareAndSet(get_NO_CLOSE_CAUSE(), cause);
+        if (cancel) {
+          markCancelled(this);
+        } else {
+          markClosed(this);
+        }
+        completeCloseOrCancel(this);
+        // Inline function 'kotlin.also' call
+        this.p2i();
+        if (closedByThisOperation) {
+          invokeCloseHandler(this);
+        }
+        return closedByThisOperation;
+      }
+      p2f() {
+        return false;
+      }
+      n2f() {
+        return _get_isClosedForSend0__kxgf9m(this, this.k2c_1.kotlinx$atomicfu$value);
+      }
+      n2d() {
+        return _get_isClosedForReceive0__f7qknl(this, this.k2c_1.kotlinx$atomicfu$value);
+      }
+      r2f() {
+        $l$loop: while (true) {
+          var segment = this.p2c_1.kotlinx$atomicfu$value;
+          var r = this.s2e();
+          var s = this.m2d();
+          if (s.a2(r) <= 0)
+            return false;
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = r.s3(toLong(other));
+          if (!segment.i22_1.equals(id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var tmp_0;
+              if (this.p2c_1.kotlinx$atomicfu$value.i22_1.a2(id) < 0) {
+                return false;
+              } else {
+                continue $l$loop;
+              }
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          segment.g2d();
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var i = r.t3(toLong(other_0)).c2();
+          if (isCellNonEmpty(this, segment, i, r))
+            return true;
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$2 = r.p3(toLong(1));
+          this.l2c_1.atomicfu$compareAndSet(r, tmp$ret$2);
+        }
+      }
+      toString() {
+        var sb = StringBuilder().a1();
+        // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+        var tmp0_subject = this.k2c_1.kotlinx$atomicfu$value.a4(60).c2();
+        if (tmp0_subject === 2) {
+          sb.jb('closed,');
+        } else if (tmp0_subject === 3) {
+          sb.jb('cancelled,');
+        }
+        sb.jb('capacity=' + this.i2c_1 + ',');
+        sb.jb('data=[');
+        // Inline function 'kotlin.collections.filter' call
+        var tmp0 = listOf([this.p2c_1.kotlinx$atomicfu$value, this.o2c_1.kotlinx$atomicfu$value, this.q2c_1.kotlinx$atomicfu$value]);
+        // Inline function 'kotlin.collections.filterTo' call
+        var destination = ArrayList().l1();
+        var _iterator__ex2g4s = tmp0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var element = _iterator__ex2g4s.f1();
+          if (!(element === get_NULL_SEGMENT())) {
+            destination.m(element);
+          }
+        }
+        var tmp$ret$4;
+        $l$block: {
+          // Inline function 'kotlin.collections.minBy' call
+          var iterator = destination.d1();
+          if (!iterator.e1())
+            throw NoSuchElementException().d6();
+          var minElem = iterator.f1();
+          if (!iterator.e1()) {
+            tmp$ret$4 = minElem;
+            break $l$block;
+          }
+          var minValue = minElem.i22_1;
+          do {
+            var e = iterator.f1();
+            var v = e.i22_1;
+            if (compareTo(minValue, v) > 0) {
+              minElem = e;
+              minValue = v;
+            }
+          }
+           while (iterator.e1());
+          tmp$ret$4 = minElem;
+        }
+        var firstSegment = tmp$ret$4;
+        var r = this.s2e();
+        var s = this.m2d();
+        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.i22_1;
+              // Inline function 'kotlin.Long.times' call
+              var other = get_SEGMENT_SIZE();
+              // Inline function 'kotlin.Long.plus' call
+              var globalCellIndex = tmp0_0.r3(toLong(other)).p3(toLong(i));
+              if (globalCellIndex.a2(s) >= 0 && globalCellIndex.a2(r) >= 0)
+                break append_elements;
+              var cellState = segment.e2c(i);
+              var element_0 = segment.b2c(i);
+              var tmp;
+              if (!(cellState == null) ? isInterface(cellState, CancellableContinuation()) : false) {
+                tmp = globalCellIndex.a2(r) < 0 && globalCellIndex.a2(s) >= 0 ? 'receive' : globalCellIndex.a2(s) < 0 && globalCellIndex.a2(r) >= 0 ? 'send' : 'cont';
+              } else {
+                if (!(cellState == null) ? isInterface(cellState, SelectInstance()) : false) {
+                  tmp = globalCellIndex.a2(r) < 0 && globalCellIndex.a2(s) >= 0 ? 'onReceive' : globalCellIndex.a2(s) < 0 && globalCellIndex.a2(r) >= 0 ? '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.jb('(' + cellStateString + ',' + toString(element_0) + '),');
+              } else {
+                sb.jb(cellStateString + ',');
+              }
+            }
+             while (inductionVariable < last_0);
+          var tmp2_elvis_lhs = segment.c2d();
+          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.di(sb.a() - 1 | 0);
+        }
+        sb.jb(']');
+        return sb.toString();
+      }
+    }
+    protoOf($).s2i = close$default;
+    protoOf($).u2i = 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.u2e_1 = waiter;
+      }
+      toString() {
+        return 'WaiterEB(' + toString_0(this.u2e_1) + ')';
+      }
+    }
+    initMetadataForClass($, 'WaiterEB');
+    WaiterEBClass = $;
+  }
+  return WaiterEBClass;
+}
+function initialBufferEnd(capacity) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  switch (capacity) {
+    case 0:
+      return new (Long())(0, 0);
+    case 2147483647:
+      return new (Long())(-1, 2147483647);
+    default:
+      return toLong(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.g21(value, null, onCancellation);
+  var tmp;
+  if (!(token == null)) {
+    _this__u8e3s4.h21(token);
+    tmp = true;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function constructEBCompletedAndPauseFlag(counter, pauseEB) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return (pauseEB ? new (Long())(0, 1073741824) : new (Long())(0, 0)).p3(counter);
+}
+function constructSendersAndCloseStatus(counter, closeStatus) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return toLong(closeStatus).z3(60).p3(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.y2b(), 0);
+}
+function createSegment$ref() {
+  var l = function (p0, p1) {
+    return 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())(new (Long())(-1, -1), 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