@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,2960 @@
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  Segmentqmq1glevgieu as Segment,
+  closefimrnzr4lu35 as close,
+  findSegmentInternal35lxp6iondi3q as findSegmentInternal,
+  _SegmentOrClosed___get_segment__impl__jvcr9l18a2bvgc1qn40 as _SegmentOrClosed___get_segment__impl__jvcr9l,
+  _SegmentOrClosed___get_isClosed__impl__qmxmloowq69c0z7uo 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 {
+  fromInt1lka3ktyu79a4 as fromInt,
+  multiply18i3gv3wlmcjg as multiply,
+  add85si75olwt6n as add,
+  divide3tol6kxdi8xn6 as divide,
+  modulo3mmbfwxzpcw3a as modulo,
+  convertToIntofdoxh9bstof as convertToInt,
+  equalsLong28bsrfhwvd686 as equalsLong,
+  compare2uud5j30pw5xc as compare,
+  bitwiseAnd2g7wmsfd45l12 as bitwiseAnd,
+  shiftRight2cr6y79ufiihy as shiftRight,
+  subtract16cg4lfi29fq9 as subtract,
+  shiftLeft1ck77p6vapyra as shiftLeft,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  recoverStackTrace3k4hvtb53ci4z as recoverStackTrace,
+  recoverStackTrace2i3si2i8nvw1k as recoverStackTrace_0,
+} from '../internal/StackTraceRecovery.mjs';
+import {
+  intercepted2ogpsikxxj4u0 as intercepted,
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import {
+  getOrCreateCancellableContinuation2t1o0dr9l9i36 as getOrCreateCancellableContinuation,
+  CancellableContinuationpb2x00mxmcbt as CancellableContinuation,
+} from '../CancellableContinuation.mjs';
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  createFailure8paxfkfa5dc7 as createFailure,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/Result.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_getInstance2uobo5jk84w6b as Companion_getInstance,
+  ChannelResult2y4k69ac6y3du as ChannelResult,
+  ClosedReceiveChannelException3ofg6gf5f5b38 as ClosedReceiveChannelException,
+  ChannelResult__getOrNull_impl_f5e07h2dh05cjyju55c as ChannelResult__getOrNull_impl_f5e07h,
+  ClosedSendChannelException29m33prpq9jaw as ClosedSendChannelException,
+  close$default29t9kascifp5w as close$default,
+  cancel$default3ekkkwpkem73o as cancel$default,
+  ReceiveChannel24wu5e2tj9lbp as ReceiveChannel,
+  SendChannel38sllbxw662ws as SendChannel,
+} from './Channel.mjs';
+import {
+  SelectInstance2isepgzfsd8ur as SelectInstance,
+  SelectImplementation59ci94k9x9wm as SelectImplementation,
+  TrySelectDetailedResult_REREGISTER_getInstance37wb4scq4deq9 as TrySelectDetailedResult_REREGISTER_getInstance,
+  TrySelectDetailedResult_SUCCESSFUL_getInstancekmsh4z99o2un as TrySelectDetailedResult_SUCCESSFUL_getInstance,
+} from '../selects/Select.mjs';
+import {
+  _InlineList___init__impl__z8n56a6l2d509tle7 as _InlineList___init__impl__z8n56,
+  InlineList__plus_impl_nuetvo1qghtjfe175d9 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__6a9atx1csff5kwtduxl 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.h19_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.g19_1 = channel;
+        this.h19_1 = atomicfu$AtomicRefArray$ofNulls(imul(get_SEGMENT_SIZE(), 2));
+      }
+      i19() {
+        return ensureNotNull(this.g19_1);
+      }
+      j19() {
+        return get_SEGMENT_SIZE();
+      }
+      k19(index, element) {
+        setElementLazy(this, index, element);
+      }
+      l19(index) {
+        var tmp = this.h19_1.atomicfu$get(imul(index, 2)).kotlinx$atomicfu$value;
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      m19(index) {
+        // Inline function 'kotlin.also' call
+        var this_0 = this.l19(index);
+        this.n19(index);
+        return this_0;
+      }
+      n19(index) {
+        setElementLazy(this, index, null);
+      }
+      o19(index) {
+        return this.h19_1.atomicfu$get(imul(index, 2) + 1 | 0).kotlinx$atomicfu$value;
+      }
+      p19(index, value) {
+        this.h19_1.atomicfu$get(imul(index, 2) + 1 | 0).kotlinx$atomicfu$value = value;
+      }
+      q19(index, from, to) {
+        return this.h19_1.atomicfu$get(imul(index, 2) + 1 | 0).atomicfu$compareAndSet(from, to);
+      }
+      r19(index, update) {
+        return this.h19_1.atomicfu$get(imul(index, 2) + 1 | 0).atomicfu$getAndSet(update);
+      }
+      v11(index, cause, context) {
+        var isSender = index >= get_SEGMENT_SIZE();
+        var index_0 = isSender ? index - get_SEGMENT_SIZE() | 0 : index;
+        var element = this.l19(index_0);
+        $l$loop: while (true) {
+          var cur = this.o19(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.q19(index_0, cur, update)) {
+              this.n19(index_0);
+              this.e1a(index_0, !isSender);
+              if (isSender) {
+                var tmp0_safe_receiver = this.i19().t19_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.n19(index_0);
+              if (isSender) {
+                var tmp1_safe_receiver = this.i19().t19_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().o(toString_0(message));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      e1a(index, receiver) {
+        if (receiver) {
+          var tmp = this.i19();
+          var tmp0 = this.t11_1;
+          // Inline function 'kotlin.Long.times' call
+          var other = get_SEGMENT_SIZE();
+          // Inline function 'kotlin.Long.plus' call
+          var this_0 = multiply(tmp0, fromInt(other));
+          var tmp$ret$1 = add(this_0, fromInt(index));
+          tmp.f1a(tmp$ret$1);
+        }
+        this.g1a();
+      }
+    }
+    initMetadataForClass($, 'ChannelSegment');
+    ChannelSegmentClass = $;
+  }
+  return ChannelSegmentClass;
+}
+function *_generator_hasNext__q471nr($this, $completion) {
+  var tmp;
+  if (!($this.s1a_1 === get_NO_RECEIVE_RESULT()) && !($this.s1a_1 === get_CHANNEL_CLOSED())) {
+    tmp = true;
+  } else {
+    var tmp0 = $this.u1a_1;
+    var tmp$ret$1;
+    $l$block_0: {
+      // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+      var segment = tmp0.z19_1.kotlinx$atomicfu$value;
+      $l$loop_0: while (true) {
+        if (tmp0.v1a()) {
+          tmp$ret$1 = onClosedHasNext($this);
+          break $l$block_0;
+        }
+        var r = tmp0.v19_1.atomicfu$getAndIncrement$long();
+        // Inline function 'kotlin.Long.div' call
+        var other = get_SEGMENT_SIZE();
+        var id = divide(r, fromInt(other));
+        // Inline function 'kotlin.Long.rem' call
+        var other_0 = get_SEGMENT_SIZE();
+        var tmp$ret$3 = modulo(r, fromInt(other_0));
+        var i = convertToInt(tmp$ret$3);
+        if (!equalsLong(segment.t11_1, id)) {
+          var tmp0_elvis_lhs = findSegmentReceive(tmp0, id, segment);
+          var tmp_0;
+          if (tmp0_elvis_lhs == null) {
+            continue $l$loop_0;
+          } else {
+            tmp_0 = tmp0_elvis_lhs;
+          }
+          segment = tmp_0;
+        }
+        var updCellResult = updateCellReceive(tmp0, segment, i, r, null);
+        var tmp_1;
+        if (updCellResult === get_SUSPEND()) {
+          var tmp1_safe_receiver = (!(null == null) ? isInterface(null, Waiter()) : false) ? null : null;
+          if (tmp1_safe_receiver == null)
+            null;
+          else {
+            prepareReceiverForSuspension(tmp0, tmp1_safe_receiver, segment, i);
+          }
+          var message = 'unreachable';
+          throw IllegalStateException().o(toString_0(message));
+        } else if (updCellResult === get_FAILED()) {
+          if (compare(r, tmp0.w1a()) < 0) {
+            segment.q1a();
+          }
+          continue $l$loop_0;
+        } else if (updCellResult === get_SUSPEND_NO_WAITER()) {
+          var segm = segment;
+          var tmp_2 = hasNextOnNoWaiterSuspend($this, segm, i, r, $completion);
+          if (tmp_2 === get_COROUTINE_SUSPENDED())
+            tmp_2 = yield tmp_2;
+          return tmp_2;
+        } else {
+          segment.q1a();
+          $this.s1a_1 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+          tmp_1 = true;
+        }
+        tmp$ret$1 = tmp_1;
+        break $l$block_0;
+      }
+    }
+    tmp = tmp$ret$1;
+  }
+  return tmp;
+}
+function onClosedHasNext($this) {
+  $this.s1a_1 = get_CHANNEL_CLOSED();
+  var tmp0_elvis_lhs = $this.u1a_1.x1a();
+  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.t1a_1 = cancellable;
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImplOnNoWaiter' call
+    var this_0 = $this.u1a_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 (compare(r, this_0.w1a()) < 0) {
+        segment.q1a();
+      }
+      $l$block_0: {
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+        var segment_0 = this_0.z19_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          if (this_0.v1a()) {
+            onClosedHasNextNoWaiterSuspend($this);
+            break $l$block_0;
+          }
+          var r_0 = this_0.v19_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(r_0, fromInt(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$3 = modulo(r_0, fromInt(other_0));
+          var i = convertToInt(tmp$ret$3);
+          if (!equalsLong(segment_0.t11_1, id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this_0, id, segment_0);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              continue $l$loop_0;
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment_0 = tmp;
+          }
+          var updCellResult_0 = updateCellReceive(this_0, segment_0, i, r_0, $this);
+          if (updCellResult_0 === get_SUSPEND()) {
+            var tmp1_safe_receiver = (!($this == null) ? isInterface($this, Waiter()) : false) ? $this : null;
+            if (tmp1_safe_receiver == null)
+              null;
+            else {
+              prepareReceiverForSuspension(this_0, tmp1_safe_receiver, segment_0, i);
+            }
+          } else if (updCellResult_0 === get_FAILED()) {
+            if (compare(r_0, this_0.w1a()) < 0) {
+              segment_0.q1a();
+            }
+            continue $l$loop_0;
+          } else if (updCellResult_0 === get_SUSPEND_NO_WAITER()) {
+            // Inline function 'kotlin.error' call
+            var message = 'unexpected';
+            throw IllegalStateException().o(toString_0(message));
+          } else {
+            segment_0.q1a();
+            var element = (updCellResult_0 == null ? true : !(updCellResult_0 == null)) ? updCellResult_0 : THROW_CCE();
+            $this.s1a_1 = element;
+            $this.t1a_1 = null;
+            var tmp0_safe_receiver = $this.u1a_1.t19_1;
+            cancellable.w12(true, tmp0_safe_receiver == null ? null : bindCancellationFun($this.u1a_1, tmp0_safe_receiver, element));
+          }
+          break $l$block_0;
+        }
+      }
+    } else {
+      segment.q1a();
+      var element_0 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+      $this.s1a_1 = element_0;
+      $this.t1a_1 = null;
+      var tmp0_safe_receiver_0 = $this.u1a_1.t19_1;
+      cancellable.w12(true, tmp0_safe_receiver_0 == null ? null : bindCancellationFun($this.u1a_1, tmp0_safe_receiver_0, element_0));
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.s12();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.a10();
+}
+function onClosedHasNextNoWaiterSuspend($this) {
+  var cont = ensureNotNull($this.t1a_1);
+  $this.t1a_1 = null;
+  $this.s1a_1 = get_CHANNEL_CLOSED();
+  var cause = $this.u1a_1.x1a();
+  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.dd(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.dd(tmp$ret$2);
+  }
+}
+function _get_bufferEndCounter__2d4hee($this) {
+  return $this.w19_1.kotlinx$atomicfu$value;
+}
+function _get_isRendezvousOrUnlimited__3mdufi($this) {
+  // Inline function 'kotlin.let' call
+  var it = _get_bufferEndCounter__2d4hee($this);
+  return equalsLong(it, new (Long())(0, 0)) || equalsLong(it, new (Long())(-1, 2147483647));
+}
+function *_generator_send__qhx0g0($this, element, $completion) {
+  $l$block_5: {
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+    var segment = $this.y19_1.kotlinx$atomicfu$value;
+    $l$loop_0: while (true) {
+      var sendersAndCloseStatusCur = $this.u19_1.atomicfu$getAndIncrement$long();
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+      var s = bitwiseAnd(sendersAndCloseStatusCur, new (Long())(-1, 268435455));
+      var closed = _get_isClosedForSend0__kxgf9m($this, sendersAndCloseStatusCur);
+      // Inline function 'kotlin.Long.div' call
+      var other = get_SEGMENT_SIZE();
+      var id = divide(s, fromInt(other));
+      // Inline function 'kotlin.Long.rem' call
+      var other_0 = get_SEGMENT_SIZE();
+      var tmp$ret$2 = modulo(s, fromInt(other_0));
+      var i = convertToInt(tmp$ret$2);
+      if (!equalsLong(segment.t11_1, id)) {
+        var tmp0_elvis_lhs = findSegmentSend($this, id, segment);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          var tmp_0;
+          if (closed) {
+            var tmp_1 = onClosedSend($this, element, $completion);
+            if (tmp_1 === get_COROUTINE_SUSPENDED())
+              tmp_1 = yield tmp_1;
+            break $l$block_5;
+          } else {
+            continue $l$loop_0;
+          }
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        segment = tmp;
+      }
+      switch (updateCellSend($this, segment, i, element, s, null, closed)) {
+        case 0:
+          segment.q1a();
+          break $l$block_5;
+        case 1:
+          break $l$block_5;
+        case 2:
+          if (closed) {
+            segment.g1a();
+            var tmp_2 = onClosedSend($this, element, $completion);
+            if (tmp_2 === get_COROUTINE_SUSPENDED())
+              tmp_2 = yield tmp_2;
+            break $l$block_5;
+          }
+
+          var tmp2_safe_receiver = (!(null == null) ? isInterface(null, Waiter()) : false) ? null : null;
+          if (tmp2_safe_receiver == null)
+            null;
+          else {
+            prepareSenderForSuspension($this, tmp2_safe_receiver, segment, i);
+          }
+
+          // Inline function 'kotlinx.coroutines.assert' call
+
+          break $l$block_5;
+        case 4:
+          if (compare(s, $this.y1a()) < 0) {
+            segment.q1a();
+          }
+
+          var tmp_3 = onClosedSend($this, element, $completion);
+          if (tmp_3 === get_COROUTINE_SUSPENDED())
+            tmp_3 = yield tmp_3;
+          break $l$block_5;
+        case 5:
+          segment.q1a();
+          continue $l$loop_0;
+        case 3:
+          var segm = segment;
+          var tmp_4 = sendOnNoWaiterSuspend($this, segm, i, element, s, $completion);
+          if (tmp_4 === get_COROUTINE_SUSPENDED())
+            tmp_4 = yield tmp_4;
+          break $l$block_5;
+      }
+    }
+  }
+  return Unit_instance;
+}
+function onClosedSend($this, element, $completion) {
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.zz();
+  $l$block: {
+    var tmp0_safe_receiver = $this.t19_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.z1a());
+      // 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.dd(tmp$ret$0);
+      break $l$block;
+    }
+    // Inline function 'kotlinx.coroutines.resumeWithStackTrace' call
+    var exception_0 = $this.z1a();
+    // 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.dd(tmp$ret$4);
+  }
+  return cancellable.a10();
+}
+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.q1a();
+        // Inline function 'kotlin.coroutines.resume' call
+
+        // Inline function 'kotlin.Companion.success' call
+
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+        cancellable.dd(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.dd(tmp$ret$3);
+        break;
+      case 2:
+        prepareSenderForSuspension($this, cancellable, segment, index);
+        break;
+      case 4:
+        if (compare(s, $this.y1a()) < 0) {
+          segment.q1a();
+        }
+
+        onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+        break;
+      case 5:
+        segment.q1a();
+        $l$block_5: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+          var segment_0 = $this.y19_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            var sendersAndCloseStatusCur = $this.u19_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+            var s_0 = bitwiseAnd(sendersAndCloseStatusCur, new (Long())(-1, 268435455));
+            var closed = _get_isClosedForSend0__kxgf9m($this, sendersAndCloseStatusCur);
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = divide(s_0, fromInt(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var tmp$ret$9 = modulo(s_0, fromInt(other_0));
+            var i = convertToInt(tmp$ret$9);
+            if (!equalsLong(segment_0.t11_1, id)) {
+              var tmp0_elvis_lhs = findSegmentSend($this, id, segment_0);
+              var tmp;
+              if (tmp0_elvis_lhs == null) {
+                var tmp_0;
+                if (closed) {
+                  onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+                  break $l$block_5;
+                } else {
+                  continue $l$loop_0;
+                }
+              } else {
+                tmp = tmp0_elvis_lhs;
+              }
+              segment_0 = tmp;
+            }
+            switch (updateCellSend($this, segment_0, i, element, s_0, cancellable, closed)) {
+              case 0:
+                segment_0.q1a();
+                // Inline function 'kotlin.coroutines.resume' call
+
+                // Inline function 'kotlin.Companion.success' call
+
+                var tmp$ret$12 = _Result___init__impl__xyqfz8(Unit_instance);
+                cancellable.dd(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.dd(tmp$ret$15);
+                break $l$block_5;
+              case 2:
+                if (closed) {
+                  segment_0.g1a();
+                  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 (compare(s_0, $this.y1a()) < 0) {
+                  segment_0.q1a();
+                }
+
+                onClosedSendOnNoWaiterSuspend($this, element, cancellable);
+                break $l$block_5;
+              case 5:
+                segment_0.q1a();
+                continue $l$loop_0;
+              case 3:
+                // Inline function 'kotlin.error' call
+
+                var message = 'unexpected';
+                throw IllegalStateException().o(toString_0(message));
+            }
+          }
+        }
+
+        break;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message_0 = 'unexpected';
+        throw IllegalStateException().o(toString_0(message_0));
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.s12();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.a10();
+}
+function prepareSenderForSuspension($this, _this__u8e3s4, segment, index) {
+  _this__u8e3s4.y12(segment, index + get_SEGMENT_SIZE() | 0);
+}
+function onClosedSendOnNoWaiterSuspend($this, element, cont) {
+  var tmp0_safe_receiver = $this.t19_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    callUndeliveredElement(tmp0_safe_receiver, element, cont.bd());
+  }
+  // Inline function 'kotlin.coroutines.resumeWithException' call
+  // Inline function 'kotlin.Companion.failure' call
+  var exception = recoverStackTrace_0($this.z1a(), cont);
+  var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+  cont.dd(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.k19(index, element);
+  if (closed)
+    return updateCellSendSlow($this, segment, index, element, s, waiter, closed);
+  var state = segment.o19(index);
+  if (state === null) {
+    if (bufferOrRendezvousSend($this, s)) {
+      if (segment.q19(index, null, get_BUFFERED())) {
+        return 1;
+      }
+    } else {
+      if (waiter == null) {
+        return 3;
+      } else {
+        if (segment.q19(index, null, waiter))
+          return 2;
+      }
+    }
+  } else {
+    if (!(state == null) ? isInterface(state, Waiter()) : false) {
+      segment.n19(index);
+      var tmp;
+      if (tryResumeReceiver($this, state, element)) {
+        segment.p19(index, get_DONE_RCV());
+        $this.a1b();
+        tmp = 0;
+      } else {
+        if (!(segment.r19(index, get_INTERRUPTED_RCV()) === get_INTERRUPTED_RCV())) {
+          segment.e1a(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.o19(index);
+    if (state === null) {
+      if (bufferOrRendezvousSend($this, s) && !closed) {
+        if (segment.q19(index, null, get_BUFFERED())) {
+          return 1;
+        }
+      } else {
+        if (closed) {
+          if (segment.q19(index, null, get_INTERRUPTED_SEND())) {
+            segment.e1a(index, false);
+            return 4;
+          }
+        } else if (waiter == null)
+          return 3;
+        else if (segment.q19(index, null, waiter))
+          return 2;
+      }
+    } else if (state === get_IN_BUFFER()) {
+      if (segment.q19(index, state, get_BUFFERED())) {
+        return 1;
+      }
+    } else if (state === get_INTERRUPTED_RCV()) {
+      segment.n19(index);
+      return 5;
+    } else if (state === get_POISONED()) {
+      segment.n19(index);
+      return 5;
+    } else if (state === get_CHANNEL_CLOSED()) {
+      segment.n19(index);
+      completeCloseOrCancel($this);
+      return 4;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      segment.n19(index);
+      var tmp;
+      if (state instanceof WaiterEB()) {
+        tmp = state.b1b_1;
+      } else {
+        tmp = state;
+      }
+      var receiver = tmp;
+      var tmp_0;
+      if (tryResumeReceiver($this, receiver, element)) {
+        segment.p19(index, get_DONE_RCV());
+        $this.a1b();
+        tmp_0 = 0;
+      } else {
+        if (!(segment.r19(index, get_INTERRUPTED_RCV()) === get_INTERRUPTED_RCV())) {
+          segment.e1a(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 = bitwiseAnd(curSendersAndCloseStatus, new (Long())(-1, 268435455));
+  return !bufferOrRendezvousSend($this, tmp$ret$0);
+}
+function bufferOrRendezvousSend($this, curSenders) {
+  var tmp;
+  if (compare(curSenders, _get_bufferEndCounter__2d4hee($this)) < 0) {
+    tmp = true;
+  } else {
+    var tmp0 = $this.y1a();
+    // Inline function 'kotlin.Long.plus' call
+    var other = $this.s19_1;
+    var tmp$ret$0 = add(tmp0, fromInt(other));
+    tmp = compare(curSenders, tmp$ret$0) < 0;
+  }
+  return tmp;
+}
+function tryResumeReceiver($this, _this__u8e3s4, element) {
+  var tmp;
+  if (isInterface(_this__u8e3s4, SelectInstance())) {
+    tmp = _this__u8e3s4.g1b($this, element);
+  } else {
+    if (_this__u8e3s4 instanceof ReceiveCatching()) {
+      if (!(_this__u8e3s4 instanceof ReceiveCatching()))
+        THROW_CCE();
+      var tmp_0 = Companion_getInstance().e1b(element);
+      var tmp1_safe_receiver = $this.t19_1;
+      tmp = tryResume0(_this__u8e3s4.f1b_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.c1b(element);
+      } else {
+        if (isInterface(_this__u8e3s4, CancellableContinuation())) {
+          if (!isInterface(_this__u8e3s4, CancellableContinuation()))
+            THROW_CCE();
+          var tmp2_safe_receiver = $this.t19_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().o(toString_0(message));
+        }
+      }
+    }
+  }
+  return tmp;
+}
+function *_generator_receive__aoggq9($this, $completion) {
+  var tmp$ret$0;
+  $l$block: {
+    // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+    var segment = $this.z19_1.kotlinx$atomicfu$value;
+    $l$loop_0: while (true) {
+      if ($this.v1a()) {
+        throw recoverStackTrace(_get_receiveException__foorc1($this));
+      }
+      var r = $this.v19_1.atomicfu$getAndIncrement$long();
+      // Inline function 'kotlin.Long.div' call
+      var other = get_SEGMENT_SIZE();
+      var id = divide(r, fromInt(other));
+      // Inline function 'kotlin.Long.rem' call
+      var other_0 = get_SEGMENT_SIZE();
+      var tmp$ret$2 = modulo(r, fromInt(other_0));
+      var i = convertToInt(tmp$ret$2);
+      if (!equalsLong(segment.t11_1, id)) {
+        var tmp0_elvis_lhs = findSegmentReceive($this, id, segment);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          continue $l$loop_0;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        segment = tmp;
+      }
+      var updCellResult = updateCellReceive($this, segment, i, r, null);
+      var tmp_0;
+      if (updCellResult === get_SUSPEND()) {
+        var tmp1_safe_receiver = (!(null == null) ? isInterface(null, Waiter()) : false) ? null : null;
+        if (tmp1_safe_receiver == null)
+          null;
+        else {
+          prepareReceiverForSuspension($this, tmp1_safe_receiver, segment, i);
+        }
+        var message = 'unexpected';
+        throw IllegalStateException().o(toString_0(message));
+      } else if (updCellResult === get_FAILED()) {
+        if (compare(r, $this.w1a()) < 0) {
+          segment.q1a();
+        }
+        continue $l$loop_0;
+      } else if (updCellResult === get_SUSPEND_NO_WAITER()) {
+        var segm = segment;
+        var tmp_1 = receiveOnNoWaiterSuspend($this, segm, i, r, $completion);
+        if (tmp_1 === get_COROUTINE_SUSPENDED())
+          tmp_1 = yield tmp_1;
+        tmp_0 = tmp_1;
+      } else {
+        segment.q1a();
+        return (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+      }
+      tmp$ret$0 = tmp_0;
+      break $l$block;
+    }
+  }
+  return tmp$ret$0;
+}
+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 (compare(r, $this.w1a()) < 0) {
+        segment.q1a();
+      }
+      $l$block_0: {
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.receiveImpl' call
+        var segment_0 = $this.z19_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          if ($this.v1a()) {
+            onClosedReceiveOnNoWaiterSuspend($this, cancellable);
+            break $l$block_0;
+          }
+          var r_0 = $this.v19_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(r_0, fromInt(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$3 = modulo(r_0, fromInt(other_0));
+          var i = convertToInt(tmp$ret$3);
+          if (!equalsLong(segment_0.t11_1, 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 (compare(r_0, $this.w1a()) < 0) {
+              segment_0.q1a();
+            }
+            continue $l$loop_0;
+          } else if (updCellResult_0 === get_SUSPEND_NO_WAITER()) {
+            // Inline function 'kotlin.error' call
+            var message = 'unexpected';
+            throw IllegalStateException().o(toString_0(message));
+          } else {
+            segment_0.q1a();
+            var element = (updCellResult_0 == null ? true : !(updCellResult_0 == null)) ? updCellResult_0 : THROW_CCE();
+            var tmp0_safe_receiver = $this.t19_1;
+            var onCancellation = tmp0_safe_receiver == null ? null : bindCancellationFun_0($this, tmp0_safe_receiver);
+            cancellable.w12(element, onCancellation);
+          }
+          break $l$block_0;
+        }
+      }
+    } else {
+      segment.q1a();
+      var element_0 = (updCellResult == null ? true : !(updCellResult == null)) ? updCellResult : THROW_CCE();
+      var tmp0_safe_receiver_0 = $this.t19_1;
+      var onCancellation_0 = tmp0_safe_receiver_0 == null ? null : bindCancellationFun_0($this, tmp0_safe_receiver_0);
+      cancellable.w12(element_0, onCancellation_0);
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      cancellable.s12();
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return cancellable.a10();
+}
+function prepareReceiverForSuspension($this, _this__u8e3s4, segment, index) {
+  $this.h1b();
+  _this__u8e3s4.y12(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.dd(tmp$ret$0);
+}
+function updateCellReceive($this, segment, index, r, waiter) {
+  var state = segment.o19(index);
+  if (state === null) {
+    // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+    var this_0 = $this.u19_1.kotlinx$atomicfu$value;
+    var senders = bitwiseAnd(this_0, new (Long())(-1, 268435455));
+    if (compare(r, senders) >= 0) {
+      if (waiter === null) {
+        return get_SUSPEND_NO_WAITER();
+      }
+      if (segment.q19(index, state, waiter)) {
+        expandBuffer($this);
+        return get_SUSPEND();
+      }
+    }
+  } else if (state === get_BUFFERED())
+    if (segment.q19(index, state, get_DONE_RCV())) {
+      expandBuffer($this);
+      return segment.m19(index);
+    }
+  return updateCellReceiveSlow($this, segment, index, r, waiter);
+}
+function updateCellReceiveSlow($this, segment, index, r, waiter) {
+  $l$loop: while (true) {
+    var state = segment.o19(index);
+    if (state === null || state === get_IN_BUFFER()) {
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+      var this_0 = $this.u19_1.kotlinx$atomicfu$value;
+      var senders = bitwiseAnd(this_0, new (Long())(-1, 268435455));
+      if (compare(r, senders) < 0) {
+        if (segment.q19(index, state, get_POISONED())) {
+          expandBuffer($this);
+          return get_FAILED();
+        }
+      } else {
+        if (waiter === null) {
+          return get_SUSPEND_NO_WAITER();
+        }
+        if (segment.q19(index, state, waiter)) {
+          expandBuffer($this);
+          return get_SUSPEND();
+        }
+      }
+    } else if (state === get_BUFFERED()) {
+      if (segment.q19(index, state, get_DONE_RCV())) {
+        expandBuffer($this);
+        return segment.m19(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.q19(index, state, get_RESUMING_BY_RCV())) {
+        var helpExpandBuffer = state instanceof WaiterEB();
+        var tmp;
+        if (state instanceof WaiterEB()) {
+          tmp = state.b1b_1;
+        } else {
+          tmp = state;
+        }
+        var sender = tmp;
+        var tmp_0;
+        if (tryResumeSender($this, sender, segment, index)) {
+          segment.p19(index, get_DONE_RCV());
+          expandBuffer($this);
+          tmp_0 = segment.m19(index);
+        } else {
+          segment.p19(index, get_INTERRUPTED_SEND());
+          segment.e1a(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.m1b($this, Unit_instance);
+      if (trySelectResult === TrySelectDetailedResult_REREGISTER_getInstance()) {
+        segment.n19(index);
+      }
+      tmp = trySelectResult === TrySelectDetailedResult_SUCCESSFUL_getInstance();
+    } else {
+      if (_this__u8e3s4 instanceof SendBroadcast()) {
+        tmp = tryResume0(_this__u8e3s4.i1b_1, true);
+      } else {
+        var message = 'Unexpected waiter: ' + toString_0(_this__u8e3s4);
+        throw IllegalStateException().o(toString_0(message));
+      }
+    }
+  }
+  return tmp;
+}
+function expandBuffer($this) {
+  if (_get_isRendezvousOrUnlimited__3mdufi($this))
+    return Unit_instance;
+  var segment = $this.a1a_1.kotlinx$atomicfu$value;
+  try_again: while (true) {
+    var b = $this.w19_1.atomicfu$getAndIncrement$long();
+    // Inline function 'kotlin.Long.div' call
+    var other = get_SEGMENT_SIZE();
+    var id = divide(b, fromInt(other));
+    var s = $this.w1a();
+    if (compare(s, b) <= 0) {
+      if (compare(segment.t11_1, id) < 0 && !(segment.m1a() == null)) {
+        moveSegmentBufferEndToSpecifiedOrLast($this, id, segment);
+      }
+      incCompletedExpandBufferAttempts$default($this);
+      return Unit_instance;
+    }
+    if (!equalsLong(segment.t11_1, id)) {
+      var tmp0_elvis_lhs = findSegmentBufferEnd($this, id, segment, b);
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        continue try_again;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      segment = tmp;
+    }
+    // Inline function 'kotlin.Long.rem' call
+    var other_0 = get_SEGMENT_SIZE();
+    var tmp$ret$1 = modulo(b, fromInt(other_0));
+    var i = convertToInt(tmp$ret$1);
+    if (updateCellExpandBuffer($this, segment, i, b)) {
+      incCompletedExpandBufferAttempts$default($this);
+      return Unit_instance;
+    } else {
+      incCompletedExpandBufferAttempts$default($this);
+      continue try_again;
+    }
+  }
+}
+function updateCellExpandBuffer($this, segment, index, b) {
+  var state = segment.o19(index);
+  if (!(state == null) ? isInterface(state, Waiter()) : false) {
+    if (compare(b, $this.v19_1.kotlinx$atomicfu$value) >= 0) {
+      if (segment.q19(index, state, get_RESUMING_BY_EB())) {
+        var tmp;
+        if (tryResumeSender($this, state, segment, index)) {
+          segment.p19(index, get_BUFFERED());
+          tmp = true;
+        } else {
+          segment.p19(index, get_INTERRUPTED_SEND());
+          segment.e1a(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.o19(index);
+    if (!(state == null) ? isInterface(state, Waiter()) : false) {
+      if (compare(b, $this.v19_1.kotlinx$atomicfu$value) < 0) {
+        if (segment.q19(index, state, new (WaiterEB())(state)))
+          return true;
+      } else {
+        if (segment.q19(index, state, get_RESUMING_BY_EB())) {
+          var tmp;
+          if (tryResumeSender($this, state, segment, index)) {
+            segment.p19(index, get_BUFFERED());
+            tmp = true;
+          } else {
+            segment.p19(index, get_INTERRUPTED_SEND());
+            segment.e1a(index, false);
+            tmp = false;
+          }
+          return tmp;
+        }
+      }
+    } else {
+      if (state === get_INTERRUPTED_SEND())
+        return false;
+      else {
+        if (state === null) {
+          if (segment.q19(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().o(toString_0(message));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function incCompletedExpandBufferAttempts($this, nAttempts) {
+  // Inline function 'kotlin.also' call
+  var this_0 = $this.x19_1.atomicfu$addAndGet$long(nAttempts);
+  // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+  if (!equalsLong(bitwiseAnd(this_0, new (Long())(0, 1073741824)), new (Long())(0, 0))) {
+    $l$loop: while (true) {
+      // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+      var this_1 = $this.x19_1.kotlinx$atomicfu$value;
+      if (!!equalsLong(bitwiseAnd(this_1, new (Long())(0, 1073741824)), 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.u1a_1 = $outer;
+        this.s1a_1 = get_NO_RECEIVE_RESULT();
+        this.t1a_1 = null;
+      }
+      n1b($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_hasNext__q471nr.bind(VOID, this), $completion);
+      }
+      y12(segment, index) {
+        var tmp0_safe_receiver = this.t1a_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          tmp0_safe_receiver.y12(segment, index);
+        }
+      }
+      s1() {
+        var result = this.s1a_1;
+        // Inline function 'kotlin.check' call
+        if (!!(result === get_NO_RECEIVE_RESULT())) {
+          var message = '`hasNext()` has not been invoked';
+          throw IllegalStateException().o(toString_0(message));
+        }
+        this.s1a_1 = get_NO_RECEIVE_RESULT();
+        if (result === get_CHANNEL_CLOSED())
+          throw recoverStackTrace(_get_receiveException__foorc1(this.u1a_1));
+        return (result == null ? true : !(result == null)) ? result : THROW_CCE();
+      }
+      c1b(element) {
+        var cont = ensureNotNull(this.t1a_1);
+        this.t1a_1 = null;
+        this.s1a_1 = element;
+        var tmp0_safe_receiver = this.u1a_1.t19_1;
+        return tryResume0(cont, true, tmp0_safe_receiver == null ? null : bindCancellationFun(this.u1a_1, tmp0_safe_receiver, element));
+      }
+      o1b() {
+        var cont = ensureNotNull(this.t1a_1);
+        this.t1a_1 = null;
+        this.s1a_1 = get_CHANNEL_CLOSED();
+        var cause = this.u1a_1.x1a();
+        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.dd(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.dd(tmp$ret$2);
+        }
+      }
+    }
+    initMetadataForClass($, 'BufferedChannelIterator', VOID, VOID, [Waiter()], [0, 3]);
+    BufferedChannelIteratorClass = $;
+  }
+  return BufferedChannelIteratorClass;
+}
+function _get_receiveException__foorc1($this) {
+  var tmp0_elvis_lhs = $this.x1a();
+  return tmp0_elvis_lhs == null ? ClosedReceiveChannelException().t1b('Channel was closed') : tmp0_elvis_lhs;
+}
+function invokeCloseHandler($this) {
+  var tmp0 = $this.d1a_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.x1a());
+}
+function markClosed($this) {
+  var tmp0 = $this.u19_1;
+  var tmp$ret$4;
+  $l$block: {
+    // Inline function 'kotlinx.atomicfu.update' call
+    while (true) {
+      var cur = tmp0.kotlinx$atomicfu$value;
+      // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+      var tmp;
+      switch (convertToInt(shiftRight(cur, 60))) {
+        case 0:
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+          var tmp$ret$1 = bitwiseAnd(cur, new (Long())(-1, 268435455));
+          tmp = constructSendersAndCloseStatus(tmp$ret$1, 2);
+          break;
+        case 1:
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+          var tmp$ret$2 = bitwiseAnd(cur, 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.u19_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 = bitwiseAnd(cur, 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.u19_1;
+  var tmp$ret$3;
+  $l$block: {
+    // Inline function 'kotlinx.atomicfu.update' call
+    while (true) {
+      var cur = tmp0.kotlinx$atomicfu$value;
+      var tmp;
+      // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+      if (convertToInt(shiftRight(cur, 60)) === 0) {
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        var tmp$ret$1 = bitwiseAnd(cur, 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.u1b();
+}
+function completeClose($this, sendersCur) {
+  var lastSegment = closeLinkedList($this);
+  if ($this.w1b()) {
+    var lastBufferedCellGlobalIndex = markAllEmptyCellsAsClosed($this, lastSegment);
+    if (!equalsLong(lastBufferedCellGlobalIndex, new (Long())(-1, -1))) {
+      $this.v1b(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.a1a_1.kotlinx$atomicfu$value;
+  // Inline function 'kotlin.let' call
+  var it = $this.y19_1.kotlinx$atomicfu$value;
+  if (compare(it.t11_1, lastSegment.t11_1) > 0)
+    lastSegment = it;
+  // Inline function 'kotlin.let' call
+  var it_0 = $this.z19_1.kotlinx$atomicfu$value;
+  if (compare(it_0.t11_1, lastSegment.t11_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.t11_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var this_0 = multiply(tmp0, fromInt(other));
+        var globalIndex = add(this_0, fromInt(index));
+        if (compare(globalIndex, $this.y1a()) < 0)
+          return new (Long())(-1, -1);
+        cell_update: while (true) {
+          var state = segment.o19(index);
+          if (state === null || state === get_IN_BUFFER()) {
+            if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+              segment.g1a();
+              break cell_update;
+            }
+          } else if (state === get_BUFFERED())
+            return globalIndex;
+          else
+            break cell_update;
+        }
+      }
+       while (0 <= inductionVariable);
+    var tmp0_elvis_lhs = segment.p1a();
+    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.t19_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.t11_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var this_0 = multiply(tmp0, fromInt(other));
+        var globalIndex = add(this_0, fromInt(index));
+        update_cell: while (true) {
+          var state = segment.o19(index);
+          if (state === get_DONE_RCV())
+            break process_segments;
+          else {
+            if (state === get_BUFFERED()) {
+              if (compare(globalIndex, $this.y1a()) < 0)
+                break process_segments;
+              if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+                if (!(onUndeliveredElement == null)) {
+                  var element = segment.l19(index);
+                  undeliveredElementException = callUndeliveredElementCatchingException(onUndeliveredElement, element, undeliveredElementException);
+                }
+                segment.n19(index);
+                segment.g1a();
+                break update_cell;
+              }
+            } else {
+              if (state === get_IN_BUFFER() || state === null) {
+                if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+                  segment.g1a();
+                  break update_cell;
+                }
+              } else {
+                var tmp;
+                if (!(state == null) ? isInterface(state, Waiter()) : false) {
+                  tmp = true;
+                } else {
+                  tmp = state instanceof WaiterEB();
+                }
+                if (tmp) {
+                  if (compare(globalIndex, $this.y1a()) < 0)
+                    break process_segments;
+                  var tmp_0;
+                  if (state instanceof WaiterEB()) {
+                    tmp_0 = state.b1b_1;
+                  } else {
+                    tmp_0 = (!(state == null) ? isInterface(state, Waiter()) : false) ? state : THROW_CCE();
+                  }
+                  var sender = tmp_0;
+                  if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+                    if (!(onUndeliveredElement == null)) {
+                      var element_0 = segment.l19(index);
+                      undeliveredElementException = callUndeliveredElementCatchingException(onUndeliveredElement, element_0, undeliveredElementException);
+                    }
+                    suspendedSenders = InlineList__plus_impl_nuetvo(suspendedSenders, sender);
+                    segment.n19(index);
+                    segment.g1a();
+                    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.p1a();
+    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.v2() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var i = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            var it_0 = list.u2(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.t11_1;
+        // Inline function 'kotlin.Long.times' call
+        var other = get_SEGMENT_SIZE();
+        // Inline function 'kotlin.Long.plus' call
+        var this_0 = multiply(tmp0, fromInt(other));
+        var tmp$ret$1 = add(this_0, fromInt(index));
+        if (compare(tmp$ret$1, sendersCounter) < 0)
+          break process_segments;
+        cell_update: while (true) {
+          var state = segment.o19(index);
+          if (state === null || state === get_IN_BUFFER()) {
+            if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+              segment.g1a();
+              break cell_update;
+            }
+          } else {
+            if (state instanceof WaiterEB()) {
+              if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+                suspendedReceivers = InlineList__plus_impl_nuetvo(suspendedReceivers, state.b1b_1);
+                segment.e1a(index, true);
+                break cell_update;
+              }
+            } else {
+              if (!(state == null) ? isInterface(state, Waiter()) : false) {
+                if (segment.q19(index, state, get_CHANNEL_CLOSED())) {
+                  suspendedReceivers = InlineList__plus_impl_nuetvo(suspendedReceivers, state);
+                  segment.e1a(index, true);
+                  break cell_update;
+                }
+              } else {
+                break cell_update;
+              }
+            }
+          }
+        }
+      }
+       while (0 <= inductionVariable);
+    segment = segment.p1a();
+  }
+  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.v2() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var i = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            var it_0 = list.u2(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.i1b_1;
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(false);
+    this_0.dd(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.z1a();
+      var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(exception));
+      _this__u8e3s4.dd(tmp$ret$2);
+    } else {
+      if (_this__u8e3s4 instanceof ReceiveCatching()) {
+        var tmp0 = _this__u8e3s4.f1b_1;
+        // Inline function 'kotlin.coroutines.resume' call
+        // Inline function 'kotlin.Companion.success' call
+        var value = new (ChannelResult())(Companion_getInstance().x1b($this.x1a()));
+        var tmp$ret$4 = _Result___init__impl__xyqfz8(value);
+        tmp0.dd(tmp$ret$4);
+      } else {
+        if (_this__u8e3s4 instanceof BufferedChannelIterator()) {
+          _this__u8e3s4.o1b();
+        } else {
+          if (isInterface(_this__u8e3s4, SelectInstance()))
+            _this__u8e3s4.g1b($this, get_CHANNEL_CLOSED());
+          else {
+            // Inline function 'kotlin.error' call
+            var message = 'Unexpected waiter: ' + toString_0(_this__u8e3s4);
+            throw IllegalStateException().o(toString_0(message));
+          }
+        }
+      }
+    }
+  }
+}
+function _get_isClosedForSend0__kxgf9m($this, _this__u8e3s4) {
+  return isClosed($this, _this__u8e3s4, false);
+}
+function _get_isClosedForReceive0__f7qknl($this, _this__u8e3s4) {
+  return isClosed($this, _this__u8e3s4, true);
+}
+function isClosed($this, sendersAndCloseStatusCur, isClosedForReceive) {
+  // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+  var tmp;
+  switch (convertToInt(shiftRight(sendersAndCloseStatusCur, 60))) {
+    case 0:
+      tmp = false;
+      break;
+    case 1:
+      tmp = false;
+      break;
+    case 2:
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+      var tmp$ret$1 = bitwiseAnd(sendersAndCloseStatusCur, new (Long())(-1, 268435455));
+      completeClose($this, tmp$ret$1);
+      tmp = isClosedForReceive ? !$this.y1b() : true;
+      break;
+    case 3:
+      // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+
+      var tmp$ret$2 = bitwiseAnd(sendersAndCloseStatusCur, 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: ' + convertToInt(shiftRight(sendersAndCloseStatusCur, 60));
+      throw IllegalStateException().o(toString_0(message));
+  }
+  return tmp;
+}
+function isCellNonEmpty($this, segment, index, globalIndex) {
+  while (true) {
+    var state = segment.o19(index);
+    if (state === null || state === get_IN_BUFFER()) {
+      if (segment.q19(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 equalsLong(globalIndex, $this.y1a());
+  }
+}
+function findSegmentSend($this, id, startFrom) {
+  var tmp0 = $this.y19_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 (compare(cur.t11_1, tmp2.t11_1) >= 0) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.i1a()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.j1a()) {
+                cur.s6();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.j1a()) {
+              tmp2.s6();
+            }
+          }
+          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.t11_1;
+    // Inline function 'kotlin.Long.times' call
+    var other = get_SEGMENT_SIZE();
+    var tmp$ret$3 = multiply(tmp0_0, fromInt(other));
+    if (compare(tmp$ret$3, $this.y1a()) < 0) {
+      startFrom.q1a();
+    }
+    tmp_0 = null;
+  } else {
+    var segment = _SegmentOrClosed___get_segment__impl__jvcr9l(it);
+    var tmp_1;
+    if (compare(segment.t11_1, id) > 0) {
+      var tmp0_1 = segment.t11_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_0 = get_SEGMENT_SIZE();
+      var tmp$ret$4 = multiply(tmp0_1, fromInt(other_0));
+      updateSendersCounterIfLower($this, tmp$ret$4);
+      var tmp0_2 = segment.t11_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_1 = get_SEGMENT_SIZE();
+      var tmp$ret$5 = multiply(tmp0_2, fromInt(other_1));
+      if (compare(tmp$ret$5, $this.y1a()) < 0) {
+        segment.q1a();
+      }
+      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.z19_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 (compare(cur.t11_1, tmp2.t11_1) >= 0) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.i1a()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.j1a()) {
+                cur.s6();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.j1a()) {
+              tmp2.s6();
+            }
+          }
+          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.t11_1;
+    // Inline function 'kotlin.Long.times' call
+    var other = get_SEGMENT_SIZE();
+    var tmp$ret$3 = multiply(tmp0_0, fromInt(other));
+    if (compare(tmp$ret$3, $this.w1a()) < 0) {
+      startFrom.q1a();
+    }
+    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 = divide(tmp0_1, fromInt(other_0));
+      tmp_1 = compare(id, tmp$ret$4) <= 0;
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      var tmp0_2 = $this.a1a_1;
+      $l$block_5: {
+        // Inline function 'kotlinx.coroutines.internal.moveForward' call
+        while (true) {
+          var cur_0 = tmp0_2.kotlinx$atomicfu$value;
+          if (compare(cur_0.t11_1, segment.t11_1) >= 0) {
+            break $l$block_5;
+          }
+          if (!segment.i1a()) {
+            break $l$block_5;
+          }
+          if (tmp0_2.atomicfu$compareAndSet(cur_0, segment)) {
+            if (cur_0.j1a()) {
+              cur_0.s6();
+            }
+            break $l$block_5;
+          }
+          if (segment.j1a()) {
+            segment.s6();
+          }
+        }
+      }
+    }
+    var tmp_2;
+    if (compare(segment.t11_1, id) > 0) {
+      var tmp0_3 = segment.t11_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_1 = get_SEGMENT_SIZE();
+      var tmp$ret$7 = multiply(tmp0_3, fromInt(other_1));
+      updateReceiversCounterIfLower($this, tmp$ret$7);
+      var tmp0_4 = segment.t11_1;
+      // Inline function 'kotlin.Long.times' call
+      var other_2 = get_SEGMENT_SIZE();
+      var tmp$ret$8 = multiply(tmp0_4, fromInt(other_2));
+      if (compare(tmp$ret$8, $this.w1a()) < 0) {
+        segment.q1a();
+      }
+      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.a1a_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 (compare(cur.t11_1, tmp2.t11_1) >= 0) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (!tmp2.i1a()) {
+              tmp$ret$0 = false;
+              break $l$block_1;
+            }
+            if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+              if (cur.j1a()) {
+                cur.s6();
+              }
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+            if (tmp2.j1a()) {
+              tmp2.s6();
+            }
+          }
+          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 (compare(segment.t11_1, id) > 0) {
+      // Inline function 'kotlin.Long.plus' call
+      var tmp_2 = add(currentBufferEndCounter, fromInt(1));
+      var tmp0_0 = segment.t11_1;
+      // Inline function 'kotlin.Long.times' call
+      var other = get_SEGMENT_SIZE();
+      var tmp$ret$4 = multiply(tmp0_0, fromInt(other));
+      if ($this.w19_1.atomicfu$compareAndSet(tmp_2, tmp$ret$4)) {
+        var tmp0_1 = segment.t11_1;
+        // Inline function 'kotlin.Long.times' call
+        var other_0 = get_SEGMENT_SIZE();
+        var tmp$ret$5 = multiply(tmp0_1, fromInt(other_0));
+        incCompletedExpandBufferAttempts($this, subtract(tmp$ret$5, currentBufferEndCounter));
+      } else {
+        incCompletedExpandBufferAttempts$default($this);
+      }
+      tmp_1 = null;
+    } else {
+      // Inline function 'kotlinx.coroutines.assert' call
+      tmp_1 = segment;
+    }
+    tmp_0 = tmp_1;
+  }
+  return tmp_0;
+}
+function moveSegmentBufferEndToSpecifiedOrLast($this, id, startFrom) {
+  var segment = startFrom;
+  $l$loop: while (compare(segment.t11_1, id) < 0) {
+    var tmp0_elvis_lhs = segment.m1a();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      break $l$loop;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    segment = tmp;
+  }
+  while (true) {
+    $l$loop_0: while (segment.h1a()) {
+      var tmp1_elvis_lhs = segment.m1a();
+      var tmp_0;
+      if (tmp1_elvis_lhs == null) {
+        break $l$loop_0;
+      } else {
+        tmp_0 = tmp1_elvis_lhs;
+      }
+      segment = tmp_0;
+    }
+    var tmp0 = $this.a1a_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 (compare(cur.t11_1, tmp2.t11_1) >= 0) {
+          tmp$ret$0 = true;
+          break $l$block_1;
+        }
+        if (!tmp2.i1a()) {
+          tmp$ret$0 = false;
+          break $l$block_1;
+        }
+        if (tmp0.atomicfu$compareAndSet(cur, tmp2)) {
+          if (cur.j1a()) {
+            cur.s6();
+          }
+          tmp$ret$0 = true;
+          break $l$block_1;
+        }
+        if (tmp2.j1a()) {
+          tmp2.s6();
+        }
+      }
+      tmp$ret$0 = Unit_instance;
+    }
+    if (tmp$ret$0)
+      return Unit_instance;
+  }
+}
+function updateSendersCounterIfLower($this, value) {
+  var this_0 = $this.u19_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+    var curCounter = bitwiseAnd(cur, new (Long())(-1, 268435455));
+    if (compare(curCounter, value) >= 0)
+      return Unit_instance;
+    // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+    var tmp$ret$1 = convertToInt(shiftRight(cur, 60));
+    var update = constructSendersAndCloseStatus(curCounter, tmp$ret$1);
+    if ($this.u19_1.atomicfu$compareAndSet(cur, update))
+      return Unit_instance;
+  }
+  return Unit_instance;
+}
+function updateReceiversCounterIfLower($this, value) {
+  var this_0 = $this.v19_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    if (compare(cur, value) >= 0)
+      return Unit_instance;
+    if ($this.v19_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.t19_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.t19_1), element, context);
+}
+function BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda$lambda($element, this$0, $select) {
+  return (_unused_var__etf5q3, _unused_var__etf5q3_0, _unused_var__etf5q3_1) => {
+    var tmp;
+    if (!($element === get_CHANNEL_CLOSED())) {
+      callUndeliveredElement(this$0.t19_1, ($element == null ? true : !($element == null)) ? $element : THROW_CCE(), $select.bd());
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda(this$0) {
+  return (select, _unused_var__etf5q3, element) => BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda$lambda(element, this$0, select);
+}
+function BufferedChannel$onCancellationChannelResultImplDoNotCall$ref(p0) {
+  var l = (_this__u8e3s4, p0_0, p1) => {
+    var tmp0 = p0;
+    onCancellationChannelResultImplDoNotCall(tmp0, _this__u8e3s4, p0_0.a1c_1, p1);
+    return Unit_instance;
+  };
+  l.callableName = 'onCancellationChannelResultImplDoNotCall';
+  return l;
+}
+function BufferedChannel$bindCancellationFun$lambda($this_bindCancellationFun, $element) {
+  return (_unused_var__etf5q3, _unused_var__etf5q3_0, context) => {
+    callUndeliveredElement($this_bindCancellationFun, $element, context);
+    return Unit_instance;
+  };
+}
+function BufferedChannel$onCancellationImplDoNotCall$ref(p0) {
+  var l = (_this__u8e3s4, p0_0, p1) => {
+    var tmp0 = p0;
+    onCancellationImplDoNotCall(tmp0, _this__u8e3s4, p0_0, p1);
+    return Unit_instance;
+  };
+  l.callableName = 'onCancellationImplDoNotCall';
+  return l;
+}
+var BufferedChannelClass;
+function BufferedChannel() {
+  if (BufferedChannelClass === VOID) {
+    class $ {
+      constructor(capacity, onUndeliveredElement) {
+        onUndeliveredElement = onUndeliveredElement === VOID ? null : onUndeliveredElement;
+        this.s19_1 = capacity;
+        this.t19_1 = onUndeliveredElement;
+        // Inline function 'kotlin.require' call
+        if (!(this.s19_1 >= 0)) {
+          var message = 'Invalid channel capacity: ' + this.s19_1 + ', should be >=0';
+          throw IllegalArgumentException().r2(toString_0(message));
+        }
+        this.u19_1 = atomic$long$1(new (Long())(0, 0));
+        this.v19_1 = atomic$long$1(new (Long())(0, 0));
+        this.w19_1 = atomic$long$1(initialBufferEnd(this.s19_1));
+        this.x19_1 = atomic$long$1(_get_bufferEndCounter__2d4hee(this));
+        var firstSegment = new (ChannelSegment())(new (Long())(0, 0), null, this, 3);
+        this.y19_1 = atomic$ref$1(firstSegment);
+        this.z19_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.a1a_1 = atomic$ref$1(tmp_0);
+        var tmp_2 = this;
+        var tmp_3;
+        if (this.t19_1 == null) {
+          tmp_3 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_3 = BufferedChannel$onUndeliveredElementReceiveCancellationConstructor$lambda(this);
+        }
+        tmp_2.b1a_1 = tmp_3;
+        this.c1a_1 = atomic$ref$1(get_NO_CLOSE_CAUSE());
+        this.d1a_1 = atomic$ref$1(null);
+      }
+      w1a() {
+        // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+        var this_0 = this.u19_1.kotlinx$atomicfu$value;
+        return bitwiseAnd(this_0, new (Long())(-1, 268435455));
+      }
+      y1a() {
+        return this.v19_1.kotlinx$atomicfu$value;
+      }
+      b1c(element, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_send__qhx0g0.bind(VOID, this, element), $completion);
+      }
+      c1c(element) {
+        if (shouldSendSuspend0(this, this.u19_1.kotlinx$atomicfu$value))
+          return Companion_getInstance().d1c();
+        var tmp4 = get_INTERRUPTED_SEND();
+        var tmp$ret$4;
+        $l$block_4: {
+          // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+          var segment = this.y19_1.kotlinx$atomicfu$value;
+          $l$loop_0: while (true) {
+            var sendersAndCloseStatusCur = this.u19_1.atomicfu$getAndIncrement$long();
+            // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+            var s = bitwiseAnd(sendersAndCloseStatusCur, new (Long())(-1, 268435455));
+            var closed = _get_isClosedForSend0__kxgf9m(this, sendersAndCloseStatusCur);
+            // Inline function 'kotlin.Long.div' call
+            var other = get_SEGMENT_SIZE();
+            var id = divide(s, fromInt(other));
+            // Inline function 'kotlin.Long.rem' call
+            var other_0 = get_SEGMENT_SIZE();
+            var tmp$ret$2 = modulo(s, fromInt(other_0));
+            var i = convertToInt(tmp$ret$2);
+            if (!equalsLong(segment.t11_1, id)) {
+              var tmp0_elvis_lhs = findSegmentSend(this, id, segment);
+              var tmp;
+              if (tmp0_elvis_lhs == null) {
+                var tmp_0;
+                if (closed) {
+                  tmp$ret$4 = Companion_getInstance().x1b(this.z1a());
+                  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.q1a();
+                tmp$ret$4 = Companion_getInstance().e1b(Unit_instance);
+                break $l$block_4;
+              case 1:
+                tmp$ret$4 = Companion_getInstance().e1b(Unit_instance);
+                break $l$block_4;
+              case 2:
+                if (closed) {
+                  segment.g1a();
+                  tmp$ret$4 = Companion_getInstance().x1b(this.z1a());
+                  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.g1a();
+                tmp$ret$4 = Companion_getInstance().d1c();
+                break $l$block_4;
+              case 4:
+                if (compare(s, this.y1a()) < 0) {
+                  segment.q1a();
+                }
+
+                tmp$ret$4 = Companion_getInstance().x1b(this.z1a());
+                break $l$block_4;
+              case 5:
+                segment.q1a();
+                continue $l$loop_0;
+              case 3:
+                var message = 'unexpected';
+                throw IllegalStateException().o(toString_0(message));
+            }
+          }
+        }
+        return tmp$ret$4;
+      }
+      e1c(element) {
+        var tmp$ret$3;
+        // Inline function 'kotlinx.coroutines.channels.BufferedChannel.sendImpl' call
+        var waiter = get_BUFFERED();
+        var segment = this.y19_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          var sendersAndCloseStatusCur = this.u19_1.atomicfu$getAndIncrement$long();
+          // Inline function 'kotlinx.coroutines.channels.sendersCounter' call
+          var s = bitwiseAnd(sendersAndCloseStatusCur, new (Long())(-1, 268435455));
+          var closed = _get_isClosedForSend0__kxgf9m(this, sendersAndCloseStatusCur);
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(s, fromInt(other));
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$2 = modulo(s, fromInt(other_0));
+          var i = convertToInt(tmp$ret$2);
+          if (!equalsLong(segment.t11_1, id)) {
+            var tmp0_elvis_lhs = findSegmentSend(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var tmp_0;
+              if (closed) {
+                return Companion_getInstance().x1b(this.z1a());
+              } else {
+                continue $l$loop_0;
+              }
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          switch (updateCellSend(this, segment, i, element, s, waiter, closed)) {
+            case 0:
+              segment.q1a();
+              return Companion_getInstance().e1b(Unit_instance);
+            case 1:
+              return Companion_getInstance().e1b(Unit_instance);
+            case 2:
+              if (closed) {
+                segment.g1a();
+                return Companion_getInstance().x1b(this.z1a());
+              }
+
+              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.t11_1;
+              // Inline function 'kotlin.Long.times' call
+
+              var other_1 = get_SEGMENT_SIZE();
+              // Inline function 'kotlin.Long.plus' call
+
+              var this_0 = multiply(tmp0, fromInt(other_1));
+              var tmp$ret$5 = add(this_0, fromInt(i));
+              this.v1b(tmp$ret$5);
+              return Companion_getInstance().e1b(Unit_instance);
+            case 4:
+              if (compare(s, this.y1a()) < 0) {
+                segment.q1a();
+              }
+
+              return Companion_getInstance().x1b(this.z1a());
+            case 5:
+              segment.q1a();
+              continue $l$loop_0;
+            case 3:
+              var message = 'unexpected';
+              throw IllegalStateException().o(toString_0(message));
+          }
+        }
+        return tmp$ret$3;
+      }
+      h1b() {
+      }
+      a1b() {
+      }
+      f1c($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_receive__aoggq9.bind(VOID, this), $completion);
+      }
+      v1b(globalCellIndex) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        var segment = this.z19_1.kotlinx$atomicfu$value;
+        $l$loop_0: while (true) {
+          var r = this.v19_1.kotlinx$atomicfu$value;
+          // Inline function 'kotlin.Long.plus' call
+          var other = this.s19_1;
+          var tmp0 = add(r, fromInt(other));
+          // Inline function 'kotlin.math.max' call
+          var b = _get_bufferEndCounter__2d4hee(this);
+          var tmp$ret$2 = compare(tmp0, b) >= 0 ? tmp0 : b;
+          if (compare(globalCellIndex, tmp$ret$2) < 0)
+            return Unit_instance;
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$3 = add(r, fromInt(1));
+          if (!this.v19_1.atomicfu$compareAndSet(r, tmp$ret$3))
+            continue $l$loop_0;
+          // Inline function 'kotlin.Long.div' call
+          var other_0 = get_SEGMENT_SIZE();
+          var id = divide(r, fromInt(other_0));
+          // Inline function 'kotlin.Long.rem' call
+          var other_1 = get_SEGMENT_SIZE();
+          var tmp$ret$5 = modulo(r, fromInt(other_1));
+          var i = convertToInt(tmp$ret$5);
+          if (!equalsLong(segment.t11_1, id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              continue $l$loop_0;
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          var updCellResult = updateCellReceive(this, segment, i, r, null);
+          if (updCellResult === get_FAILED()) {
+            if (compare(r, this.w1a()) < 0) {
+              segment.q1a();
+            }
+          } else {
+            segment.q1a();
+            var tmp1_safe_receiver = this.t19_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;
+            }
+          }
+        }
+      }
+      f1a(globalIndex) {
+        if (_get_isRendezvousOrUnlimited__3mdufi(this))
+          return Unit_instance;
+        while (compare(_get_bufferEndCounter__2d4hee(this), 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 this_0 = this.x19_1.kotlinx$atomicfu$value;
+            var ebCompleted = bitwiseAnd(this_0, new (Long())(-1, 1073741823));
+            if (equalsLong(b, ebCompleted) && equalsLong(b, _get_bufferEndCounter__2d4hee(this)))
+              return Unit_instance;
+          }
+           while (inductionVariable < times);
+        var tmp0 = this.x19_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 = bitwiseAnd(cur, 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.x19_1.kotlinx$atomicfu$value;
+          // Inline function 'kotlinx.coroutines.channels.ebCompletedCounter' call
+          var ebCompleted_0 = bitwiseAnd(ebCompletedAndBit, new (Long())(-1, 1073741823));
+          // Inline function 'kotlinx.coroutines.channels.ebPauseExpandBuffers' call
+          var pauseExpandBuffers = !equalsLong(bitwiseAnd(ebCompletedAndBit, new (Long())(0, 1073741824)), new (Long())(0, 0));
+          if (equalsLong(b_0, ebCompleted_0) && equalsLong(b_0, _get_bufferEndCounter__2d4hee(this))) {
+            var tmp0_0 = this.x19_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 = bitwiseAnd(cur_0, 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.x19_1.atomicfu$compareAndSet(ebCompletedAndBit, constructEBCompletedAndPauseFlag(ebCompleted_0, true));
+          }
+        }
+      }
+      q1() {
+        return new (BufferedChannelIterator())(this);
+      }
+      x1a() {
+        var tmp = this.c1a_1.kotlinx$atomicfu$value;
+        return (tmp == null ? true : tmp instanceof Error) ? tmp : THROW_CCE();
+      }
+      z1a() {
+        var tmp0_elvis_lhs = this.x1a();
+        return tmp0_elvis_lhs == null ? ClosedSendChannelException().k1c('Channel was closed') : tmp0_elvis_lhs;
+      }
+      l1c() {
+      }
+      m1c(cause) {
+        return this.n1c(cause, false);
+      }
+      sx(cause) {
+        this.p1c(cause);
+      }
+      p1c(cause) {
+        return this.n1c(cause == null ? CancellationException().n('Channel was cancelled') : cause, true);
+      }
+      n1c(cause, cancel) {
+        if (cancel) {
+          markCancellationStarted(this);
+        }
+        var closedByThisOperation = this.c1a_1.atomicfu$compareAndSet(get_NO_CLOSE_CAUSE(), cause);
+        if (cancel) {
+          markCancelled(this);
+        } else {
+          markClosed(this);
+        }
+        completeCloseOrCancel(this);
+        // Inline function 'kotlin.also' call
+        this.l1c();
+        if (closedByThisOperation) {
+          invokeCloseHandler(this);
+        }
+        return closedByThisOperation;
+      }
+      w1b() {
+        return false;
+      }
+      u1b() {
+        return _get_isClosedForSend0__kxgf9m(this, this.u19_1.kotlinx$atomicfu$value);
+      }
+      v1a() {
+        return _get_isClosedForReceive0__f7qknl(this, this.u19_1.kotlinx$atomicfu$value);
+      }
+      y1b() {
+        $l$loop: while (true) {
+          var segment = this.z19_1.kotlinx$atomicfu$value;
+          var r = this.y1a();
+          var s = this.w1a();
+          if (compare(s, r) <= 0)
+            return false;
+          // Inline function 'kotlin.Long.div' call
+          var other = get_SEGMENT_SIZE();
+          var id = divide(r, fromInt(other));
+          if (!equalsLong(segment.t11_1, id)) {
+            var tmp0_elvis_lhs = findSegmentReceive(this, id, segment);
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var tmp_0;
+              if (compare(this.z19_1.kotlinx$atomicfu$value.t11_1, id) < 0) {
+                return false;
+              } else {
+                continue $l$loop;
+              }
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            segment = tmp;
+          }
+          segment.q1a();
+          // Inline function 'kotlin.Long.rem' call
+          var other_0 = get_SEGMENT_SIZE();
+          var tmp$ret$1 = modulo(r, fromInt(other_0));
+          var i = convertToInt(tmp$ret$1);
+          if (isCellNonEmpty(this, segment, i, r))
+            return true;
+          // Inline function 'kotlin.Long.plus' call
+          var tmp$ret$2 = add(r, fromInt(1));
+          this.v19_1.atomicfu$compareAndSet(r, tmp$ret$2);
+        }
+      }
+      toString() {
+        var sb = StringBuilder().m1();
+        // Inline function 'kotlinx.coroutines.channels.sendersCloseStatus' call
+        var this_0 = this.u19_1.kotlinx$atomicfu$value;
+        var tmp0_subject = convertToInt(shiftRight(this_0, 60));
+        if (tmp0_subject === 2) {
+          sb.n1('closed,');
+        } else if (tmp0_subject === 3) {
+          sb.n1('cancelled,');
+        }
+        sb.n1('capacity=' + this.s19_1 + ',');
+        sb.n1('data=[');
+        // Inline function 'kotlin.collections.filter' call
+        var tmp0 = listOf([this.z19_1.kotlinx$atomicfu$value, this.y19_1.kotlinx$atomicfu$value, this.a1a_1.kotlinx$atomicfu$value]);
+        // Inline function 'kotlin.collections.filterTo' call
+        var destination = ArrayList().n2();
+        var _iterator__ex2g4s = tmp0.q1();
+        while (_iterator__ex2g4s.r1()) {
+          var element = _iterator__ex2g4s.s1();
+          if (!(element === get_NULL_SEGMENT())) {
+            destination.t2(element);
+          }
+        }
+        var tmp$ret$4;
+        $l$block: {
+          // Inline function 'kotlin.collections.minBy' call
+          var iterator = destination.q1();
+          if (!iterator.r1())
+            throw NoSuchElementException().w6();
+          var minElem = iterator.s1();
+          if (!iterator.r1()) {
+            tmp$ret$4 = minElem;
+            break $l$block;
+          }
+          var minValue = minElem.t11_1;
+          do {
+            var e = iterator.s1();
+            var v = e.t11_1;
+            if (compareTo(minValue, v) > 0) {
+              minElem = e;
+              minValue = v;
+            }
+          }
+           while (iterator.r1());
+          tmp$ret$4 = minElem;
+        }
+        var firstSegment = tmp$ret$4;
+        var r = this.y1a();
+        var s = this.w1a();
+        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.t11_1;
+              // Inline function 'kotlin.Long.times' call
+              var other = get_SEGMENT_SIZE();
+              // Inline function 'kotlin.Long.plus' call
+              var this_1 = multiply(tmp0_0, fromInt(other));
+              var globalCellIndex = add(this_1, fromInt(i));
+              if (compare(globalCellIndex, s) >= 0 && compare(globalCellIndex, r) >= 0)
+                break append_elements;
+              var cellState = segment.o19(i);
+              var element_0 = segment.l19(i);
+              var tmp;
+              if (!(cellState == null) ? isInterface(cellState, CancellableContinuation()) : false) {
+                tmp = compare(globalCellIndex, r) < 0 && compare(globalCellIndex, s) >= 0 ? 'receive' : compare(globalCellIndex, s) < 0 && compare(globalCellIndex, r) >= 0 ? 'send' : 'cont';
+              } else {
+                if (!(cellState == null) ? isInterface(cellState, SelectInstance()) : false) {
+                  tmp = compare(globalCellIndex, r) < 0 && compare(globalCellIndex, s) >= 0 ? 'onReceive' : compare(globalCellIndex, s) < 0 && compare(globalCellIndex, 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.n1('(' + cellStateString + ',' + toString(element_0) + '),');
+              } else {
+                sb.n1(cellStateString + ',');
+              }
+            }
+             while (inductionVariable < last_0);
+          var tmp2_elvis_lhs = segment.m1a();
+          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.ih(sb.a() - 1 | 0);
+        }
+        sb.n1(']');
+        return sb.toString();
+      }
+    }
+    protoOf($).o1c = close$default;
+    protoOf($).q1c = cancel$default;
+    initMetadataForClass($, 'BufferedChannel', VOID, VOID, [ReceiveChannel(), SendChannel()], [1, 4, 0, 3]);
+    BufferedChannelClass = $;
+  }
+  return BufferedChannelClass;
+}
+var WaiterEBClass;
+function WaiterEB() {
+  if (WaiterEBClass === VOID) {
+    class $ {
+      constructor(waiter) {
+        this.b1b_1 = waiter;
+      }
+      toString() {
+        return 'WaiterEB(' + toString_0(this.b1b_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 fromInt(capacity);
+  }
+}
+var ReceiveCatchingClass;
+function ReceiveCatching() {
+  if (ReceiveCatchingClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'ReceiveCatching', VOID, VOID, [Waiter()]);
+    ReceiveCatchingClass = $;
+  }
+  return ReceiveCatchingClass;
+}
+function tryResume0(_this__u8e3s4, value, onCancellation) {
+  onCancellation = onCancellation === VOID ? null : onCancellation;
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  // Inline function 'kotlin.let' call
+  var token = _this__u8e3s4.a11(value, null, onCancellation);
+  var tmp;
+  if (!(token == null)) {
+    _this__u8e3s4.gz(token);
+    tmp = true;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function constructEBCompletedAndPauseFlag(counter, pauseEB) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return add(pauseEB ? new (Long())(0, 1073741824) : new (Long())(0, 0), counter);
+}
+function constructSendersAndCloseStatus(counter, closeStatus) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return add(shiftLeft(fromInt(closeStatus), 60), counter);
+}
+function createSegmentFunction() {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return createSegment$ref();
+}
+function createSegment(id, prev) {
+  _init_properties_BufferedChannel_kt__d6uc4y();
+  return new (ChannelSegment())(id, prev, prev.i19(), 0);
+}
+function createSegment$ref() {
+  var l = (p0, p1) => createSegment(p0, p1);
+  l.callableName = 'createSegment';
+  return l;
+}
+var properties_initialized_BufferedChannel_kt_58tjvw;
+function _init_properties_BufferedChannel_kt__d6uc4y() {
+  if (!properties_initialized_BufferedChannel_kt_58tjvw) {
+    properties_initialized_BufferedChannel_kt_58tjvw = true;
+    NULL_SEGMENT = new (ChannelSegment())(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