@zenwave360/json-schema-ref-parser-kmp 1.0.0-next.0

package/kotlin/kotlinx-coroutines-core.mjs

@@ -0,0 +1,3549 @@
+import {
+  Unit_instance1fbcbse1fwigr as Unit_instance,
+  protoOf180f3jzyo7rfj as protoOf,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  Element2gr7ezmxqaln7 as Element,
+  Continuation1aa2oekvx7jm7 as Continuation,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  VOID3gxj6tk5isa35 as VOID,
+  EmptyCoroutineContext_getInstance31fow51ayy30t as EmptyCoroutineContext_getInstance,
+  createCoroutineUnintercepted3gya308dmbbtg as createCoroutineUnintercepted,
+  isInterface3d6p8outrmvmk as isInterface,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$2w9444nebyjns as IllegalStateException_init_$Create$,
+  toString30pk9tzaqopn as toString_0,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  CancellationException_init_$Create$2cv5nayrc39hr as CancellationException_init_$Create$,
+  Result__exceptionOrNull_impl_p6xea9ty3elzpd9eo3 as Result__exceptionOrNull_impl_p6xea9,
+  _Result___get_value__impl__bjfvqg2ei4op8d4d2m as _Result___get_value__impl__bjfvqg,
+  AbstractCoroutineContextKey9xr9r6wlj5bm as AbstractCoroutineContextKey,
+  Key_instance17k9ki7fvysxq as Key_instance,
+  AbstractCoroutineContextElement2rpehg0hv5szw as AbstractCoroutineContextElement,
+  getxe4seun860fg as get,
+  minusKey2uxs00uz5ceqp as minusKey,
+  ContinuationInterceptor2624y0vaqwxwf as ContinuationInterceptor,
+  RuntimeException_init_$Create$518iyh59wo54 as RuntimeException_init_$Create$,
+  addSuppressedu5jwjfvsc039 as addSuppressed,
+  Enum3alwj03lh1n41 as Enum,
+  startCoroutine327fwvtqvedik as startCoroutine,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  Long2qws0ah9gnpki as Long,
+  ArrayDeque_init_$Create$2333dl090ltjt as ArrayDeque_init_$Create$,
+  compare2uud5j30pw5xc as compare,
+  add85si75olwt6n as add,
+  subtract16cg4lfi29fq9 as subtract,
+  RuntimeException1r3t0zl97011n as RuntimeException,
+  RuntimeException_init_$Init$3m7ccek2krm3f as RuntimeException_init_$Init$,
+  captureStack1fzi4aczwc4hg as captureStack,
+  Error3ofk6owajcepa as Error_0,
+  Error_init_$Init$17pe7jtgoh3ll as Error_init_$Init$,
+  StringBuilder_init_$Create$2qsge4ydj6bin as StringBuilder_init_$Create$,
+  throwUninitializedPropertyAccessExceptionyynx7gkm73wd as throwUninitializedPropertyAccessException,
+  ArrayList_init_$Create$3bxttkj3v1mea as ArrayList_init_$Create$,
+  CancellationException3b36o9qz53rgr as CancellationException,
+  ArrayList3it5z8td81qkl as ArrayList,
+  IllegalStateException_init_$Create$12oloagvd20rx as IllegalStateException_init_$Create$_0,
+  plusolev77jfy5r9 as plus,
+  get6d5x931vk0s as get_0,
+  fold36i9psb7d5v48 as fold,
+  minusKeyyqanvso9aovh as minusKey_0,
+  anyToString3ho3k49fc56mj as anyToString,
+  UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException,
+  UnsupportedOperationException_init_$Create$1pe732c4s59hc as UnsupportedOperationException_init_$Create$,
+  Exceptiondt2hlxn7j7vw as Exception,
+  IllegalArgumentException_init_$Create$3ewkh27kzt8z8 as IllegalArgumentException_init_$Create$,
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  createFailure8paxfkfa5dc7 as createFailure,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  Exception_init_$Init$393utbttlf2x4 as Exception_init_$Init$,
+  defineProp3ur6h3slcvq4x as defineProp,
+  intercepted2ogpsikxxj4u0 as intercepted,
+  startCoroutineUninterceptedOrReturnNonGeneratorVersionyfrrvzbtl8bf as startCoroutineUninterceptedOrReturnNonGeneratorVersion,
+  getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression,
+  Exception_init_$Create$becl18oowirz as Exception_init_$Create$,
+  CancellationException_init_$Init$1ieejj57c468h as CancellationException_init_$Init$,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  HashSet_init_$Create$1almu45bw06ne as HashSet_init_$Create$,
+  RuntimeException_init_$Init$1tdhpyy2sm4eb as RuntimeException_init_$Init$_0,
+  LinkedHashSet_init_$Create$3o6z3oewjhki9 as LinkedHashSet_init_$Create$,
+  stackTraceToString2670q6lbhdojj as stackTraceToString,
+  removeFirstOrNull15yg2tczrh8a7 as removeFirstOrNull,
+  KtMutableList1beimitadwkna as KtMutableList,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  atomic$int$11d5swdyn6j0pu as atomic$int$1,
+  atomic$ref$130aurmcwdfdf1 as atomic$ref$1,
+  atomic$boolean$1iggki4z65a2h as atomic$boolean$1,
+} from './kotlinx-atomicfu.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+initMetadataForInterface(ParentJob, 'ParentJob', VOID, VOID, [Element], [0]);
+initMetadataForClass(JobSupport, 'JobSupport', VOID, VOID, [Element, ParentJob], [0]);
+initMetadataForInterface(CoroutineScope, 'CoroutineScope');
+initMetadataForClass(AbstractCoroutine, 'AbstractCoroutine', VOID, JobSupport, [JobSupport, Element, Continuation, CoroutineScope], [0]);
+initMetadataForClass(DeferredCoroutine, 'DeferredCoroutine', VOID, AbstractCoroutine, [AbstractCoroutine, Element], [0]);
+initMetadataForClass(LazyDeferredCoroutine, 'LazyDeferredCoroutine', VOID, DeferredCoroutine, VOID, [0]);
+initMetadataForInterface(Runnable, 'Runnable');
+initMetadataForClass(SchedulerTask, 'SchedulerTask', VOID, VOID, [Runnable]);
+initMetadataForClass(DispatchedTask, 'DispatchedTask', VOID, SchedulerTask);
+initMetadataForClass(CancellableContinuationImpl, 'CancellableContinuationImpl', VOID, DispatchedTask, [DispatchedTask, Continuation]);
+initMetadataForInterface(NotCompleted, 'NotCompleted');
+initMetadataForInterface(CancelHandler, 'CancelHandler', VOID, VOID, [NotCompleted]);
+initMetadataForObject(Active, 'Active', VOID, VOID, [NotCompleted]);
+initMetadataForClass(CompletedContinuation, 'CompletedContinuation');
+initMetadataForClass(LockFreeLinkedListNode, 'LockFreeLinkedListNode', LockFreeLinkedListNode);
+initMetadataForInterface(Incomplete, 'Incomplete');
+initMetadataForClass(JobNode, 'JobNode', VOID, LockFreeLinkedListNode, [LockFreeLinkedListNode, Incomplete]);
+initMetadataForClass(ChildContinuation, 'ChildContinuation', VOID, JobNode);
+initMetadataForClass(CompletedExceptionally, 'CompletedExceptionally');
+initMetadataForClass(CancelledContinuation, 'CancelledContinuation', VOID, CompletedExceptionally);
+initMetadataForObject(Key, 'Key', VOID, AbstractCoroutineContextKey);
+initMetadataForClass(CoroutineDispatcher, 'CoroutineDispatcher', VOID, AbstractCoroutineContextElement, [AbstractCoroutineContextElement, ContinuationInterceptor]);
+initMetadataForObject(Key_0, 'Key');
+initMetadataForObject(GlobalScope, 'GlobalScope', VOID, VOID, [CoroutineScope]);
+initMetadataForClass(CoroutineStart, 'CoroutineStart', VOID, Enum);
+initMetadataForClass(EventLoop, 'EventLoop', VOID, CoroutineDispatcher);
+initMetadataForObject(ThreadLocalEventLoop, 'ThreadLocalEventLoop');
+initMetadataForClass(CompletionHandlerException, 'CompletionHandlerException', VOID, RuntimeException);
+initMetadataForClass(CoroutinesInternalError, 'CoroutinesInternalError', VOID, Error_0);
+initMetadataForObject(Key_1, 'Key');
+initMetadataForObject(NonDisposableHandle, 'NonDisposableHandle');
+initMetadataForClass(Empty, 'Empty', VOID, VOID, [Incomplete]);
+initMetadataForClass(LockFreeLinkedListHead, 'LockFreeLinkedListHead', LockFreeLinkedListHead, LockFreeLinkedListNode);
+initMetadataForClass(NodeList, 'NodeList', NodeList, LockFreeLinkedListHead, [LockFreeLinkedListHead, Incomplete]);
+initMetadataForClass(SynchronizedObject, 'SynchronizedObject', SynchronizedObject);
+initMetadataForClass(Finishing, 'Finishing', VOID, SynchronizedObject, [SynchronizedObject, Incomplete]);
+initMetadataForClass(ChildCompletion, 'ChildCompletion', VOID, JobNode);
+initMetadataForClass(InactiveNodeList, 'InactiveNodeList', VOID, VOID, [Incomplete]);
+initMetadataForClass(InvokeOnCompletion, 'InvokeOnCompletion', VOID, JobNode);
+initMetadataForClass(InvokeOnCancelling, 'InvokeOnCancelling', VOID, JobNode);
+initMetadataForClass(ChildHandleNode, 'ChildHandleNode', VOID, JobNode);
+initMetadataForClass(IncompleteStateBox, 'IncompleteStateBox');
+initMetadataForClass(MainCoroutineDispatcher, 'MainCoroutineDispatcher', VOID, CoroutineDispatcher);
+initMetadataForClass(TimeoutCancellationException, 'TimeoutCancellationException', VOID, CancellationException);
+initMetadataForObject(Unconfined, 'Unconfined', VOID, CoroutineDispatcher);
+initMetadataForObject(Key_2, 'Key');
+initMetadataForClass(ConcurrentLinkedListNode, 'ConcurrentLinkedListNode');
+initMetadataForClass(Segment, 'Segment', VOID, ConcurrentLinkedListNode, [ConcurrentLinkedListNode, NotCompleted]);
+initMetadataForObject(ExceptionSuccessfullyProcessed, 'ExceptionSuccessfullyProcessed', VOID, Exception);
+initMetadataForClass(DispatchedContinuation, 'DispatchedContinuation', VOID, DispatchedTask, [DispatchedTask, Continuation]);
+initMetadataForClass(DispatchException, 'DispatchException', VOID, Exception);
+initMetadataForClass(Symbol, 'Symbol');
+initMetadataForClass(SetTimeoutBasedDispatcher, 'SetTimeoutBasedDispatcher', VOID, CoroutineDispatcher, VOID, [1]);
+initMetadataForObject(NodeDispatcher, 'NodeDispatcher', VOID, SetTimeoutBasedDispatcher, VOID, [1]);
+initMetadataForClass(MessageQueue, 'MessageQueue', VOID, VOID, [KtMutableList]);
+initMetadataForClass(ScheduledMessageQueue, 'ScheduledMessageQueue', VOID, MessageQueue);
+initMetadataForClass(WindowMessageQueue, 'WindowMessageQueue', VOID, MessageQueue);
+initMetadataForObject(Dispatchers, 'Dispatchers');
+initMetadataForClass(JsMainDispatcher, 'JsMainDispatcher', VOID, MainCoroutineDispatcher);
+initMetadataForClass(JobCancellationException, 'JobCancellationException', VOID, CancellationException);
+initMetadataForClass(DiagnosticCoroutineContextException, 'DiagnosticCoroutineContextException', VOID, RuntimeException);
+initMetadataForClass(ListClosed, 'ListClosed', VOID, LockFreeLinkedListNode);
+initMetadataForClass(CommonThreadLocal, 'CommonThreadLocal', CommonThreadLocal);
+initMetadataForClass(UnconfinedEventLoop, 'UnconfinedEventLoop', UnconfinedEventLoop, EventLoop);
+initMetadataForObject(SetTimeoutDispatcher, 'SetTimeoutDispatcher', VOID, SetTimeoutBasedDispatcher, VOID, [1]);
+initMetadataForClass(WindowDispatcher, 'WindowDispatcher', VOID, CoroutineDispatcher, VOID, [1]);
+//endregion
+function AbstractCoroutine(parentContext, initParentJob, active) {
+  JobSupport.call(this, active);
+  if (initParentJob) {
+    this.px(parentContext.h7(Key_instance_2));
+  }
+  this.sx_1 = parentContext.ob(this);
+}
+protoOf(AbstractCoroutine).a7 = function () {
+  return this.sx_1;
+};
+protoOf(AbstractCoroutine).tx = function () {
+  return this.sx_1;
+};
+protoOf(AbstractCoroutine).ux = function () {
+  return protoOf(JobSupport).ux.call(this);
+};
+protoOf(AbstractCoroutine).vx = function (value) {
+};
+protoOf(AbstractCoroutine).wx = function (cause, handled) {
+};
+protoOf(AbstractCoroutine).xx = function () {
+  return get_classSimpleName(this) + ' was cancelled';
+};
+protoOf(AbstractCoroutine).yx = function (state) {
+  if (state instanceof CompletedExceptionally) {
+    this.wx(state.zx_1, state.by());
+  } else {
+    this.vx((state == null ? true : !(state == null)) ? state : THROW_CCE());
+  }
+};
+protoOf(AbstractCoroutine).f7 = function (result) {
+  var state = this.cy(toState_0(result));
+  if (state === get_COMPLETING_WAITING_CHILDREN())
+    return Unit_instance;
+  this.dy(state);
+};
+protoOf(AbstractCoroutine).dy = function (state) {
+  return this.ey(state);
+};
+protoOf(AbstractCoroutine).fy = function (exception) {
+  handleCoroutineException(this.sx_1, exception);
+};
+protoOf(AbstractCoroutine).gy = function () {
+  var tmp0_elvis_lhs = get_coroutineName(this.sx_1);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return protoOf(JobSupport).gy.call(this);
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var coroutineName = tmp;
+  return '"' + coroutineName + '":' + protoOf(JobSupport).gy.call(this);
+};
+protoOf(AbstractCoroutine).hy = function (start, receiver, block) {
+  start.ky(block, receiver, this);
+};
+function async(_this__u8e3s4, context, start, block) {
+  context = context === VOID ? EmptyCoroutineContext_getInstance() : context;
+  start = start === VOID ? CoroutineStart_DEFAULT_getInstance() : start;
+  var newContext = newCoroutineContext(_this__u8e3s4, context);
+  var coroutine = start.lz() ? new LazyDeferredCoroutine(newContext, block) : new DeferredCoroutine(newContext, true);
+  coroutine.hy(start, coroutine, block);
+  return coroutine;
+}
+function DeferredCoroutine(parentContext, active) {
+  AbstractCoroutine.call(this, parentContext, true, active);
+}
+protoOf(DeferredCoroutine).pz = function () {
+  var tmp = this.kz();
+  return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+};
+function LazyDeferredCoroutine(parentContext, block) {
+  DeferredCoroutine.call(this, parentContext, false);
+  this.tz_1 = createCoroutineUnintercepted(block, this, this);
+}
+protoOf(LazyDeferredCoroutine).qy = function () {
+  startCoroutineCancellable_0(this.tz_1, this);
+};
+function _get_parentHandle__f8dcex($this) {
+  return $this.zz_1.kotlinx$atomicfu$value;
+}
+function _get_stateDebugRepresentation__bf18u4($this) {
+  var tmp0_subject = $this.ny();
+  var tmp;
+  if (!(tmp0_subject == null) ? isInterface(tmp0_subject, NotCompleted) : false) {
+    tmp = 'Active';
+  } else {
+    if (tmp0_subject instanceof CancelledContinuation) {
+      tmp = 'Cancelled';
+    } else {
+      tmp = 'Completed';
+    }
+  }
+  return tmp;
+}
+function isReusable($this) {
+  var tmp;
+  if (get_isReusableMode($this.h10_1)) {
+    var tmp_0 = $this.vz_1;
+    tmp = (tmp_0 instanceof DispatchedContinuation ? tmp_0 : THROW_CCE()).g10();
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function cancelLater($this, cause) {
+  if (!isReusable($this))
+    return false;
+  var tmp = $this.vz_1;
+  var dispatched = tmp instanceof DispatchedContinuation ? tmp : THROW_CCE();
+  return dispatched.i10(cause);
+}
+function callSegmentOnCancellation($this, segment, cause) {
+  // Inline function 'kotlinx.coroutines.index' call
+  var index = $this.xz_1.kotlinx$atomicfu$value & 536870911;
+  // Inline function 'kotlin.check' call
+  if (!!(index === 536870911)) {
+    var message = 'The index for Segment.onCancellation(..) is broken';
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlinx.coroutines.CancellableContinuationImpl.callCancelHandlerSafely' call
+  try {
+    segment.j10(index, cause, $this.a7());
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var ex = $p;
+      handleCoroutineException($this.a7(), new CompletionHandlerException('Exception in invokeOnCancellation handler for ' + $this.toString(), ex));
+    } else {
+      throw $p;
+    }
+  }
+}
+function trySuspend($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.xz_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.decision' call
+    switch (cur >> 29) {
+      case 0:
+        // Inline function 'kotlinx.coroutines.index' call
+
+        // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+
+        var tmp$ret$2 = (1 << 29) + (cur & 536870911) | 0;
+        if ($this.xz_1.atomicfu$compareAndSet(cur, tmp$ret$2))
+          return true;
+        break;
+      case 2:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already suspended';
+        throw IllegalStateException_init_$Create$(toString(message));
+    }
+  }
+}
+function tryResume($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.xz_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.decision' call
+    switch (cur >> 29) {
+      case 0:
+        // Inline function 'kotlinx.coroutines.index' call
+
+        // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+
+        var tmp$ret$2 = (2 << 29) + (cur & 536870911) | 0;
+        if ($this.xz_1.atomicfu$compareAndSet(cur, tmp$ret$2))
+          return true;
+        break;
+      case 1:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already resumed';
+        throw IllegalStateException_init_$Create$(toString(message));
+    }
+  }
+}
+function installParentHandle($this) {
+  var tmp0_elvis_lhs = $this.a7().h7(Key_instance_2);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var parent = tmp;
+  var handle = invokeOnCompletion(parent, VOID, new ChildContinuation($this));
+  $this.zz_1.atomicfu$compareAndSet(null, handle);
+  return handle;
+}
+function dispatchResume($this, mode) {
+  if (tryResume($this))
+    return Unit_instance;
+  dispatch($this, mode);
+}
+function resumedState($this, state, proposedUpdate, resumeMode, onCancellation, idempotent) {
+  var tmp;
+  if (proposedUpdate instanceof CompletedExceptionally) {
+    // Inline function 'kotlinx.coroutines.assert' call
+    // Inline function 'kotlinx.coroutines.assert' call
+    tmp = proposedUpdate;
+  } else {
+    if (!get_isCancellableMode(resumeMode) && idempotent == null) {
+      tmp = proposedUpdate;
+    } else {
+      var tmp_0;
+      var tmp_1;
+      if (!(onCancellation == null)) {
+        tmp_1 = true;
+      } else {
+        tmp_1 = isInterface(state, CancelHandler);
+      }
+      if (tmp_1) {
+        tmp_0 = true;
+      } else {
+        tmp_0 = !(idempotent == null);
+      }
+      if (tmp_0) {
+        tmp = new CompletedContinuation(proposedUpdate, isInterface(state, CancelHandler) ? state : null, onCancellation, idempotent);
+      } else {
+        tmp = proposedUpdate;
+      }
+    }
+  }
+  return tmp;
+}
+function alreadyResumedError($this, proposedUpdate) {
+  // Inline function 'kotlin.error' call
+  var message = 'Already resumed, but proposed with update ' + toString_0(proposedUpdate);
+  throw IllegalStateException_init_$Create$(toString(message));
+}
+function detachChildIfNonReusable($this) {
+  if (!isReusable($this)) {
+    $this.k10();
+  }
+}
+function CancellableContinuationImpl(delegate, resumeMode) {
+  DispatchedTask.call(this, resumeMode);
+  this.vz_1 = delegate;
+  // Inline function 'kotlinx.coroutines.assert' call
+  this.wz_1 = this.vz_1.a7();
+  var tmp = this;
+  // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+  var tmp$ret$1 = (0 << 29) + 536870911 | 0;
+  tmp.xz_1 = atomic$int$1(tmp$ret$1);
+  this.yz_1 = atomic$ref$1(Active_instance);
+  this.zz_1 = atomic$ref$1(null);
+}
+protoOf(CancellableContinuationImpl).l10 = function () {
+  return this.vz_1;
+};
+protoOf(CancellableContinuationImpl).a7 = function () {
+  return this.wz_1;
+};
+protoOf(CancellableContinuationImpl).ny = function () {
+  return this.yz_1.kotlinx$atomicfu$value;
+};
+protoOf(CancellableContinuationImpl).oy = function () {
+  var tmp = this.ny();
+  return !(!(tmp == null) ? isInterface(tmp, NotCompleted) : false);
+};
+protoOf(CancellableContinuationImpl).m10 = function () {
+  var tmp0_elvis_lhs = installParentHandle(this);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return Unit_instance;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var handle = tmp;
+  if (this.oy()) {
+    handle.n10();
+    this.zz_1.kotlinx$atomicfu$value = NonDisposableHandle_instance;
+  }
+};
+protoOf(CancellableContinuationImpl).o10 = function () {
+  return this.ny();
+};
+protoOf(CancellableContinuationImpl).p10 = function (takenState, cause) {
+  var this_0 = this.yz_1;
+  while (true) {
+    var state = this_0.kotlinx$atomicfu$value;
+    if (!(state == null) ? isInterface(state, NotCompleted) : false) {
+      // Inline function 'kotlin.error' call
+      var message = 'Not completed';
+      throw IllegalStateException_init_$Create$(toString(message));
+    } else {
+      if (state instanceof CompletedExceptionally)
+        return Unit_instance;
+      else {
+        if (state instanceof CompletedContinuation) {
+          // Inline function 'kotlin.check' call
+          if (!!state.v10()) {
+            var message_0 = 'Must be called at most once';
+            throw IllegalStateException_init_$Create$(toString(message_0));
+          }
+          var update = state.w10(VOID, VOID, VOID, VOID, cause);
+          if (this.yz_1.atomicfu$compareAndSet(state, update)) {
+            state.x10(this, cause);
+            return Unit_instance;
+          }
+        } else {
+          if (this.yz_1.atomicfu$compareAndSet(state, new CompletedContinuation(state, VOID, VOID, VOID, cause))) {
+            return Unit_instance;
+          }
+        }
+      }
+    }
+  }
+  return Unit_instance;
+};
+protoOf(CancellableContinuationImpl).y10 = function (cause) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = this.yz_1;
+  while (true) {
+    var tmp0 = this_0.kotlinx$atomicfu$value;
+    $l$block: {
+      if (!(!(tmp0 == null) ? isInterface(tmp0, NotCompleted) : false))
+        return false;
+      var tmp;
+      if (isInterface(tmp0, CancelHandler)) {
+        tmp = true;
+      } else {
+        tmp = tmp0 instanceof Segment;
+      }
+      var update = new CancelledContinuation(this, cause, tmp);
+      if (!this.yz_1.atomicfu$compareAndSet(tmp0, update)) {
+        break $l$block;
+      }
+      if (isInterface(tmp0, CancelHandler)) {
+        this.z10(tmp0, cause);
+      } else {
+        if (tmp0 instanceof Segment) {
+          callSegmentOnCancellation(this, tmp0, cause);
+        }
+      }
+      detachChildIfNonReusable(this);
+      dispatchResume(this, this.h10_1);
+      return true;
+    }
+  }
+};
+protoOf(CancellableContinuationImpl).a11 = function (cause) {
+  if (cancelLater(this, cause))
+    return Unit_instance;
+  this.y10(cause);
+  detachChildIfNonReusable(this);
+};
+protoOf(CancellableContinuationImpl).z10 = function (handler, cause) {
+  // Inline function 'kotlinx.coroutines.CancellableContinuationImpl.callCancelHandlerSafely' call
+  try {
+    handler.b11(cause);
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var ex = $p;
+      handleCoroutineException(this.a7(), new CompletionHandlerException('Exception in invokeOnCancellation handler for ' + this.toString(), ex));
+    } else {
+      throw $p;
+    }
+  }
+  return Unit_instance;
+};
+protoOf(CancellableContinuationImpl).c11 = function (onCancellation, cause, value) {
+  try {
+    onCancellation(cause, value, this.a7());
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var ex = $p;
+      handleCoroutineException(this.a7(), new CompletionHandlerException('Exception in resume onCancellation handler for ' + this.toString(), ex));
+    } else {
+      throw $p;
+    }
+  }
+};
+protoOf(CancellableContinuationImpl).d11 = function (parent) {
+  return parent.ry();
+};
+protoOf(CancellableContinuationImpl).e11 = function () {
+  var isReusable_0 = isReusable(this);
+  if (trySuspend(this)) {
+    if (_get_parentHandle__f8dcex(this) == null) {
+      installParentHandle(this);
+    }
+    if (isReusable_0) {
+      this.f11();
+    }
+    return get_COROUTINE_SUSPENDED();
+  }
+  if (isReusable_0) {
+    this.f11();
+  }
+  var state = this.ny();
+  if (state instanceof CompletedExceptionally)
+    throw recoverStackTrace(state.zx_1, this);
+  if (get_isCancellableMode(this.h10_1)) {
+    var job = this.a7().h7(Key_instance_2);
+    if (!(job == null) && !job.ux()) {
+      var cause = job.ry();
+      this.p10(state, cause);
+      throw recoverStackTrace(cause, this);
+    }
+  }
+  return this.g11(state);
+};
+protoOf(CancellableContinuationImpl).f11 = function () {
+  var tmp = this.vz_1;
+  var tmp0_safe_receiver = tmp instanceof DispatchedContinuation ? tmp : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.h11(this);
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    return Unit_instance;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var cancellationCause = tmp_0;
+  this.k10();
+  this.y10(cancellationCause);
+};
+protoOf(CancellableContinuationImpl).f7 = function (result) {
+  return this.i11(toState(result, this), this.h10_1);
+};
+protoOf(CancellableContinuationImpl).j11 = function (proposedUpdate, resumeMode, onCancellation) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = this.yz_1;
+  while (true) {
+    var tmp0 = this_0.kotlinx$atomicfu$value;
+    $l$block: {
+      if (!(tmp0 == null) ? isInterface(tmp0, NotCompleted) : false) {
+        var update = resumedState(this, tmp0, proposedUpdate, resumeMode, onCancellation, null);
+        if (!this.yz_1.atomicfu$compareAndSet(tmp0, update)) {
+          break $l$block;
+        }
+        detachChildIfNonReusable(this);
+        dispatchResume(this, resumeMode);
+        return Unit_instance;
+      } else {
+        if (tmp0 instanceof CancelledContinuation) {
+          if (tmp0.n11()) {
+            if (onCancellation == null)
+              null;
+            else {
+              // Inline function 'kotlin.let' call
+              this.c11(onCancellation, tmp0.zx_1, proposedUpdate);
+            }
+            return Unit_instance;
+          }
+        }
+      }
+      alreadyResumedError(this, proposedUpdate);
+    }
+  }
+};
+protoOf(CancellableContinuationImpl).i11 = function (proposedUpdate, resumeMode, onCancellation, $super) {
+  onCancellation = onCancellation === VOID ? null : onCancellation;
+  var tmp;
+  if ($super === VOID) {
+    this.j11(proposedUpdate, resumeMode, onCancellation);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.j11.call(this, proposedUpdate, resumeMode, onCancellation);
+  }
+  return tmp;
+};
+protoOf(CancellableContinuationImpl).k10 = function () {
+  var tmp0_elvis_lhs = _get_parentHandle__f8dcex(this);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return Unit_instance;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var handle = tmp;
+  handle.n10();
+  this.zz_1.kotlinx$atomicfu$value = NonDisposableHandle_instance;
+};
+protoOf(CancellableContinuationImpl).g11 = function (state) {
+  var tmp;
+  if (state instanceof CompletedContinuation) {
+    var tmp_0 = state.q10_1;
+    tmp = (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+  } else {
+    tmp = (state == null ? true : !(state == null)) ? state : THROW_CCE();
+  }
+  return tmp;
+};
+protoOf(CancellableContinuationImpl).o11 = function (state) {
+  var tmp0_safe_receiver = protoOf(DispatchedTask).o11.call(this, state);
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    tmp = recoverStackTrace(tmp0_safe_receiver, this.vz_1);
+  }
+  return tmp;
+};
+protoOf(CancellableContinuationImpl).toString = function () {
+  return this.p11() + '(' + toDebugString(this.vz_1) + '){' + _get_stateDebugRepresentation__bf18u4(this) + '}@' + get_hexAddress(this);
+};
+protoOf(CancellableContinuationImpl).p11 = function () {
+  return 'CancellableContinuation';
+};
+function NotCompleted() {
+}
+function CancelHandler() {
+}
+function Active() {
+}
+protoOf(Active).toString = function () {
+  return 'Active';
+};
+var Active_instance;
+function Active_getInstance() {
+  return Active_instance;
+}
+function CompletedContinuation(result, cancelHandler, onCancellation, idempotentResume, cancelCause) {
+  cancelHandler = cancelHandler === VOID ? null : cancelHandler;
+  onCancellation = onCancellation === VOID ? null : onCancellation;
+  idempotentResume = idempotentResume === VOID ? null : idempotentResume;
+  cancelCause = cancelCause === VOID ? null : cancelCause;
+  this.q10_1 = result;
+  this.r10_1 = cancelHandler;
+  this.s10_1 = onCancellation;
+  this.t10_1 = idempotentResume;
+  this.u10_1 = cancelCause;
+}
+protoOf(CompletedContinuation).v10 = function () {
+  return !(this.u10_1 == null);
+};
+protoOf(CompletedContinuation).x10 = function (cont, cause) {
+  var tmp0_safe_receiver = this.r10_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    cont.z10(tmp0_safe_receiver, cause);
+  }
+  var tmp1_safe_receiver = this.s10_1;
+  if (tmp1_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    cont.c11(tmp1_safe_receiver, cause, this.q10_1);
+  }
+};
+protoOf(CompletedContinuation).s11 = function (result, cancelHandler, onCancellation, idempotentResume, cancelCause) {
+  return new CompletedContinuation(result, cancelHandler, onCancellation, idempotentResume, cancelCause);
+};
+protoOf(CompletedContinuation).w10 = function (result, cancelHandler, onCancellation, idempotentResume, cancelCause, $super) {
+  result = result === VOID ? this.q10_1 : result;
+  cancelHandler = cancelHandler === VOID ? this.r10_1 : cancelHandler;
+  onCancellation = onCancellation === VOID ? this.s10_1 : onCancellation;
+  idempotentResume = idempotentResume === VOID ? this.t10_1 : idempotentResume;
+  cancelCause = cancelCause === VOID ? this.u10_1 : cancelCause;
+  return $super === VOID ? this.s11(result, cancelHandler, onCancellation, idempotentResume, cancelCause) : $super.s11.call(this, result, cancelHandler, onCancellation, idempotentResume, cancelCause);
+};
+protoOf(CompletedContinuation).toString = function () {
+  return 'CompletedContinuation(result=' + toString_0(this.q10_1) + ', cancelHandler=' + toString_0(this.r10_1) + ', onCancellation=' + toString_0(this.s10_1) + ', idempotentResume=' + toString_0(this.t10_1) + ', cancelCause=' + toString_0(this.u10_1) + ')';
+};
+protoOf(CompletedContinuation).hashCode = function () {
+  var result = this.q10_1 == null ? 0 : hashCode(this.q10_1);
+  result = imul(result, 31) + (this.r10_1 == null ? 0 : hashCode(this.r10_1)) | 0;
+  result = imul(result, 31) + (this.s10_1 == null ? 0 : hashCode(this.s10_1)) | 0;
+  result = imul(result, 31) + (this.t10_1 == null ? 0 : hashCode(this.t10_1)) | 0;
+  result = imul(result, 31) + (this.u10_1 == null ? 0 : hashCode(this.u10_1)) | 0;
+  return result;
+};
+protoOf(CompletedContinuation).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof CompletedContinuation))
+    return false;
+  if (!equals(this.q10_1, other.q10_1))
+    return false;
+  if (!equals(this.r10_1, other.r10_1))
+    return false;
+  if (!equals(this.s10_1, other.s10_1))
+    return false;
+  if (!equals(this.t10_1, other.t10_1))
+    return false;
+  if (!equals(this.u10_1, other.u10_1))
+    return false;
+  return true;
+};
+function ChildContinuation(child) {
+  JobNode.call(this);
+  this.x11_1 = child;
+}
+protoOf(ChildContinuation).y11 = function () {
+  return true;
+};
+protoOf(ChildContinuation).b11 = function (cause) {
+  this.x11_1.a11(this.x11_1.d11(this.d12()));
+};
+function CompletedExceptionally(cause, handled) {
+  handled = handled === VOID ? false : handled;
+  this.zx_1 = cause;
+  this.ay_1 = atomic$boolean$1(handled);
+}
+protoOf(CompletedExceptionally).by = function () {
+  return this.ay_1.kotlinx$atomicfu$value;
+};
+protoOf(CompletedExceptionally).l12 = function () {
+  return this.ay_1.atomicfu$compareAndSet(false, true);
+};
+protoOf(CompletedExceptionally).toString = function () {
+  return get_classSimpleName(this) + '[' + this.zx_1.toString() + ']';
+};
+function CancelledContinuation(continuation, cause, handled) {
+  CompletedExceptionally.call(this, cause == null ? CancellationException_init_$Create$('Continuation ' + toString(continuation) + ' was cancelled normally') : cause, handled);
+  this.m11_1 = atomic$boolean$1(false);
+}
+protoOf(CancelledContinuation).n11 = function () {
+  return this.m11_1.atomicfu$compareAndSet(false, true);
+};
+function toState(_this__u8e3s4, caller) {
+  // Inline function 'kotlin.getOrElse' call
+  var exception = Result__exceptionOrNull_impl_p6xea9(_this__u8e3s4);
+  var tmp;
+  if (exception == null) {
+    var tmp_0 = _Result___get_value__impl__bjfvqg(_this__u8e3s4);
+    tmp = (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+  } else {
+    tmp = new CompletedExceptionally(recoverStackTrace(exception, caller));
+  }
+  return tmp;
+}
+function toState_0(_this__u8e3s4) {
+  // Inline function 'kotlin.getOrElse' call
+  var exception = Result__exceptionOrNull_impl_p6xea9(_this__u8e3s4);
+  var tmp;
+  if (exception == null) {
+    var tmp_0 = _Result___get_value__impl__bjfvqg(_this__u8e3s4);
+    tmp = (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+  } else {
+    tmp = new CompletedExceptionally(exception);
+  }
+  return tmp;
+}
+function CoroutineDispatcher$Key$_init_$lambda_akl8b5(it) {
+  return it instanceof CoroutineDispatcher ? it : null;
+}
+function Key() {
+  Key_instance_0 = this;
+  var tmp = Key_instance;
+  AbstractCoroutineContextKey.call(this, tmp, CoroutineDispatcher$Key$_init_$lambda_akl8b5);
+}
+var Key_instance_0;
+function Key_getInstance() {
+  if (Key_instance_0 == null)
+    new Key();
+  return Key_instance_0;
+}
+function CoroutineDispatcher() {
+  Key_getInstance();
+  AbstractCoroutineContextElement.call(this, Key_instance);
+}
+protoOf(CoroutineDispatcher).n12 = function (context) {
+  return true;
+};
+protoOf(CoroutineDispatcher).i7 = function (continuation) {
+  return new DispatchedContinuation(this, continuation);
+};
+protoOf(CoroutineDispatcher).j7 = function (continuation) {
+  var dispatched = continuation instanceof DispatchedContinuation ? continuation : THROW_CCE();
+  dispatched.p12();
+};
+protoOf(CoroutineDispatcher).toString = function () {
+  return get_classSimpleName(this) + '@' + get_hexAddress(this);
+};
+function handleCoroutineException(context, exception) {
+  var tmp;
+  if (exception instanceof DispatchException) {
+    tmp = exception.q12_1;
+  } else {
+    tmp = exception;
+  }
+  var reportException = tmp;
+  try {
+    var tmp0_safe_receiver = context.h7(Key_instance_1);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      tmp0_safe_receiver.r12(context, reportException);
+      return Unit_instance;
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var t = $p;
+      handleUncaughtCoroutineException(context, handlerException(reportException, t));
+      return Unit_instance;
+    } else {
+      throw $p;
+    }
+  }
+  handleUncaughtCoroutineException(context, reportException);
+}
+function Key_0() {
+}
+var Key_instance_1;
+function Key_getInstance_0() {
+  return Key_instance_1;
+}
+function handlerException(originalException, thrownException) {
+  if (originalException === thrownException)
+    return originalException;
+  // Inline function 'kotlin.apply' call
+  var this_0 = RuntimeException_init_$Create$('Exception while trying to handle coroutine exception', thrownException);
+  addSuppressed(this_0, originalException);
+  return this_0;
+}
+function GlobalScope() {
+}
+protoOf(GlobalScope).tx = function () {
+  return EmptyCoroutineContext_getInstance();
+};
+var GlobalScope_instance;
+function GlobalScope_getInstance() {
+  return GlobalScope_instance;
+}
+function CoroutineScope() {
+}
+var CoroutineStart_DEFAULT_instance;
+var CoroutineStart_LAZY_instance;
+var CoroutineStart_ATOMIC_instance;
+var CoroutineStart_UNDISPATCHED_instance;
+var CoroutineStart_entriesInitialized;
+function CoroutineStart_initEntries() {
+  if (CoroutineStart_entriesInitialized)
+    return Unit_instance;
+  CoroutineStart_entriesInitialized = true;
+  CoroutineStart_DEFAULT_instance = new CoroutineStart('DEFAULT', 0);
+  CoroutineStart_LAZY_instance = new CoroutineStart('LAZY', 1);
+  CoroutineStart_ATOMIC_instance = new CoroutineStart('ATOMIC', 2);
+  CoroutineStart_UNDISPATCHED_instance = new CoroutineStart('UNDISPATCHED', 3);
+}
+function CoroutineStart(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+protoOf(CoroutineStart).ky = function (block, receiver, completion) {
+  var tmp;
+  switch (this.w1_1) {
+    case 0:
+      startCoroutineCancellable(block, receiver, completion);
+      tmp = Unit_instance;
+      break;
+    case 2:
+      startCoroutine(block, receiver, completion);
+      tmp = Unit_instance;
+      break;
+    case 3:
+      startCoroutineUndispatched(block, receiver, completion);
+      tmp = Unit_instance;
+      break;
+    case 1:
+      tmp = Unit_instance;
+      break;
+    default:
+      noWhenBranchMatchedException();
+      break;
+  }
+  return tmp;
+};
+protoOf(CoroutineStart).lz = function () {
+  return this === CoroutineStart_LAZY_getInstance();
+};
+function CoroutineStart_DEFAULT_getInstance() {
+  CoroutineStart_initEntries();
+  return CoroutineStart_DEFAULT_instance;
+}
+function CoroutineStart_LAZY_getInstance() {
+  CoroutineStart_initEntries();
+  return CoroutineStart_LAZY_instance;
+}
+function delta($this, unconfined) {
+  return unconfined ? new Long(0, 1) : new Long(1, 0);
+}
+function EventLoop() {
+  CoroutineDispatcher.call(this);
+  this.t12_1 = new Long(0, 0);
+  this.u12_1 = false;
+  this.v12_1 = null;
+}
+protoOf(EventLoop).w12 = function () {
+  var tmp0_elvis_lhs = this.v12_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var queue = tmp;
+  var tmp1_elvis_lhs = queue.ta();
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var task = tmp_0;
+  task.q11();
+  return true;
+};
+protoOf(EventLoop).x12 = function (task) {
+  var tmp0_elvis_lhs = this.v12_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlin.also' call
+    var this_0 = ArrayDeque_init_$Create$();
+    this.v12_1 = this_0;
+    tmp = this_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var queue = tmp;
+  queue.ra(task);
+};
+protoOf(EventLoop).y12 = function () {
+  return compare(this.t12_1, delta(this, true)) >= 0;
+};
+protoOf(EventLoop).z12 = function () {
+  var tmp0_safe_receiver = this.v12_1;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p();
+  return tmp1_elvis_lhs == null ? true : tmp1_elvis_lhs;
+};
+protoOf(EventLoop).a13 = function (unconfined) {
+  this.t12_1 = add(this.t12_1, delta(this, unconfined));
+  if (!unconfined)
+    this.u12_1 = true;
+};
+protoOf(EventLoop).b13 = function (unconfined) {
+  this.t12_1 = subtract(this.t12_1, delta(this, unconfined));
+  if (compare(this.t12_1, new Long(0, 0)) > 0)
+    return Unit_instance;
+  // Inline function 'kotlinx.coroutines.assert' call
+  if (this.u12_1) {
+    this.c13();
+  }
+};
+protoOf(EventLoop).c13 = function () {
+};
+function ThreadLocalEventLoop() {
+  ThreadLocalEventLoop_instance = this;
+  this.d13_1 = commonThreadLocal(new Symbol('ThreadLocalEventLoop'));
+}
+protoOf(ThreadLocalEventLoop).e13 = function () {
+  var tmp0_elvis_lhs = this.d13_1.g13();
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlin.also' call
+    var this_0 = createEventLoop();
+    ThreadLocalEventLoop_getInstance().d13_1.h13(this_0);
+    tmp = this_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+};
+var ThreadLocalEventLoop_instance;
+function ThreadLocalEventLoop_getInstance() {
+  if (ThreadLocalEventLoop_instance == null)
+    new ThreadLocalEventLoop();
+  return ThreadLocalEventLoop_instance;
+}
+function CompletionHandlerException(message, cause) {
+  RuntimeException_init_$Init$(message, cause, this);
+  captureStack(this, CompletionHandlerException);
+}
+function CoroutinesInternalError(message, cause) {
+  Error_init_$Init$(message, cause, this);
+  captureStack(this, CoroutinesInternalError);
+}
+function Key_1() {
+}
+var Key_instance_2;
+function Key_getInstance_1() {
+  return Key_instance_2;
+}
+function ParentJob() {
+}
+function NonDisposableHandle() {
+}
+protoOf(NonDisposableHandle).n10 = function () {
+};
+protoOf(NonDisposableHandle).az = function (cause) {
+  return false;
+};
+protoOf(NonDisposableHandle).toString = function () {
+  return 'NonDisposableHandle';
+};
+var NonDisposableHandle_instance;
+function NonDisposableHandle_getInstance() {
+  return NonDisposableHandle_instance;
+}
+function invokeOnCompletion(_this__u8e3s4, invokeImmediately, handler) {
+  invokeImmediately = invokeImmediately === VOID ? true : invokeImmediately;
+  var tmp;
+  if (_this__u8e3s4 instanceof JobSupport) {
+    tmp = _this__u8e3s4.wy(invokeImmediately, handler);
+  } else {
+    var tmp_0 = handler.y11();
+    tmp = _this__u8e3s4.vy(tmp_0, invokeImmediately, JobNode$invoke$ref(handler));
+  }
+  return tmp;
+}
+function JobNode$invoke$ref(p0) {
+  var l = function (_this__u8e3s4) {
+    p0.b11(_this__u8e3s4);
+    return Unit_instance;
+  };
+  l.callableName = 'invoke';
+  return l;
+}
+function get_COMPLETING_ALREADY() {
+  _init_properties_JobSupport_kt__68f172();
+  return COMPLETING_ALREADY;
+}
+var COMPLETING_ALREADY;
+function get_COMPLETING_WAITING_CHILDREN() {
+  _init_properties_JobSupport_kt__68f172();
+  return COMPLETING_WAITING_CHILDREN;
+}
+var COMPLETING_WAITING_CHILDREN;
+function get_COMPLETING_RETRY() {
+  _init_properties_JobSupport_kt__68f172();
+  return COMPLETING_RETRY;
+}
+var COMPLETING_RETRY;
+function get_TOO_LATE_TO_CANCEL() {
+  _init_properties_JobSupport_kt__68f172();
+  return TOO_LATE_TO_CANCEL;
+}
+var TOO_LATE_TO_CANCEL;
+function get_SEALED() {
+  _init_properties_JobSupport_kt__68f172();
+  return SEALED;
+}
+var SEALED;
+function get_EMPTY_NEW() {
+  _init_properties_JobSupport_kt__68f172();
+  return EMPTY_NEW;
+}
+var EMPTY_NEW;
+function get_EMPTY_ACTIVE() {
+  _init_properties_JobSupport_kt__68f172();
+  return EMPTY_ACTIVE;
+}
+var EMPTY_ACTIVE;
+function Empty(isActive) {
+  this.i13_1 = isActive;
+}
+protoOf(Empty).ux = function () {
+  return this.i13_1;
+};
+protoOf(Empty).e12 = function () {
+  return null;
+};
+protoOf(Empty).toString = function () {
+  return 'Empty{' + (this.i13_1 ? 'Active' : 'New') + '}';
+};
+function Incomplete() {
+}
+function NodeList() {
+  LockFreeLinkedListHead.call(this);
+}
+protoOf(NodeList).ux = function () {
+  return true;
+};
+protoOf(NodeList).e12 = function () {
+  return this;
+};
+protoOf(NodeList).m13 = function (state) {
+  // Inline function 'kotlin.text.buildString' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder_init_$Create$();
+  this_0.f6('List{');
+  this_0.f6(state);
+  this_0.f6('}[');
+  var first = true;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = this.f12_1;
+  while (!equals(cur, this)) {
+    var node = cur;
+    if (node instanceof JobNode) {
+      if (first) {
+        first = false;
+      } else
+        this_0.f6(', ');
+      this_0.e6(node);
+    }
+    cur = cur.f12_1;
+  }
+  this_0.f6(']');
+  return this_0.toString();
+};
+protoOf(NodeList).toString = function () {
+  return get_DEBUG() ? this.m13('Active') : protoOf(LockFreeLinkedListHead).toString.call(this);
+};
+function JobNode() {
+  LockFreeLinkedListNode.call(this);
+}
+protoOf(JobNode).d12 = function () {
+  var tmp = this.c12_1;
+  if (!(tmp == null))
+    return tmp;
+  else {
+    throwUninitializedPropertyAccessException('job');
+  }
+};
+protoOf(JobNode).ux = function () {
+  return true;
+};
+protoOf(JobNode).e12 = function () {
+  return null;
+};
+protoOf(JobNode).n10 = function () {
+  return this.d12().xy(this);
+};
+protoOf(JobNode).toString = function () {
+  return get_classSimpleName(this) + '@' + get_hexAddress(this) + '[job@' + get_hexAddress(this.d12()) + ']';
+};
+function _set_exceptionsHolder__tqm22h($this, value) {
+  $this.r13_1.kotlinx$atomicfu$value = value;
+}
+function _get_exceptionsHolder__nhszp($this) {
+  return $this.r13_1.kotlinx$atomicfu$value;
+}
+function allocateList($this) {
+  return ArrayList_init_$Create$(4);
+}
+function finalizeFinishingState($this, state, proposedUpdate) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally ? proposedUpdate : null;
+  var proposedException = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.zx_1;
+  var wasCancelling;
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  wasCancelling = state.s13();
+  var exceptions = state.t13(proposedException);
+  var finalCause = getFinalRootCause($this, state, exceptions);
+  if (!(finalCause == null)) {
+    addSuppressedExceptions($this, finalCause, exceptions);
+  }
+  var finalException = finalCause;
+  var finalState = finalException == null ? proposedUpdate : finalException === proposedException ? proposedUpdate : new CompletedExceptionally(finalException);
+  if (!(finalException == null)) {
+    var handled = cancelParent($this, finalException) || $this.hz(finalException);
+    if (handled) {
+      (finalState instanceof CompletedExceptionally ? finalState : THROW_CCE()).l12();
+    }
+  }
+  if (!wasCancelling) {
+    $this.ez(finalException);
+  }
+  $this.yx(finalState);
+  var casSuccess = $this.nx_1.atomicfu$compareAndSet(state, boxIncomplete(finalState));
+  // Inline function 'kotlinx.coroutines.assert' call
+  completeStateFinalization($this, state, finalState);
+  return finalState;
+}
+function getFinalRootCause($this, state, exceptions) {
+  if (exceptions.p()) {
+    if (state.s13()) {
+      // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+      return new JobCancellationException(null == null ? $this.xx() : null, null, $this);
+    }
+    return null;
+  }
+  var tmp$ret$2;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstOrNull' call
+    var _iterator__ex2g4s = exceptions.f();
+    while (_iterator__ex2g4s.g()) {
+      var element = _iterator__ex2g4s.h();
+      if (!(element instanceof CancellationException)) {
+        tmp$ret$2 = element;
+        break $l$block;
+      }
+    }
+    tmp$ret$2 = null;
+  }
+  var firstNonCancellation = tmp$ret$2;
+  if (!(firstNonCancellation == null))
+    return firstNonCancellation;
+  var first = exceptions.n(0);
+  if (first instanceof TimeoutCancellationException) {
+    var tmp$ret$4;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s_0 = exceptions.f();
+      while (_iterator__ex2g4s_0.g()) {
+        var element_0 = _iterator__ex2g4s_0.h();
+        var tmp;
+        if (!(element_0 === first)) {
+          tmp = element_0 instanceof TimeoutCancellationException;
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          tmp$ret$4 = element_0;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$4 = null;
+    }
+    var detailedTimeoutException = tmp$ret$4;
+    if (!(detailedTimeoutException == null))
+      return detailedTimeoutException;
+  }
+  return first;
+}
+function addSuppressedExceptions($this, rootCause, exceptions) {
+  if (exceptions.i() <= 1)
+    return Unit_instance;
+  var seenExceptions = identitySet(exceptions.i());
+  var unwrappedCause = unwrap(rootCause);
+  var _iterator__ex2g4s = exceptions.f();
+  while (_iterator__ex2g4s.g()) {
+    var exception = _iterator__ex2g4s.h();
+    var unwrapped = unwrap(exception);
+    var tmp;
+    var tmp_0;
+    if (!(unwrapped === rootCause) && !(unwrapped === unwrappedCause)) {
+      tmp_0 = !(unwrapped instanceof CancellationException);
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = seenExceptions.d(unwrapped);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      addSuppressed(rootCause, unwrapped);
+    }
+  }
+}
+function tryFinalizeSimpleState($this, state, update) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  if (!$this.nx_1.atomicfu$compareAndSet(state, boxIncomplete(update)))
+    return false;
+  $this.ez(null);
+  $this.yx(update);
+  completeStateFinalization($this, state, update);
+  return true;
+}
+function completeStateFinalization($this, state, update) {
+  var tmp0_safe_receiver = $this.my();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    tmp0_safe_receiver.n10();
+    $this.ly(NonDisposableHandle_instance);
+  }
+  var tmp1_safe_receiver = update instanceof CompletedExceptionally ? update : null;
+  var cause = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.zx_1;
+  if (state instanceof JobNode) {
+    try {
+      state.b11(cause);
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        $this.fy(new CompletionHandlerException('Exception in completion handler ' + state.toString() + ' for ' + $this.toString(), ex));
+      } else {
+        throw $p;
+      }
+    }
+  } else {
+    var tmp2_safe_receiver = state.e12();
+    if (tmp2_safe_receiver == null)
+      null;
+    else {
+      notifyCompletion($this, tmp2_safe_receiver, cause);
+    }
+  }
+}
+function notifyCancelling($this, list, cause) {
+  $this.ez(cause);
+  list.n13(4);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = list.f12_1;
+  while (!equals(cur, list)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode) {
+      tmp = node.y11();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.b11(cause);
+      } catch ($p) {
+        if ($p instanceof Error) {
+          var ex = $p;
+          var tmp0_safe_receiver = exception;
+          var tmp_0;
+          if (tmp0_safe_receiver == null) {
+            tmp_0 = null;
+          } else {
+            // Inline function 'kotlin.apply' call
+            addSuppressed(tmp0_safe_receiver, ex);
+            tmp_0 = tmp0_safe_receiver;
+          }
+          if (tmp_0 == null) {
+            // Inline function 'kotlin.run' call
+            exception = new CompletionHandlerException('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.f12_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.fy(tmp0_safe_receiver_0);
+  }
+  cancelParent($this, cause);
+}
+function cancelParent($this, cause) {
+  if ($this.fz())
+    return true;
+  var isCancellation = cause instanceof CancellationException;
+  var parent = $this.my();
+  if (parent === null || parent === NonDisposableHandle_instance) {
+    return isCancellation;
+  }
+  return parent.az(cause) || isCancellation;
+}
+function notifyCompletion($this, _this__u8e3s4, cause) {
+  _this__u8e3s4.n13(1);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = _this__u8e3s4.f12_1;
+  while (!equals(cur, _this__u8e3s4)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode) {
+      tmp = true;
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.b11(cause);
+      } catch ($p) {
+        if ($p instanceof Error) {
+          var ex = $p;
+          var tmp0_safe_receiver = exception;
+          var tmp_0;
+          if (tmp0_safe_receiver == null) {
+            tmp_0 = null;
+          } else {
+            // Inline function 'kotlin.apply' call
+            addSuppressed(tmp0_safe_receiver, ex);
+            tmp_0 = tmp0_safe_receiver;
+          }
+          if (tmp_0 == null) {
+            // Inline function 'kotlin.run' call
+            exception = new CompletionHandlerException('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.f12_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.fy(tmp0_safe_receiver_0);
+  }
+}
+function startInternal($this, state) {
+  if (state instanceof Empty) {
+    if (state.i13_1)
+      return 0;
+    if (!$this.nx_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+      return -1;
+    $this.qy();
+    return 1;
+  } else {
+    if (state instanceof InactiveNodeList) {
+      if (!$this.nx_1.atomicfu$compareAndSet(state, state.u13_1))
+        return -1;
+      $this.qy();
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+}
+function promoteEmptyToNodeList($this, state) {
+  var list = new NodeList();
+  var update = state.i13_1 ? list : new InactiveNodeList(list);
+  $this.nx_1.atomicfu$compareAndSet(state, update);
+}
+function promoteSingleToNodeList($this, state) {
+  state.k12(new NodeList());
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+  var list = state.f12_1;
+  $this.nx_1.atomicfu$compareAndSet(state, list);
+}
+function cancelMakeCompleting($this, cause) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.ny();
+    var tmp;
+    if (!(!(state == null) ? isInterface(state, Incomplete) : false)) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (state instanceof Finishing) {
+        tmp_0 = state.v13();
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    }
+    if (tmp) {
+      return get_COMPLETING_ALREADY();
+    }
+    var proposedUpdate = new CompletedExceptionally(createCauseException($this, cause));
+    var finalState = tryMakeCompleting($this, state, proposedUpdate);
+    if (!(finalState === get_COMPLETING_RETRY()))
+      return finalState;
+  }
+}
+function createCauseException($this, cause) {
+  var tmp;
+  if (cause == null ? true : cause instanceof Error) {
+    var tmp_0;
+    if (cause == null) {
+      // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+      tmp_0 = new JobCancellationException(null == null ? $this.xx() : null, null, $this);
+    } else {
+      tmp_0 = cause;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = (isInterface(cause, ParentJob) ? cause : THROW_CCE()).cz();
+  }
+  return tmp;
+}
+function makeCancelling($this, cause) {
+  var causeExceptionCache = null;
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var tmp0 = $this.ny();
+    $l$block: {
+      if (tmp0 instanceof Finishing) {
+        // Inline function 'kotlinx.coroutines.internal.synchronized' call
+        // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+        if (tmp0.w13())
+          return get_TOO_LATE_TO_CANCEL();
+        var wasCancelling = tmp0.s13();
+        if (!(cause == null) || !wasCancelling) {
+          var tmp0_elvis_lhs = causeExceptionCache;
+          var tmp;
+          if (tmp0_elvis_lhs == null) {
+            // Inline function 'kotlin.also' call
+            var this_0 = createCauseException($this, cause);
+            causeExceptionCache = this_0;
+            tmp = this_0;
+          } else {
+            tmp = tmp0_elvis_lhs;
+          }
+          var causeException = tmp;
+          tmp0.x13(causeException);
+        }
+        // Inline function 'kotlin.takeIf' call
+        var this_1 = tmp0.y13();
+        var tmp_0;
+        if (!wasCancelling) {
+          tmp_0 = this_1;
+        } else {
+          tmp_0 = null;
+        }
+        var notifyRootCause = tmp_0;
+        if (notifyRootCause == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          notifyCancelling($this, tmp0.o13_1, notifyRootCause);
+        }
+        return get_COMPLETING_ALREADY();
+      } else {
+        if (!(tmp0 == null) ? isInterface(tmp0, Incomplete) : false) {
+          var tmp2_elvis_lhs = causeExceptionCache;
+          var tmp_1;
+          if (tmp2_elvis_lhs == null) {
+            // Inline function 'kotlin.also' call
+            var this_2 = createCauseException($this, cause);
+            causeExceptionCache = this_2;
+            tmp_1 = this_2;
+          } else {
+            tmp_1 = tmp2_elvis_lhs;
+          }
+          var causeException_0 = tmp_1;
+          if (tmp0.ux()) {
+            if (tryMakeCancelling($this, tmp0, causeException_0))
+              return get_COMPLETING_ALREADY();
+          } else {
+            var finalState = tryMakeCompleting($this, tmp0, new CompletedExceptionally(causeException_0));
+            if (finalState === get_COMPLETING_ALREADY()) {
+              // Inline function 'kotlin.error' call
+              var message = 'Cannot happen in ' + toString(tmp0);
+              throw IllegalStateException_init_$Create$(toString(message));
+            } else if (finalState === get_COMPLETING_RETRY()) {
+              break $l$block;
+            } else
+              return finalState;
+          }
+        } else {
+          return get_TOO_LATE_TO_CANCEL();
+        }
+      }
+    }
+  }
+}
+function getOrPromoteCancellingList($this, state) {
+  var tmp0_elvis_lhs = state.e12();
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    var tmp_0;
+    if (state instanceof Empty) {
+      tmp_0 = new NodeList();
+    } else {
+      if (state instanceof JobNode) {
+        promoteSingleToNodeList($this, state);
+        tmp_0 = null;
+      } else {
+        var message = 'State should have list: ' + toString(state);
+        throw IllegalStateException_init_$Create$(toString(message));
+      }
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function tryMakeCancelling($this, state, rootCause) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  var tmp0_elvis_lhs = getOrPromoteCancellingList($this, state);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var list = tmp;
+  var cancelling = new Finishing(list, false, rootCause);
+  if (!$this.nx_1.atomicfu$compareAndSet(state, cancelling))
+    return false;
+  notifyCancelling($this, list, rootCause);
+  return true;
+}
+function tryMakeCompleting($this, state, proposedUpdate) {
+  if (!(!(state == null) ? isInterface(state, Incomplete) : false))
+    return get_COMPLETING_ALREADY();
+  var tmp;
+  var tmp_0;
+  var tmp_1;
+  if (state instanceof Empty) {
+    tmp_1 = true;
+  } else {
+    tmp_1 = state instanceof JobNode;
+  }
+  if (tmp_1) {
+    tmp_0 = !(state instanceof ChildHandleNode);
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = !(proposedUpdate instanceof CompletedExceptionally);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    if (tryFinalizeSimpleState($this, state, proposedUpdate)) {
+      return proposedUpdate;
+    }
+    return get_COMPLETING_RETRY();
+  }
+  return tryMakeCompletingSlowPath($this, state, proposedUpdate);
+}
+function tryMakeCompletingSlowPath($this, state, proposedUpdate) {
+  var tmp0_elvis_lhs = getOrPromoteCancellingList($this, state);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return get_COMPLETING_RETRY();
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var list = tmp;
+  var tmp1_elvis_lhs = state instanceof Finishing ? state : null;
+  var finishing = tmp1_elvis_lhs == null ? new Finishing(list, false, null) : tmp1_elvis_lhs;
+  var notifyRootCause;
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  if (finishing.v13())
+    return get_COMPLETING_ALREADY();
+  finishing.z13(true);
+  if (!(finishing === state)) {
+    if (!$this.nx_1.atomicfu$compareAndSet(state, finishing))
+      return get_COMPLETING_RETRY();
+  }
+  // Inline function 'kotlinx.coroutines.assert' call
+  var wasCancelling = finishing.s13();
+  var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally ? proposedUpdate : null;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    finishing.x13(tmp0_safe_receiver.zx_1);
+  }
+  // Inline function 'kotlin.takeIf' call
+  var this_0 = finishing.y13();
+  var tmp_0;
+  if (!wasCancelling) {
+    tmp_0 = this_0;
+  } else {
+    tmp_0 = null;
+  }
+  notifyRootCause = tmp_0;
+  if (notifyRootCause == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    notifyCancelling($this, list, notifyRootCause);
+  }
+  var child = nextChild($this, list);
+  if (!(child == null) && tryWaitForChild($this, finishing, child, proposedUpdate))
+    return get_COMPLETING_WAITING_CHILDREN();
+  list.n13(2);
+  var anotherChild = nextChild($this, list);
+  if (!(anotherChild == null) && tryWaitForChild($this, finishing, anotherChild, proposedUpdate))
+    return get_COMPLETING_WAITING_CHILDREN();
+  return finalizeFinishingState($this, finishing, proposedUpdate);
+}
+function _get_exceptionOrNull__b3j7js($this, _this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4 instanceof CompletedExceptionally ? _this__u8e3s4 : null;
+  return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.zx_1;
+}
+function tryWaitForChild($this, state, child, proposedUpdate) {
+  var $this_0 = $this;
+  var state_0 = state;
+  var child_0 = child;
+  var proposedUpdate_0 = proposedUpdate;
+  $l$1: do {
+    $l$0: do {
+      var handle = invokeOnCompletion(child_0.e14_1, false, new ChildCompletion($this_0, state_0, child_0, proposedUpdate_0));
+      if (!(handle === NonDisposableHandle_instance))
+        return true;
+      var tmp0_elvis_lhs = nextChild($this_0, child_0);
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        return false;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      var nextChild_0 = tmp;
+      var tmp0 = $this_0;
+      var tmp1 = state_0;
+      var tmp3 = proposedUpdate_0;
+      $this_0 = tmp0;
+      state_0 = tmp1;
+      child_0 = nextChild_0;
+      proposedUpdate_0 = tmp3;
+      continue $l$0;
+    }
+     while (false);
+  }
+   while (true);
+}
+function continueCompleting($this, state, lastChild, proposedUpdate) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  var waitChild = nextChild($this, lastChild);
+  if (!(waitChild == null) && tryWaitForChild($this, state, waitChild, proposedUpdate))
+    return Unit_instance;
+  state.o13_1.n13(2);
+  var waitChildAgain = nextChild($this, lastChild);
+  if (!(waitChildAgain == null) && tryWaitForChild($this, state, waitChildAgain, proposedUpdate)) {
+    return Unit_instance;
+  }
+  var finalState = finalizeFinishingState($this, state, proposedUpdate);
+  $this.ey(finalState);
+}
+function nextChild($this, _this__u8e3s4) {
+  var cur = _this__u8e3s4;
+  $l$loop: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (!cur.h12_1) {
+      break $l$loop;
+    }
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.prevNode' call
+    cur = cur.g12_1;
+  }
+  $l$loop_0: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+    cur = cur.f12_1;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (cur.h12_1)
+      continue $l$loop_0;
+    if (cur instanceof ChildHandleNode)
+      return cur;
+    if (cur instanceof NodeList)
+      return null;
+  }
+}
+function stateString($this, state) {
+  var tmp;
+  if (state instanceof Finishing) {
+    tmp = state.s13() ? 'Cancelling' : state.v13() ? 'Completing' : 'Active';
+  } else {
+    if (!(state == null) ? isInterface(state, Incomplete) : false) {
+      tmp = state.ux() ? 'Active' : 'New';
+    } else {
+      if (state instanceof CompletedExceptionally) {
+        tmp = 'Cancelled';
+      } else {
+        tmp = 'Completed';
+      }
+    }
+  }
+  return tmp;
+}
+function Finishing(list, isCompleting, rootCause) {
+  SynchronizedObject.call(this);
+  this.o13_1 = list;
+  this.p13_1 = atomic$boolean$1(isCompleting);
+  this.q13_1 = atomic$ref$1(rootCause);
+  this.r13_1 = atomic$ref$1(null);
+}
+protoOf(Finishing).e12 = function () {
+  return this.o13_1;
+};
+protoOf(Finishing).z13 = function (value) {
+  this.p13_1.kotlinx$atomicfu$value = value;
+};
+protoOf(Finishing).v13 = function () {
+  return this.p13_1.kotlinx$atomicfu$value;
+};
+protoOf(Finishing).f14 = function (value) {
+  this.q13_1.kotlinx$atomicfu$value = value;
+};
+protoOf(Finishing).y13 = function () {
+  return this.q13_1.kotlinx$atomicfu$value;
+};
+protoOf(Finishing).w13 = function () {
+  return _get_exceptionsHolder__nhszp(this) === get_SEALED();
+};
+protoOf(Finishing).s13 = function () {
+  return !(this.y13() == null);
+};
+protoOf(Finishing).ux = function () {
+  return this.y13() == null;
+};
+protoOf(Finishing).t13 = function (proposedException) {
+  var eh = _get_exceptionsHolder__nhszp(this);
+  var tmp;
+  if (eh == null) {
+    tmp = allocateList(this);
+  } else {
+    if (eh instanceof Error) {
+      // Inline function 'kotlin.also' call
+      var this_0 = allocateList(this);
+      this_0.d(eh);
+      tmp = this_0;
+    } else {
+      if (eh instanceof ArrayList) {
+        tmp = eh instanceof ArrayList ? eh : THROW_CCE();
+      } else {
+        var message = 'State is ' + toString(eh);
+        throw IllegalStateException_init_$Create$(toString(message));
+      }
+    }
+  }
+  var list = tmp;
+  var rootCause = this.y13();
+  if (rootCause == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    list.y2(0, rootCause);
+  }
+  if (!(proposedException == null) && !equals(proposedException, rootCause)) {
+    list.d(proposedException);
+  }
+  _set_exceptionsHolder__tqm22h(this, get_SEALED());
+  return list;
+};
+protoOf(Finishing).x13 = function (exception) {
+  var rootCause = this.y13();
+  if (rootCause == null) {
+    this.f14(exception);
+    return Unit_instance;
+  }
+  if (exception === rootCause)
+    return Unit_instance;
+  var eh = _get_exceptionsHolder__nhszp(this);
+  if (eh == null) {
+    _set_exceptionsHolder__tqm22h(this, exception);
+  } else {
+    if (eh instanceof Error) {
+      if (exception === eh)
+        return Unit_instance;
+      // Inline function 'kotlin.apply' call
+      var this_0 = allocateList(this);
+      this_0.d(eh);
+      this_0.d(exception);
+      _set_exceptionsHolder__tqm22h(this, this_0);
+    } else {
+      if (eh instanceof ArrayList) {
+        (eh instanceof ArrayList ? eh : THROW_CCE()).d(exception);
+      } else {
+        // Inline function 'kotlin.error' call
+        var message = 'State is ' + toString(eh);
+        throw IllegalStateException_init_$Create$(toString(message));
+      }
+    }
+  }
+};
+protoOf(Finishing).toString = function () {
+  return 'Finishing[cancelling=' + this.s13() + ', completing=' + this.v13() + ', rootCause=' + toString_0(this.y13()) + ', exceptions=' + toString_0(_get_exceptionsHolder__nhszp(this)) + ', list=' + this.o13_1.toString() + ']';
+};
+function ChildCompletion(parent, state, child, proposedUpdate) {
+  JobNode.call(this);
+  this.k14_1 = parent;
+  this.l14_1 = state;
+  this.m14_1 = child;
+  this.n14_1 = proposedUpdate;
+}
+protoOf(ChildCompletion).y11 = function () {
+  return false;
+};
+protoOf(ChildCompletion).b11 = function (cause) {
+  continueCompleting(this.k14_1, this.l14_1, this.m14_1, this.n14_1);
+};
+function JobSupport(active) {
+  this.nx_1 = atomic$ref$1(active ? get_EMPTY_ACTIVE() : get_EMPTY_NEW());
+  this.ox_1 = atomic$ref$1(null);
+}
+protoOf(JobSupport).i1 = function () {
+  return Key_instance_2;
+};
+protoOf(JobSupport).ly = function (value) {
+  this.ox_1.kotlinx$atomicfu$value = value;
+};
+protoOf(JobSupport).my = function () {
+  return this.ox_1.kotlinx$atomicfu$value;
+};
+protoOf(JobSupport).px = function (parent) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  if (parent == null) {
+    this.ly(NonDisposableHandle_instance);
+    return Unit_instance;
+  }
+  parent.py();
+  var handle = parent.dz(this);
+  this.ly(handle);
+  if (this.oy()) {
+    handle.n10();
+    this.ly(NonDisposableHandle_instance);
+  }
+};
+protoOf(JobSupport).ny = function () {
+  return this.nx_1.kotlinx$atomicfu$value;
+};
+protoOf(JobSupport).ux = function () {
+  var state = this.ny();
+  var tmp;
+  if (!(state == null) ? isInterface(state, Incomplete) : false) {
+    tmp = state.ux();
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(JobSupport).oy = function () {
+  var tmp = this.ny();
+  return !(!(tmp == null) ? isInterface(tmp, Incomplete) : false);
+};
+protoOf(JobSupport).py = function () {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = this.ny();
+    var tmp0_subject = startInternal(this, state);
+    if (tmp0_subject === 0)
+      return false;
+    else if (tmp0_subject === 1)
+      return true;
+  }
+};
+protoOf(JobSupport).qy = function () {
+};
+protoOf(JobSupport).ry = function () {
+  var state = this.ny();
+  var tmp;
+  if (state instanceof Finishing) {
+    var tmp0_safe_receiver = state.y13();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : this.sy(tmp0_safe_receiver, get_classSimpleName(this) + ' is cancelling');
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      var message = 'Job is still new or active: ' + this.toString();
+      throw IllegalStateException_init_$Create$(toString(message));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    tmp = tmp_0;
+  } else {
+    if (!(state == null) ? isInterface(state, Incomplete) : false) {
+      var message_0 = 'Job is still new or active: ' + this.toString();
+      throw IllegalStateException_init_$Create$(toString(message_0));
+    } else {
+      if (state instanceof CompletedExceptionally) {
+        tmp = this.ty(state.zx_1);
+      } else {
+        tmp = new JobCancellationException(get_classSimpleName(this) + ' has completed normally', null, this);
+      }
+    }
+  }
+  return tmp;
+};
+protoOf(JobSupport).sy = function (_this__u8e3s4, message) {
+  var tmp0_elvis_lhs = _this__u8e3s4 instanceof CancellationException ? _this__u8e3s4 : null;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+    tmp = new JobCancellationException(message == null ? this.xx() : message, _this__u8e3s4, this);
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+};
+protoOf(JobSupport).ty = function (_this__u8e3s4, message, $super) {
+  message = message === VOID ? null : message;
+  return $super === VOID ? this.sy(_this__u8e3s4, message) : $super.sy.call(this, _this__u8e3s4, message);
+};
+protoOf(JobSupport).uy = function (handler) {
+  return this.wy(true, new InvokeOnCompletion(handler));
+};
+protoOf(JobSupport).vy = function (onCancelling, invokeImmediately, handler) {
+  var tmp;
+  if (onCancelling) {
+    tmp = new InvokeOnCancelling(handler);
+  } else {
+    tmp = new InvokeOnCompletion(handler);
+  }
+  return this.wy(invokeImmediately, tmp);
+};
+protoOf(JobSupport).wy = function (invokeImmediately, node) {
+  node.c12_1 = this;
+  var tmp$ret$0;
+  $l$block_1: {
+    // Inline function 'kotlinx.coroutines.JobSupport.tryPutNodeIntoList' call
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var state = this.ny();
+      if (state instanceof Empty) {
+        if (state.i13_1) {
+          if (this.nx_1.atomicfu$compareAndSet(state, node)) {
+            tmp$ret$0 = true;
+            break $l$block_1;
+          }
+        } else {
+          promoteEmptyToNodeList(this, state);
+        }
+      } else {
+        if (!(state == null) ? isInterface(state, Incomplete) : false) {
+          var list = state.e12();
+          if (list == null) {
+            promoteSingleToNodeList(this, state instanceof JobNode ? state : THROW_CCE());
+          } else {
+            var tmp;
+            if (node.y11()) {
+              var tmp0_safe_receiver = state instanceof Finishing ? state : null;
+              var rootCause = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y13();
+              var tmp_0;
+              if (rootCause == null) {
+                tmp_0 = list.i12(node, 5);
+              } else {
+                if (invokeImmediately) {
+                  node.b11(rootCause);
+                }
+                return NonDisposableHandle_instance;
+              }
+              tmp = tmp_0;
+            } else {
+              tmp = list.i12(node, 1);
+            }
+            if (tmp) {
+              tmp$ret$0 = true;
+              break $l$block_1;
+            }
+          }
+        } else {
+          tmp$ret$0 = false;
+          break $l$block_1;
+        }
+      }
+    }
+  }
+  var added = tmp$ret$0;
+  if (added)
+    return node;
+  else if (invokeImmediately) {
+    var tmp_1 = this.ny();
+    var tmp0_safe_receiver_0 = tmp_1 instanceof CompletedExceptionally ? tmp_1 : null;
+    node.b11(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.zx_1);
+  }
+  return NonDisposableHandle_instance;
+};
+protoOf(JobSupport).xy = function (node) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = this.ny();
+    if (state instanceof JobNode) {
+      if (!(state === node))
+        return Unit_instance;
+      if (this.nx_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+        return Unit_instance;
+    } else {
+      if (!(state == null) ? isInterface(state, Incomplete) : false) {
+        if (!(state.e12() == null)) {
+          node.j12();
+        }
+        return Unit_instance;
+      } else {
+        return Unit_instance;
+      }
+    }
+  }
+};
+protoOf(JobSupport).yy = function () {
+  return false;
+};
+protoOf(JobSupport).xx = function () {
+  return 'Job was cancelled';
+};
+protoOf(JobSupport).zy = function (parentJob) {
+  this.bz(parentJob);
+};
+protoOf(JobSupport).az = function (cause) {
+  if (cause instanceof CancellationException)
+    return true;
+  return this.bz(cause) && this.gz();
+};
+protoOf(JobSupport).bz = function (cause) {
+  var finalState = get_COMPLETING_ALREADY();
+  if (this.yy()) {
+    finalState = cancelMakeCompleting(this, cause);
+    if (finalState === get_COMPLETING_WAITING_CHILDREN())
+      return true;
+  }
+  if (finalState === get_COMPLETING_ALREADY()) {
+    finalState = makeCancelling(this, cause);
+  }
+  var tmp;
+  if (finalState === get_COMPLETING_ALREADY()) {
+    tmp = true;
+  } else if (finalState === get_COMPLETING_WAITING_CHILDREN()) {
+    tmp = true;
+  } else if (finalState === get_TOO_LATE_TO_CANCEL()) {
+    tmp = false;
+  } else {
+    this.ey(finalState);
+    tmp = true;
+  }
+  return tmp;
+};
+protoOf(JobSupport).cz = function () {
+  var state = this.ny();
+  var tmp;
+  if (state instanceof Finishing) {
+    tmp = state.y13();
+  } else {
+    if (state instanceof CompletedExceptionally) {
+      tmp = state.zx_1;
+    } else {
+      if (!(state == null) ? isInterface(state, Incomplete) : false) {
+        var message = 'Cannot be cancelling child in this state: ' + toString(state);
+        throw IllegalStateException_init_$Create$(toString(message));
+      } else {
+        tmp = null;
+      }
+    }
+  }
+  var rootCause = tmp;
+  var tmp1_elvis_lhs = rootCause instanceof CancellationException ? rootCause : null;
+  return tmp1_elvis_lhs == null ? new JobCancellationException('Parent job is ' + stateString(this, state), rootCause, this) : tmp1_elvis_lhs;
+};
+protoOf(JobSupport).cy = function (proposedUpdate) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var tmp0 = this.ny();
+    $l$block: {
+      var finalState = tryMakeCompleting(this, tmp0, proposedUpdate);
+      if (finalState === get_COMPLETING_ALREADY())
+        throw IllegalStateException_init_$Create$_0('Job ' + this.toString() + ' is already complete or completing, ' + ('but is being completed with ' + toString_0(proposedUpdate)), _get_exceptionOrNull__b3j7js(this, proposedUpdate));
+      else if (finalState === get_COMPLETING_RETRY()) {
+        break $l$block;
+      } else
+        return finalState;
+    }
+  }
+};
+protoOf(JobSupport).dz = function (child) {
+  // Inline function 'kotlin.also' call
+  var this_0 = new ChildHandleNode(child);
+  this_0.c12_1 = this;
+  var node = this_0;
+  var tmp$ret$2;
+  $l$block_1: {
+    // Inline function 'kotlinx.coroutines.JobSupport.tryPutNodeIntoList' call
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var state = this.ny();
+      if (state instanceof Empty) {
+        if (state.i13_1) {
+          if (this.nx_1.atomicfu$compareAndSet(state, node)) {
+            tmp$ret$2 = true;
+            break $l$block_1;
+          }
+        } else {
+          promoteEmptyToNodeList(this, state);
+        }
+      } else {
+        if (!(state == null) ? isInterface(state, Incomplete) : false) {
+          var list = state.e12();
+          if (list == null) {
+            promoteSingleToNodeList(this, state instanceof JobNode ? state : THROW_CCE());
+          } else {
+            var addedBeforeCancellation = list.i12(node, 7);
+            var tmp;
+            if (addedBeforeCancellation) {
+              tmp = true;
+            } else {
+              var addedBeforeCompletion = list.i12(node, 3);
+              var latestState = this.ny();
+              var tmp_0;
+              if (latestState instanceof Finishing) {
+                tmp_0 = latestState.y13();
+              } else {
+                // Inline function 'kotlinx.coroutines.assert' call
+                var tmp0_safe_receiver = latestState instanceof CompletedExceptionally ? latestState : null;
+                tmp_0 = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.zx_1;
+              }
+              var rootCause = tmp_0;
+              node.b11(rootCause);
+              var tmp_1;
+              if (addedBeforeCompletion) {
+                // Inline function 'kotlinx.coroutines.assert' call
+                tmp_1 = true;
+              } else {
+                return NonDisposableHandle_instance;
+              }
+              tmp = tmp_1;
+            }
+            if (tmp) {
+              tmp$ret$2 = true;
+              break $l$block_1;
+            }
+          }
+        } else {
+          tmp$ret$2 = false;
+          break $l$block_1;
+        }
+      }
+    }
+  }
+  var added = tmp$ret$2;
+  if (added)
+    return node;
+  var tmp_2 = this.ny();
+  var tmp0_safe_receiver_0 = tmp_2 instanceof CompletedExceptionally ? tmp_2 : null;
+  node.b11(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.zx_1);
+  return NonDisposableHandle_instance;
+};
+protoOf(JobSupport).fy = function (exception) {
+  throw exception;
+};
+protoOf(JobSupport).ez = function (cause) {
+};
+protoOf(JobSupport).fz = function () {
+  return false;
+};
+protoOf(JobSupport).gz = function () {
+  return true;
+};
+protoOf(JobSupport).hz = function (exception) {
+  return false;
+};
+protoOf(JobSupport).yx = function (state) {
+};
+protoOf(JobSupport).ey = function (state) {
+};
+protoOf(JobSupport).toString = function () {
+  return this.iz() + '@' + get_hexAddress(this);
+};
+protoOf(JobSupport).iz = function () {
+  return this.gy() + '{' + stateString(this, this.ny()) + '}';
+};
+protoOf(JobSupport).gy = function () {
+  return get_classSimpleName(this);
+};
+protoOf(JobSupport).jz = function () {
+  var state = this.ny();
+  // Inline function 'kotlin.check' call
+  if (!!(!(state == null) ? isInterface(state, Incomplete) : false)) {
+    var message = 'This job has not completed yet';
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  return _get_exceptionOrNull__b3j7js(this, state);
+};
+protoOf(JobSupport).kz = function () {
+  var state = this.ny();
+  // Inline function 'kotlin.check' call
+  if (!!(!(state == null) ? isInterface(state, Incomplete) : false)) {
+    var message = 'This job has not completed yet';
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  if (state instanceof CompletedExceptionally)
+    throw state.zx_1;
+  return unboxState(state);
+};
+function boxIncomplete(_this__u8e3s4) {
+  _init_properties_JobSupport_kt__68f172();
+  var tmp;
+  if (!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, Incomplete) : false) {
+    tmp = new IncompleteStateBox(_this__u8e3s4);
+  } else {
+    tmp = _this__u8e3s4;
+  }
+  return tmp;
+}
+function InactiveNodeList(list) {
+  this.u13_1 = list;
+}
+protoOf(InactiveNodeList).e12 = function () {
+  return this.u13_1;
+};
+protoOf(InactiveNodeList).ux = function () {
+  return false;
+};
+protoOf(InactiveNodeList).toString = function () {
+  return get_DEBUG() ? this.u13_1.m13('New') : anyToString(this);
+};
+function InvokeOnCompletion(handler) {
+  JobNode.call(this);
+  this.s14_1 = handler;
+}
+protoOf(InvokeOnCompletion).y11 = function () {
+  return false;
+};
+protoOf(InvokeOnCompletion).b11 = function (cause) {
+  return this.s14_1(cause);
+};
+function InvokeOnCancelling(handler) {
+  JobNode.call(this);
+  this.x14_1 = handler;
+  this.y14_1 = atomic$boolean$1(false);
+}
+protoOf(InvokeOnCancelling).y11 = function () {
+  return true;
+};
+protoOf(InvokeOnCancelling).b11 = function (cause) {
+  if (this.y14_1.atomicfu$compareAndSet(false, true))
+    this.x14_1(cause);
+};
+function ChildHandleNode(childJob) {
+  JobNode.call(this);
+  this.e14_1 = childJob;
+}
+protoOf(ChildHandleNode).y11 = function () {
+  return true;
+};
+protoOf(ChildHandleNode).b11 = function (cause) {
+  return this.e14_1.zy(this.d12());
+};
+protoOf(ChildHandleNode).az = function (cause) {
+  return this.d12().az(cause);
+};
+function unboxState(_this__u8e3s4) {
+  _init_properties_JobSupport_kt__68f172();
+  var tmp0_safe_receiver = _this__u8e3s4 instanceof IncompleteStateBox ? _this__u8e3s4 : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z14_1;
+  return tmp1_elvis_lhs == null ? _this__u8e3s4 : tmp1_elvis_lhs;
+}
+function IncompleteStateBox(state) {
+  this.z14_1 = state;
+}
+var properties_initialized_JobSupport_kt_5iq8a4;
+function _init_properties_JobSupport_kt__68f172() {
+  if (!properties_initialized_JobSupport_kt_5iq8a4) {
+    properties_initialized_JobSupport_kt_5iq8a4 = true;
+    COMPLETING_ALREADY = new Symbol('COMPLETING_ALREADY');
+    COMPLETING_WAITING_CHILDREN = new Symbol('COMPLETING_WAITING_CHILDREN');
+    COMPLETING_RETRY = new Symbol('COMPLETING_RETRY');
+    TOO_LATE_TO_CANCEL = new Symbol('TOO_LATE_TO_CANCEL');
+    SEALED = new Symbol('SEALED');
+    EMPTY_NEW = new Empty(false);
+    EMPTY_ACTIVE = new Empty(true);
+  }
+}
+function MainCoroutineDispatcher() {
+  CoroutineDispatcher.call(this);
+}
+protoOf(MainCoroutineDispatcher).toString = function () {
+  var tmp0_elvis_lhs = this.c15();
+  return tmp0_elvis_lhs == null ? get_classSimpleName(this) + '@' + get_hexAddress(this) : tmp0_elvis_lhs;
+};
+protoOf(MainCoroutineDispatcher).c15 = function () {
+  var main = Dispatchers_getInstance().h15();
+  if (this === main)
+    return 'Dispatchers.Main';
+  var tmp;
+  try {
+    tmp = main.b15();
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof UnsupportedOperationException) {
+      var e = $p;
+      tmp_0 = null;
+    } else {
+      throw $p;
+    }
+    tmp = tmp_0;
+  }
+  var immediate = tmp;
+  if (this === immediate)
+    return 'Dispatchers.Main.immediate';
+  return null;
+};
+function TimeoutCancellationException() {
+}
+function Unconfined() {
+  Unconfined_instance = this;
+  CoroutineDispatcher.call(this);
+}
+protoOf(Unconfined).n12 = function (context) {
+  return false;
+};
+protoOf(Unconfined).o12 = function (context, block) {
+  var yieldContext = context.h7(Key_instance_3);
+  if (!(yieldContext == null)) {
+    yieldContext.k15_1 = true;
+    return Unit_instance;
+  }
+  throw UnsupportedOperationException_init_$Create$('Dispatchers.Unconfined.dispatch function can only be used by the yield function. If you wrap Unconfined dispatcher in your code, make sure you properly delegate isDispatchNeeded and dispatch calls.');
+};
+protoOf(Unconfined).toString = function () {
+  return 'Dispatchers.Unconfined';
+};
+var Unconfined_instance;
+function Unconfined_getInstance() {
+  if (Unconfined_instance == null)
+    new Unconfined();
+  return Unconfined_instance;
+}
+function Key_2() {
+}
+var Key_instance_3;
+function Key_getInstance_2() {
+  return Key_instance_3;
+}
+function Segment() {
+}
+function ConcurrentLinkedListNode() {
+}
+function handleUncaughtCoroutineException(context, exception) {
+  var _iterator__ex2g4s = get_platformExceptionHandlers().f();
+  while (_iterator__ex2g4s.g()) {
+    var handler = _iterator__ex2g4s.h();
+    try {
+      handler.r12(context, exception);
+    } catch ($p) {
+      if ($p instanceof ExceptionSuccessfullyProcessed) {
+        var _unused_var__etf5q3 = $p;
+        return Unit_instance;
+      } else {
+        if ($p instanceof Error) {
+          var t = $p;
+          propagateExceptionFinalResort(handlerException(exception, t));
+        } else {
+          throw $p;
+        }
+      }
+    }
+  }
+  try {
+    addSuppressed(exception, new DiagnosticCoroutineContextException(context));
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+    } else {
+      throw $p;
+    }
+  }
+  propagateExceptionFinalResort(exception);
+}
+function ExceptionSuccessfullyProcessed() {
+}
+function get_UNDEFINED() {
+  _init_properties_DispatchedContinuation_kt__tnmqc0();
+  return UNDEFINED;
+}
+var UNDEFINED;
+function get_REUSABLE_CLAIMED() {
+  _init_properties_DispatchedContinuation_kt__tnmqc0();
+  return REUSABLE_CLAIMED;
+}
+var REUSABLE_CLAIMED;
+function _get_reusableCancellableContinuation__9qex09($this) {
+  var tmp = $this.f10_1.kotlinx$atomicfu$value;
+  return tmp instanceof CancellableContinuationImpl ? tmp : null;
+}
+function DispatchedContinuation(dispatcher, continuation) {
+  DispatchedTask.call(this, -1);
+  this.b10_1 = dispatcher;
+  this.c10_1 = continuation;
+  this.d10_1 = get_UNDEFINED();
+  this.e10_1 = threadContextElements(this.a7());
+  this.f10_1 = atomic$ref$1(null);
+}
+protoOf(DispatchedContinuation).g10 = function () {
+  return !(this.f10_1.kotlinx$atomicfu$value == null);
+};
+protoOf(DispatchedContinuation).l15 = function () {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = this.f10_1;
+  while (true) {
+    if (!(this_0.kotlinx$atomicfu$value === get_REUSABLE_CLAIMED()))
+      return Unit_instance;
+  }
+};
+protoOf(DispatchedContinuation).p12 = function () {
+  this.l15();
+  var tmp0_safe_receiver = _get_reusableCancellableContinuation__9qex09(this);
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    tmp0_safe_receiver.k10();
+  }
+};
+protoOf(DispatchedContinuation).h11 = function (continuation) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = this.f10_1;
+  while (true) {
+    var state = this_0.kotlinx$atomicfu$value;
+    if (state === get_REUSABLE_CLAIMED()) {
+      if (this.f10_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), continuation))
+        return null;
+    } else {
+      if (state instanceof Error) {
+        // Inline function 'kotlin.require' call
+        // Inline function 'kotlin.require' call
+        if (!this.f10_1.atomicfu$compareAndSet(state, null)) {
+          var message = 'Failed requirement.';
+          throw IllegalArgumentException_init_$Create$(toString(message));
+        }
+        return state;
+      } else {
+        // Inline function 'kotlin.error' call
+        var message_0 = 'Inconsistent state ' + toString_0(state);
+        throw IllegalStateException_init_$Create$(toString(message_0));
+      }
+    }
+  }
+};
+protoOf(DispatchedContinuation).i10 = function (cause) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = this.f10_1;
+  while (true) {
+    var state = this_0.kotlinx$atomicfu$value;
+    if (equals(state, get_REUSABLE_CLAIMED())) {
+      if (this.f10_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), cause))
+        return true;
+    } else {
+      if (state instanceof Error)
+        return true;
+      else {
+        if (this.f10_1.atomicfu$compareAndSet(state, null))
+          return false;
+      }
+    }
+  }
+};
+protoOf(DispatchedContinuation).o10 = function () {
+  var state = this.d10_1;
+  // Inline function 'kotlinx.coroutines.assert' call
+  this.d10_1 = get_UNDEFINED();
+  return state;
+};
+protoOf(DispatchedContinuation).l10 = function () {
+  return this;
+};
+protoOf(DispatchedContinuation).f7 = function (result) {
+  var state = toState_0(result);
+  if (safeIsDispatchNeeded(this.b10_1, this.a7())) {
+    this.d10_1 = state;
+    this.h10_1 = 0;
+    safeDispatch(this.b10_1, this.a7(), this);
+  } else {
+    $l$block: {
+      // Inline function 'kotlinx.coroutines.internal.executeUnconfined' call
+      // Inline function 'kotlinx.coroutines.assert' call
+      var eventLoop = ThreadLocalEventLoop_getInstance().e13();
+      if (false && eventLoop.z12()) {
+        break $l$block;
+      }
+      var tmp;
+      if (eventLoop.y12()) {
+        this.d10_1 = state;
+        this.h10_1 = 0;
+        eventLoop.x12(this);
+        tmp = true;
+      } else {
+        // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+        eventLoop.a13(true);
+        try {
+          this.a7();
+          // Inline function 'kotlinx.coroutines.withCoroutineContext' call
+          this.e10_1;
+          this.c10_1.f7(result);
+          $l$loop: while (eventLoop.w12()) {
+          }
+        } catch ($p) {
+          if ($p instanceof Error) {
+            var e = $p;
+            this.r11(e);
+          } else {
+            throw $p;
+          }
+        }
+        finally {
+          eventLoop.b13(true);
+        }
+        tmp = false;
+      }
+    }
+  }
+};
+protoOf(DispatchedContinuation).toString = function () {
+  return 'DispatchedContinuation[' + this.b10_1.toString() + ', ' + toDebugString(this.c10_1) + ']';
+};
+protoOf(DispatchedContinuation).a7 = function () {
+  return this.c10_1.a7();
+};
+function safeDispatch(_this__u8e3s4, context, runnable) {
+  _init_properties_DispatchedContinuation_kt__tnmqc0();
+  try {
+    _this__u8e3s4.o12(context, runnable);
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      throw new DispatchException(e, _this__u8e3s4, context);
+    } else {
+      throw $p;
+    }
+  }
+}
+function safeIsDispatchNeeded(_this__u8e3s4, context) {
+  _init_properties_DispatchedContinuation_kt__tnmqc0();
+  try {
+    return _this__u8e3s4.n12(context);
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      throw new DispatchException(e, _this__u8e3s4, context);
+    } else {
+      throw $p;
+    }
+  }
+}
+function resumeCancellableWithInternal(_this__u8e3s4, result) {
+  _init_properties_DispatchedContinuation_kt__tnmqc0();
+  var tmp;
+  if (_this__u8e3s4 instanceof DispatchedContinuation) {
+    // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeCancellableWith' call
+    var state = toState_0(result);
+    if (safeIsDispatchNeeded(_this__u8e3s4.b10_1, _this__u8e3s4.a7())) {
+      _this__u8e3s4.d10_1 = state;
+      _this__u8e3s4.h10_1 = 1;
+      safeDispatch(_this__u8e3s4.b10_1, _this__u8e3s4.a7(), _this__u8e3s4);
+    } else {
+      $l$block: {
+        // Inline function 'kotlinx.coroutines.internal.executeUnconfined' call
+        // Inline function 'kotlinx.coroutines.assert' call
+        var eventLoop = ThreadLocalEventLoop_getInstance().e13();
+        if (false && eventLoop.z12()) {
+          break $l$block;
+        }
+        var tmp_0;
+        if (eventLoop.y12()) {
+          _this__u8e3s4.d10_1 = state;
+          _this__u8e3s4.h10_1 = 1;
+          eventLoop.x12(_this__u8e3s4);
+          tmp_0 = true;
+        } else {
+          // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+          eventLoop.a13(true);
+          try {
+            var tmp$ret$4;
+            $l$block_0: {
+              // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeCancelled' call
+              var job = _this__u8e3s4.a7().h7(Key_instance_2);
+              if (!(job == null) && !job.ux()) {
+                var cause = job.ry();
+                _this__u8e3s4.p10(state, cause);
+                // Inline function 'kotlin.coroutines.resumeWithException' call
+                // Inline function 'kotlin.Companion.failure' call
+                var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(cause));
+                _this__u8e3s4.f7(tmp$ret$2);
+                tmp$ret$4 = true;
+                break $l$block_0;
+              }
+              tmp$ret$4 = false;
+            }
+            if (!tmp$ret$4) {
+              // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeUndispatchedWith' call
+              _this__u8e3s4.c10_1;
+              // Inline function 'kotlinx.coroutines.withContinuationContext' call
+              _this__u8e3s4.e10_1;
+              _this__u8e3s4.c10_1.f7(result);
+            }
+            $l$loop: while (eventLoop.w12()) {
+            }
+          } catch ($p) {
+            if ($p instanceof Error) {
+              var e = $p;
+              _this__u8e3s4.r11(e);
+            } else {
+              throw $p;
+            }
+          }
+          finally {
+            eventLoop.b13(true);
+          }
+          tmp_0 = false;
+        }
+      }
+    }
+    tmp = Unit_instance;
+  } else {
+    _this__u8e3s4.f7(result);
+    tmp = Unit_instance;
+  }
+  return tmp;
+}
+var properties_initialized_DispatchedContinuation_kt_2siadq;
+function _init_properties_DispatchedContinuation_kt__tnmqc0() {
+  if (!properties_initialized_DispatchedContinuation_kt_2siadq) {
+    properties_initialized_DispatchedContinuation_kt_2siadq = true;
+    UNDEFINED = new Symbol('UNDEFINED');
+    REUSABLE_CLAIMED = new Symbol('REUSABLE_CLAIMED');
+  }
+}
+function DispatchedTask(resumeMode) {
+  SchedulerTask.call(this);
+  this.h10_1 = resumeMode;
+}
+protoOf(DispatchedTask).p10 = function (takenState, cause) {
+};
+protoOf(DispatchedTask).g11 = function (state) {
+  return (state == null ? true : !(state == null)) ? state : THROW_CCE();
+};
+protoOf(DispatchedTask).o11 = function (state) {
+  var tmp0_safe_receiver = state instanceof CompletedExceptionally ? state : null;
+  return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.zx_1;
+};
+protoOf(DispatchedTask).q11 = function () {
+  // Inline function 'kotlinx.coroutines.assert' call
+  try {
+    var tmp = this.l10();
+    var delegate = tmp instanceof DispatchedContinuation ? tmp : THROW_CCE();
+    var continuation = delegate.c10_1;
+    // Inline function 'kotlinx.coroutines.withContinuationContext' call
+    delegate.e10_1;
+    var context = continuation.a7();
+    var state = this.o10();
+    var exception = this.o11(state);
+    var job = exception == null && get_isCancellableMode(this.h10_1) ? context.h7(Key_instance_2) : null;
+    if (!(job == null) && !job.ux()) {
+      var cause = job.ry();
+      this.p10(state, cause);
+      // Inline function 'kotlinx.coroutines.resumeWithStackTrace' call
+      // Inline function 'kotlin.Companion.failure' call
+      var exception_0 = recoverStackTrace(cause, continuation);
+      var tmp$ret$1 = _Result___init__impl__xyqfz8(createFailure(exception_0));
+      continuation.f7(tmp$ret$1);
+    } else {
+      if (!(exception == null)) {
+        // Inline function 'kotlin.coroutines.resumeWithException' call
+        // Inline function 'kotlin.Companion.failure' call
+        var tmp$ret$3 = _Result___init__impl__xyqfz8(createFailure(exception));
+        continuation.f7(tmp$ret$3);
+      } else {
+        // Inline function 'kotlin.coroutines.resume' call
+        // Inline function 'kotlin.Companion.success' call
+        var value = this.g11(state);
+        var tmp$ret$5 = _Result___init__impl__xyqfz8(value);
+        continuation.f7(tmp$ret$5);
+      }
+    }
+  } catch ($p) {
+    if ($p instanceof DispatchException) {
+      var e = $p;
+      handleCoroutineException(this.l10().a7(), e.q12_1);
+    } else {
+      if ($p instanceof Error) {
+        var e_0 = $p;
+        this.r11(e_0);
+      } else {
+        throw $p;
+      }
+    }
+  }
+};
+protoOf(DispatchedTask).r11 = function (exception) {
+  var reason = new CoroutinesInternalError('Fatal exception in coroutines machinery for ' + toString(this) + '. ' + "Please read KDoc to 'handleFatalException' method and report this incident to maintainers", exception);
+  handleCoroutineException(this.l10().a7(), reason);
+};
+function get_isReusableMode(_this__u8e3s4) {
+  return _this__u8e3s4 === 2;
+}
+function get_isCancellableMode(_this__u8e3s4) {
+  return _this__u8e3s4 === 1 || _this__u8e3s4 === 2;
+}
+function dispatch(_this__u8e3s4, mode) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  var delegate = _this__u8e3s4.l10();
+  var undispatched = mode === 4;
+  var tmp;
+  var tmp_0;
+  if (!undispatched) {
+    tmp_0 = delegate instanceof DispatchedContinuation;
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = get_isCancellableMode(mode) === get_isCancellableMode(_this__u8e3s4.h10_1);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    var dispatcher = delegate.b10_1;
+    var context = delegate.a7();
+    if (safeIsDispatchNeeded(dispatcher, context)) {
+      safeDispatch(dispatcher, context, _this__u8e3s4);
+    } else {
+      resumeUnconfined(_this__u8e3s4);
+    }
+  } else {
+    resume(_this__u8e3s4, delegate, undispatched);
+  }
+}
+function DispatchException(cause, dispatcher, context) {
+  Exception_init_$Init$('Coroutine dispatcher ' + dispatcher.toString() + ' threw an exception, context = ' + toString(context), cause, this);
+  captureStack(this, DispatchException);
+  this.q12_1 = cause;
+  delete this.cause;
+}
+protoOf(DispatchException).l7 = function () {
+  return this.q12_1;
+};
+function resumeUnconfined(_this__u8e3s4) {
+  var eventLoop = ThreadLocalEventLoop_getInstance().e13();
+  if (eventLoop.y12()) {
+    eventLoop.x12(_this__u8e3s4);
+  } else {
+    // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+    eventLoop.a13(true);
+    try {
+      resume(_this__u8e3s4, _this__u8e3s4.l10(), true);
+      $l$loop: while (eventLoop.w12()) {
+      }
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var e = $p;
+        _this__u8e3s4.r11(e);
+      } else {
+        throw $p;
+      }
+    }
+    finally {
+      eventLoop.b13(true);
+    }
+  }
+}
+function resume(_this__u8e3s4, delegate, undispatched) {
+  var state = _this__u8e3s4.o10();
+  var exception = _this__u8e3s4.o11(state);
+  var tmp;
+  if (!(exception == null)) {
+    // Inline function 'kotlin.Companion.failure' call
+    tmp = _Result___init__impl__xyqfz8(createFailure(exception));
+  } else {
+    // Inline function 'kotlin.Companion.success' call
+    var value = _this__u8e3s4.g11(state);
+    tmp = _Result___init__impl__xyqfz8(value);
+  }
+  var result = tmp;
+  if (undispatched) {
+    // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeUndispatchedWith' call
+    var this_0 = delegate instanceof DispatchedContinuation ? delegate : THROW_CCE();
+    this_0.c10_1;
+    // Inline function 'kotlinx.coroutines.withContinuationContext' call
+    this_0.e10_1;
+    this_0.c10_1.f7(result);
+  } else {
+    delegate.f7(result);
+  }
+}
+function Symbol(symbol) {
+  this.m15_1 = symbol;
+}
+protoOf(Symbol).toString = function () {
+  return '<' + this.m15_1 + '>';
+};
+function startCoroutineCancellable(_this__u8e3s4, receiver, completion) {
+  // Inline function 'kotlinx.coroutines.intrinsics.runSafely' call
+  try {
+    var tmp = intercepted(createCoroutineUnintercepted(_this__u8e3s4, receiver, completion));
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+    resumeCancellableWithInternal(tmp, tmp$ret$0);
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      dispatcherFailure(completion, e);
+    } else {
+      throw $p;
+    }
+  }
+  return Unit_instance;
+}
+function startCoroutineCancellable_0(_this__u8e3s4, fatalCompletion) {
+  // Inline function 'kotlinx.coroutines.intrinsics.runSafely' call
+  try {
+    var tmp = intercepted(_this__u8e3s4);
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+    resumeCancellableWithInternal(tmp, tmp$ret$0);
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var e = $p;
+      dispatcherFailure(fatalCompletion, e);
+    } else {
+      throw $p;
+    }
+  }
+  return Unit_instance;
+}
+function dispatcherFailure(completion, e) {
+  var tmp;
+  if (e instanceof DispatchException) {
+    tmp = e.q12_1;
+  } else {
+    tmp = e;
+  }
+  var reportException = tmp;
+  // Inline function 'kotlin.Companion.failure' call
+  var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(reportException));
+  completion.f7(tmp$ret$0);
+  throw reportException;
+}
+function startCoroutineUndispatched(_this__u8e3s4, receiver, completion) {
+  // Inline function 'kotlinx.coroutines.internal.probeCoroutineCreated' call
+  var actualCompletion = completion;
+  var tmp;
+  try {
+    // Inline function 'kotlinx.coroutines.withCoroutineContext' call
+    actualCompletion.a7();
+    // Inline function 'kotlinx.coroutines.internal.probeCoroutineResumed' call
+    // Inline function 'kotlin.coroutines.intrinsics.startCoroutineUninterceptedOrReturn' call
+    tmp = startCoroutineUninterceptedOrReturnNonGeneratorVersion(_this__u8e3s4, receiver, actualCompletion);
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var e = $p;
+      var tmp_1;
+      if (e instanceof DispatchException) {
+        tmp_1 = e.q12_1;
+      } else {
+        tmp_1 = e;
+      }
+      var reportException = tmp_1;
+      // Inline function 'kotlin.coroutines.resumeWithException' call
+      // Inline function 'kotlin.Companion.failure' call
+      var tmp$ret$5 = _Result___init__impl__xyqfz8(createFailure(reportException));
+      actualCompletion.f7(tmp$ret$5);
+      return Unit_instance;
+    } else {
+      throw $p;
+    }
+  }
+  var value = tmp;
+  if (!(value === get_COROUTINE_SUSPENDED())) {
+    // Inline function 'kotlin.coroutines.resume' call
+    // Inline function 'kotlin.Companion.success' call
+    var value_0 = (value == null ? true : !(value == null)) ? value : THROW_CCE();
+    var tmp$ret$7 = _Result___init__impl__xyqfz8(value_0);
+    actualCompletion.f7(tmp$ret$7);
+  }
+}
+function createDefaultDispatcher() {
+  var tmp;
+  if (isJsdom()) {
+    tmp = NodeDispatcher_getInstance();
+  } else {
+    var tmp_0;
+    var tmp_1;
+    if (!(typeof window === 'undefined')) {
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp_1 = window != null;
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp_0 = !(typeof window.addEventListener === 'undefined');
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = asCoroutineDispatcher(window);
+    } else {
+      if (typeof process === 'undefined' || typeof process.nextTick === 'undefined') {
+        tmp = SetTimeoutDispatcher_getInstance();
+      } else {
+        tmp = NodeDispatcher_getInstance();
+      }
+    }
+  }
+  return tmp;
+}
+function isJsdom() {
+  return !(typeof navigator === 'undefined') && navigator != null && navigator.userAgent != null && !(typeof navigator.userAgent === 'undefined') && !(typeof navigator.userAgent.match === 'undefined') && navigator.userAgent.match('\\bjsdom\\b');
+}
+var counter;
+function get_DEBUG() {
+  return DEBUG;
+}
+var DEBUG;
+function get_classSimpleName(_this__u8e3s4) {
+  var tmp0_elvis_lhs = getKClassFromExpression(_this__u8e3s4).g8();
+  return tmp0_elvis_lhs == null ? 'Unknown' : tmp0_elvis_lhs;
+}
+function get_hexAddress(_this__u8e3s4) {
+  // Inline function 'kotlin.js.asDynamic' call
+  var result = _this__u8e3s4.__debug_counter;
+  if (!(typeof result === 'number')) {
+    counter = counter + 1 | 0;
+    result = counter;
+    // Inline function 'kotlin.js.asDynamic' call
+    _this__u8e3s4.__debug_counter = result;
+  }
+  return ((!(result == null) ? typeof result === 'number' : false) ? result : THROW_CCE()).toString();
+}
+function NodeDispatcher() {
+  NodeDispatcher_instance = this;
+  SetTimeoutBasedDispatcher.call(this);
+}
+protoOf(NodeDispatcher).p15 = function () {
+  process.nextTick(this.w15_1.u15_1);
+};
+var NodeDispatcher_instance;
+function NodeDispatcher_getInstance() {
+  if (NodeDispatcher_instance == null)
+    new NodeDispatcher();
+  return NodeDispatcher_instance;
+}
+function ScheduledMessageQueue$processQueue$lambda(this$0) {
+  return function () {
+    this$0.a16();
+    return Unit_instance;
+  };
+}
+function ScheduledMessageQueue(dispatcher) {
+  MessageQueue.call(this);
+  this.t15_1 = dispatcher;
+  var tmp = this;
+  tmp.u15_1 = ScheduledMessageQueue$processQueue$lambda(this);
+}
+protoOf(ScheduledMessageQueue).b16 = function () {
+  this.t15_1.p15();
+};
+protoOf(ScheduledMessageQueue).c16 = function () {
+  setTimeout(this.u15_1, 0);
+};
+protoOf(ScheduledMessageQueue).d16 = function (timeout) {
+  setTimeout(this.u15_1, timeout);
+};
+function WindowMessageQueue$lambda(this$0) {
+  return function (event) {
+    var tmp;
+    if (event.source == this$0.m16_1 && event.data == this$0.n16_1) {
+      event.stopPropagation();
+      this$0.a16();
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function WindowMessageQueue$schedule$lambda(this$0) {
+  return function (it) {
+    this$0.a16();
+    return Unit_instance;
+  };
+}
+function WindowMessageQueue(window_0) {
+  MessageQueue.call(this);
+  this.m16_1 = window_0;
+  this.n16_1 = 'dispatchCoroutine';
+  this.m16_1.addEventListener('message', WindowMessageQueue$lambda(this), true);
+}
+protoOf(WindowMessageQueue).b16 = function () {
+  var tmp = Promise.resolve(Unit_instance);
+  tmp.then(WindowMessageQueue$schedule$lambda(this));
+};
+protoOf(WindowMessageQueue).c16 = function () {
+  this.m16_1.postMessage(this.n16_1, '*');
+};
+function toThrowable(_this__u8e3s4) {
+  var tmp0_elvis_lhs = _this__u8e3s4 instanceof Error ? _this__u8e3s4 : null;
+  return tmp0_elvis_lhs == null ? Exception_init_$Create$("Promise resolved with a non-Throwable exception '" + _this__u8e3s4.toString() + "' (type " + toString(getKClassFromExpression(_this__u8e3s4)) + ')') : tmp0_elvis_lhs;
+}
+function toJsPromiseError(_this__u8e3s4) {
+  return _this__u8e3s4;
+}
+function asCoroutineDispatcher(_this__u8e3s4) {
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp0_elvis_lhs = _this__u8e3s4.coroutineDispatcher;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlin.also' call
+    var this_0 = new WindowDispatcher(_this__u8e3s4);
+    // Inline function 'kotlin.js.asDynamic' call
+    _this__u8e3s4.coroutineDispatcher = this_0;
+    tmp = this_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function toDebugString(_this__u8e3s4) {
+  return toString(_this__u8e3s4);
+}
+function newCoroutineContext(_this__u8e3s4, context) {
+  var combined = _this__u8e3s4.tx().ob(context);
+  return !(combined === Dispatchers_getInstance().d15_1) && combined.h7(Key_instance) == null ? combined.ob(Dispatchers_getInstance().d15_1) : combined;
+}
+function get_coroutineName(_this__u8e3s4) {
+  return null;
+}
+function Dispatchers() {
+  Dispatchers_instance = this;
+  this.d15_1 = createDefaultDispatcher();
+  this.e15_1 = Unconfined_getInstance();
+  this.f15_1 = new JsMainDispatcher(this.d15_1, false);
+  this.g15_1 = null;
+}
+protoOf(Dispatchers).h15 = function () {
+  var tmp0_elvis_lhs = this.g15_1;
+  return tmp0_elvis_lhs == null ? this.f15_1 : tmp0_elvis_lhs;
+};
+var Dispatchers_instance;
+function Dispatchers_getInstance() {
+  if (Dispatchers_instance == null)
+    new Dispatchers();
+  return Dispatchers_instance;
+}
+function JsMainDispatcher(delegate, invokeImmediately) {
+  MainCoroutineDispatcher.call(this);
+  this.p16_1 = delegate;
+  this.q16_1 = invokeImmediately;
+  this.r16_1 = this.q16_1 ? this : new JsMainDispatcher(this.p16_1, true);
+}
+protoOf(JsMainDispatcher).b15 = function () {
+  return this.r16_1;
+};
+protoOf(JsMainDispatcher).n12 = function (context) {
+  return !this.q16_1;
+};
+protoOf(JsMainDispatcher).o12 = function (context, block) {
+  return this.p16_1.o12(context, block);
+};
+protoOf(JsMainDispatcher).toString = function () {
+  var tmp0_elvis_lhs = this.c15();
+  return tmp0_elvis_lhs == null ? this.p16_1.toString() : tmp0_elvis_lhs;
+};
+function JobCancellationException(message, cause, job) {
+  CancellationException_init_$Init$(message, cause, this);
+  captureStack(this, JobCancellationException);
+  this.s16_1 = job;
+}
+protoOf(JobCancellationException).toString = function () {
+  return protoOf(CancellationException).toString.call(this) + '; job=' + toString(this.s16_1);
+};
+protoOf(JobCancellationException).equals = function (other) {
+  var tmp;
+  if (other === this) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    var tmp_1;
+    var tmp_2;
+    if (other instanceof JobCancellationException) {
+      tmp_2 = other.message == this.message;
+    } else {
+      tmp_2 = false;
+    }
+    if (tmp_2) {
+      tmp_1 = equals(other.s16_1, this.s16_1);
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      tmp_0 = equals(other.cause, this.cause);
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(JobCancellationException).hashCode = function () {
+  var tmp = imul(imul(getStringHashCode(ensureNotNull(this.message)), 31) + hashCode(this.s16_1) | 0, 31);
+  var tmp0_safe_receiver = this.cause;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+  return tmp + (tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs) | 0;
+};
+function Runnable() {
+}
+function SchedulerTask() {
+}
+function identitySet(expectedSize) {
+  return HashSet_init_$Create$(expectedSize);
+}
+function get_platformExceptionHandlers_() {
+  _init_properties_CoroutineExceptionHandlerImpl_kt__37d7wf();
+  return platformExceptionHandlers_;
+}
+var platformExceptionHandlers_;
+function get_platformExceptionHandlers() {
+  _init_properties_CoroutineExceptionHandlerImpl_kt__37d7wf();
+  return get_platformExceptionHandlers_();
+}
+function DiagnosticCoroutineContextException(context) {
+  RuntimeException_init_$Init$_0(toString(context), this);
+  captureStack(this, DiagnosticCoroutineContextException);
+}
+var properties_initialized_CoroutineExceptionHandlerImpl_kt_qhrgvx;
+function _init_properties_CoroutineExceptionHandlerImpl_kt__37d7wf() {
+  if (!properties_initialized_CoroutineExceptionHandlerImpl_kt_qhrgvx) {
+    properties_initialized_CoroutineExceptionHandlerImpl_kt_qhrgvx = true;
+    // Inline function 'kotlin.collections.mutableSetOf' call
+    platformExceptionHandlers_ = LinkedHashSet_init_$Create$();
+  }
+}
+function LockFreeLinkedListHead() {
+  LockFreeLinkedListNode.call(this);
+}
+function LockFreeLinkedListNode() {
+  this.f12_1 = this;
+  this.g12_1 = this;
+  this.h12_1 = false;
+}
+protoOf(LockFreeLinkedListNode).i12 = function (node, permissionsBitmask) {
+  var prev = this.g12_1;
+  var tmp;
+  if (prev instanceof ListClosed) {
+    tmp = ((prev.w16_1 & permissionsBitmask) === 0 && prev.i12(node, permissionsBitmask));
+  } else {
+    node.f12_1 = this;
+    node.g12_1 = prev;
+    prev.f12_1 = node;
+    this.g12_1 = node;
+    tmp = true;
+  }
+  return tmp;
+};
+protoOf(LockFreeLinkedListNode).n13 = function (forbiddenElementsBit) {
+  this.i12(new ListClosed(forbiddenElementsBit), forbiddenElementsBit);
+};
+protoOf(LockFreeLinkedListNode).j12 = function () {
+  if (this.h12_1)
+    return false;
+  var prev = this.g12_1;
+  var next = this.f12_1;
+  prev.f12_1 = next;
+  next.g12_1 = prev;
+  this.h12_1 = true;
+  return true;
+};
+protoOf(LockFreeLinkedListNode).k12 = function (node) {
+  if (!(this.f12_1 === this))
+    return false;
+  this.i12(node, -2147483648);
+  return true;
+};
+function ListClosed(forbiddenElementsBitmask) {
+  LockFreeLinkedListNode.call(this);
+  this.w16_1 = forbiddenElementsBitmask;
+}
+function unwrap(exception) {
+  return exception;
+}
+function recoverStackTrace(exception, continuation) {
+  return exception;
+}
+function SynchronizedObject() {
+}
+function threadContextElements(context) {
+  return 0;
+}
+function CommonThreadLocal() {
+  this.f13_1 = null;
+}
+protoOf(CommonThreadLocal).g13 = function () {
+  var tmp = this.f13_1;
+  return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+};
+protoOf(CommonThreadLocal).h13 = function (value) {
+  this.f13_1 = value;
+};
+function commonThreadLocal(name) {
+  return new CommonThreadLocal();
+}
+function createEventLoop() {
+  return new UnconfinedEventLoop();
+}
+function UnconfinedEventLoop() {
+  EventLoop.call(this);
+}
+protoOf(UnconfinedEventLoop).o12 = function (context, block) {
+  unsupported();
+};
+function unsupported() {
+  throw UnsupportedOperationException_init_$Create$('runBlocking event loop is not supported');
+}
+function promise(_this__u8e3s4, context, start, block) {
+  context = context === VOID ? EmptyCoroutineContext_getInstance() : context;
+  start = start === VOID ? CoroutineStart_DEFAULT_getInstance() : start;
+  return asPromise(async(_this__u8e3s4, context, start, block));
+}
+function await_0(_this__u8e3s4, $completion) {
+  var cancellable = new CancellableContinuationImpl(intercepted($completion), 1);
+  cancellable.m10();
+  var tmp = await$lambda(cancellable);
+  _this__u8e3s4.then(tmp, await$lambda_0(cancellable));
+  return cancellable.e11();
+}
+function asPromise(_this__u8e3s4) {
+  var promise = new Promise(asPromise$lambda(_this__u8e3s4));
+  // Inline function 'kotlin.js.toJsReference' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  promiseSetDeferred(promise, _this__u8e3s4);
+  return promise;
+}
+function promiseSetDeferred(promise, deferred) {
+  promise.deferred = deferred;
+  return Unit_instance;
+}
+function await$lambda($cont) {
+  return function (it) {
+    // Inline function 'kotlin.coroutines.resume' call
+    var this_0 = $cont;
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(it);
+    this_0.f7(tmp$ret$0);
+    return null;
+  };
+}
+function await$lambda_0($cont) {
+  return function (it) {
+    var tmp0 = $cont;
+    // Inline function 'kotlin.coroutines.resumeWithException' call
+    // Inline function 'kotlin.Companion.failure' call
+    var exception = toThrowable(it);
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+    tmp0.f7(tmp$ret$0);
+    return null;
+  };
+}
+function asPromise$lambda$lambda($this_asPromise, $reject, $resolve) {
+  return function (it) {
+    var e = $this_asPromise.jz();
+    var tmp;
+    if (!(e == null)) {
+      tmp = $reject(toJsPromiseError(e));
+    } else {
+      tmp = $resolve($this_asPromise.pz());
+    }
+    return Unit_instance;
+  };
+}
+function asPromise$lambda($this_asPromise) {
+  return function (resolve, reject) {
+    $this_asPromise.uy(asPromise$lambda$lambda($this_asPromise, reject, resolve));
+    return Unit_instance;
+  };
+}
+function propagateExceptionFinalResort(exception) {
+  // Inline function 'kotlin.with' call
+  throwAsyncJsError(exception.message, getKClassFromExpression(exception).g8(), stackTraceToString(exception));
+  return Unit_instance;
+}
+function throwAsyncJsError(message, className, stack) {
+  var error = new Error();
+  error.message = message;
+  error.name = className;
+  error.stack = stack;
+  if (typeof globalThis.reportError === 'function') {
+    // Up-to-date browsers and some non-browser JS runtimes (Deno, Bun)
+    globalThis.reportError(error);
+  } else {
+    // Fallback for old browsers (pre-2022), Node.js
+    setTimeout(function () {
+      throw error;
+    }, 0);
+  }
+}
+function SetTimeoutDispatcher() {
+  SetTimeoutDispatcher_instance = this;
+  SetTimeoutBasedDispatcher.call(this);
+}
+protoOf(SetTimeoutDispatcher).p15 = function () {
+  this.w15_1.d16(0);
+};
+var SetTimeoutDispatcher_instance;
+function SetTimeoutDispatcher_getInstance() {
+  if (SetTimeoutDispatcher_instance == null)
+    new SetTimeoutDispatcher();
+  return SetTimeoutDispatcher_instance;
+}
+function SetTimeoutBasedDispatcher() {
+  CoroutineDispatcher.call(this);
+  this.w15_1 = new ScheduledMessageQueue(this);
+}
+protoOf(SetTimeoutBasedDispatcher).o12 = function (context, block) {
+  this.w15_1.e16(block);
+};
+function MessageQueue() {
+  this.x15_1 = ArrayDeque_init_$Create$();
+  this.y15_1 = 16;
+  this.z15_1 = false;
+}
+protoOf(MessageQueue).e16 = function (element) {
+  this.f16(element);
+  if (!this.z15_1) {
+    this.z15_1 = true;
+    this.b16();
+  }
+};
+protoOf(MessageQueue).a16 = function () {
+  try {
+    // Inline function 'kotlin.repeat' call
+    var times = this.y15_1;
+    var inductionVariable = 0;
+    if (inductionVariable < times)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp0_elvis_lhs = removeFirstOrNull(this);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          return Unit_instance;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var element = tmp;
+        element.q11();
+      }
+       while (inductionVariable < times);
+  }finally {
+    if (this.p()) {
+      this.z15_1 = false;
+    } else {
+      this.c16();
+    }
+  }
+};
+protoOf(MessageQueue).f16 = function (element) {
+  return this.x15_1.d(element);
+};
+protoOf(MessageQueue).d = function (element) {
+  return this.f16((!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+};
+protoOf(MessageQueue).g16 = function (elements) {
+  return this.x15_1.o(elements);
+};
+protoOf(MessageQueue).o = function (elements) {
+  return this.g16(elements);
+};
+protoOf(MessageQueue).r1 = function () {
+  this.x15_1.r1();
+};
+protoOf(MessageQueue).h16 = function (index, element) {
+  return this.x15_1.t1(index, element);
+};
+protoOf(MessageQueue).t1 = function (index, element) {
+  return this.h16(index, (!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+};
+protoOf(MessageQueue).u1 = function (index) {
+  return this.x15_1.u1(index);
+};
+protoOf(MessageQueue).m = function (index) {
+  return this.x15_1.m(index);
+};
+protoOf(MessageQueue).p = function () {
+  return this.x15_1.p();
+};
+protoOf(MessageQueue).i16 = function (element) {
+  return this.x15_1.g1(element);
+};
+protoOf(MessageQueue).g1 = function (element) {
+  if (!(!(element == null) ? isInterface(element, Runnable) : false))
+    return false;
+  return this.i16((!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+};
+protoOf(MessageQueue).f = function () {
+  return this.x15_1.f();
+};
+protoOf(MessageQueue).n = function (index) {
+  return this.x15_1.n(index);
+};
+protoOf(MessageQueue).i = function () {
+  return this.x15_1.na_1;
+};
+function WindowDispatcher(window_0) {
+  CoroutineDispatcher.call(this);
+  this.e17_1 = window_0;
+  this.f17_1 = new WindowMessageQueue(this.e17_1);
+}
+protoOf(WindowDispatcher).o12 = function (context, block) {
+  return this.f17_1.e16(block);
+};
+//region block: post-declaration
+protoOf(JobSupport).ob = plus;
+protoOf(JobSupport).h7 = get_0;
+protoOf(JobSupport).nb = fold;
+protoOf(JobSupport).mb = minusKey_0;
+protoOf(CoroutineDispatcher).h7 = get;
+protoOf(CoroutineDispatcher).mb = minusKey;
+defineProp(protoOf(DispatchException), 'cause', function () {
+  return this.l7();
+});
+//endregion
+//region block: init
+Active_instance = new Active();
+Key_instance_1 = new Key_0();
+GlobalScope_instance = new GlobalScope();
+Key_instance_2 = new Key_1();
+NonDisposableHandle_instance = new NonDisposableHandle();
+Key_instance_3 = new Key_2();
+counter = 0;
+DEBUG = false;
+//endregion
+//region block: exports
+export {
+  await_0 as await20nhgj9iqzkt,
+  GlobalScope_instance as GlobalScope_instance1sfulufhd2ijt,
+  CoroutineScope as CoroutineScopefcb5f5dwqcas,
+  promise as promise1ky6tawqaxbt4,
+};
+//endregion
+
+//# sourceMappingURL=kotlinx-coroutines-core.mjs.map