@zenwave360/workspace-mcp 1.0.0-next.0

package/kotlin/kotlinx-coroutines-core.js

@@ -0,0 +1,3577 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './kotlinx-atomicfu.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./kotlinx-atomicfu.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'kotlinx-coroutines-core'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'kotlinx-coroutines-core'.");
+    }
+    if (typeof globalThis['kotlinx-atomicfu'] === 'undefined') {
+      throw new Error("Error loading module 'kotlinx-coroutines-core'. Its dependency 'kotlinx-atomicfu' was not found. Please, check whether 'kotlinx-atomicfu' is loaded prior to 'kotlinx-coroutines-core'.");
+    }
+    globalThis['kotlinx-coroutines-core'] = factory(typeof globalThis['kotlinx-coroutines-core'] === 'undefined' ? {} : globalThis['kotlinx-coroutines-core'], globalThis['kotlin-kotlin-stdlib'], globalThis['kotlinx-atomicfu']);
+  }
+}(function (_, kotlin_kotlin, kotlin_org_jetbrains_kotlinx_atomicfu) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var Unit_instance = kotlin_kotlin.$_$.c2;
+  var protoOf = kotlin_kotlin.$_$.c7;
+  var THROW_CCE = kotlin_kotlin.$_$.t9;
+  var Element = kotlin_kotlin.$_$.i5;
+  var Continuation = kotlin_kotlin.$_$.e5;
+  var initMetadataForClass = kotlin_kotlin.$_$.p6;
+  var VOID = kotlin_kotlin.$_$.a;
+  var EmptyCoroutineContext_getInstance = kotlin_kotlin.$_$.z1;
+  var createCoroutineUnintercepted = kotlin_kotlin.$_$.w4;
+  var isInterface = kotlin_kotlin.$_$.y6;
+  var toString = kotlin_kotlin.$_$.e7;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.a1;
+  var toString_0 = kotlin_kotlin.$_$.ca;
+  var atomic$int$1 = kotlin_org_jetbrains_kotlinx_atomicfu.$_$.c;
+  var atomic$ref$1 = kotlin_org_jetbrains_kotlinx_atomicfu.$_$.b;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.v4;
+  var initMetadataForInterface = kotlin_kotlin.$_$.s6;
+  var initMetadataForObject = kotlin_kotlin.$_$.u6;
+  var hashCode = kotlin_kotlin.$_$.o6;
+  var equals = kotlin_kotlin.$_$.l6;
+  var atomic$boolean$1 = kotlin_org_jetbrains_kotlinx_atomicfu.$_$.a;
+  var CancellationException_init_$Create$ = kotlin_kotlin.$_$.n;
+  var Result__exceptionOrNull_impl_p6xea9 = kotlin_kotlin.$_$.w1;
+  var _Result___get_value__impl__bjfvqg = kotlin_kotlin.$_$.x1;
+  var AbstractCoroutineContextKey = kotlin_kotlin.$_$.a5;
+  var Key_instance = kotlin_kotlin.$_$.y1;
+  var AbstractCoroutineContextElement = kotlin_kotlin.$_$.z4;
+  var get = kotlin_kotlin.$_$.b5;
+  var minusKey = kotlin_kotlin.$_$.c5;
+  var ContinuationInterceptor = kotlin_kotlin.$_$.d5;
+  var RuntimeException_init_$Create$ = kotlin_kotlin.$_$.n1;
+  var addSuppressed = kotlin_kotlin.$_$.v9;
+  var Enum = kotlin_kotlin.$_$.k9;
+  var startCoroutine = kotlin_kotlin.$_$.l5;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.y9;
+  var Long = kotlin_kotlin.$_$.p9;
+  var ArrayDeque_init_$Create$ = kotlin_kotlin.$_$.c;
+  var compare = kotlin_kotlin.$_$.s5;
+  var add = kotlin_kotlin.$_$.p5;
+  var subtract = kotlin_kotlin.$_$.y5;
+  var RuntimeException = kotlin_kotlin.$_$.s9;
+  var RuntimeException_init_$Init$ = kotlin_kotlin.$_$.m1;
+  var captureStack = kotlin_kotlin.$_$.d6;
+  var Error_0 = kotlin_kotlin.$_$.l9;
+  var Error_init_$Init$ = kotlin_kotlin.$_$.t;
+  var StringBuilder_init_$Create$ = kotlin_kotlin.$_$.r;
+  var throwUninitializedPropertyAccessException = kotlin_kotlin.$_$.n5;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.d;
+  var CancellationException = kotlin_kotlin.$_$.u4;
+  var ArrayList = kotlin_kotlin.$_$.f2;
+  var IllegalStateException_init_$Create$_0 = kotlin_kotlin.$_$.b1;
+  var plus = kotlin_kotlin.$_$.j5;
+  var get_0 = kotlin_kotlin.$_$.g5;
+  var fold = kotlin_kotlin.$_$.f5;
+  var minusKey_0 = kotlin_kotlin.$_$.h5;
+  var anyToString = kotlin_kotlin.$_$.a6;
+  var UnsupportedOperationException = kotlin_kotlin.$_$.u9;
+  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.p1;
+  var Exception = kotlin_kotlin.$_$.m9;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.x;
+  var Companion_instance = kotlin_kotlin.$_$.b2;
+  var createFailure = kotlin_kotlin.$_$.w9;
+  var _Result___init__impl__xyqfz8 = kotlin_kotlin.$_$.v1;
+  var Exception_init_$Init$ = kotlin_kotlin.$_$.v;
+  var defineProp = kotlin_kotlin.$_$.k6;
+  var intercepted = kotlin_kotlin.$_$.x4;
+  var startCoroutineUninterceptedOrReturnNonGeneratorVersion = kotlin_kotlin.$_$.y4;
+  var getKClassFromExpression = kotlin_kotlin.$_$.h7;
+  var Exception_init_$Create$ = kotlin_kotlin.$_$.u;
+  var CancellationException_init_$Init$ = kotlin_kotlin.$_$.o;
+  var ensureNotNull = kotlin_kotlin.$_$.x9;
+  var getStringHashCode = kotlin_kotlin.$_$.n6;
+  var HashSet_init_$Create$ = kotlin_kotlin.$_$.h;
+  var RuntimeException_init_$Init$_0 = kotlin_kotlin.$_$.k1;
+  var LinkedHashSet_init_$Create$ = kotlin_kotlin.$_$.m;
+  var stackTraceToString = kotlin_kotlin.$_$.ba;
+  var removeFirstOrNull = kotlin_kotlin.$_$.k4;
+  var KtMutableList = kotlin_kotlin.$_$.k2;
+  //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.r4t(parentContext.m8(Key_instance_2));
+    }
+    this.u4t_1 = parentContext.xe(this);
+  }
+  protoOf(AbstractCoroutine).f8 = function () {
+    return this.u4t_1;
+  };
+  protoOf(AbstractCoroutine).v4t = function () {
+    return this.u4t_1;
+  };
+  protoOf(AbstractCoroutine).w4t = function () {
+    return protoOf(JobSupport).w4t.call(this);
+  };
+  protoOf(AbstractCoroutine).x4t = function (value) {
+  };
+  protoOf(AbstractCoroutine).y4t = function (cause, handled) {
+  };
+  protoOf(AbstractCoroutine).z4t = function () {
+    return get_classSimpleName(this) + ' was cancelled';
+  };
+  protoOf(AbstractCoroutine).a4u = function (state) {
+    if (state instanceof CompletedExceptionally) {
+      this.y4t(state.b4u_1, state.d4u());
+    } else {
+      this.x4t((state == null ? true : !(state == null)) ? state : THROW_CCE());
+    }
+  };
+  protoOf(AbstractCoroutine).k8 = function (result) {
+    var state = this.e4u(toState_0(result));
+    if (state === get_COMPLETING_WAITING_CHILDREN())
+      return Unit_instance;
+    this.f4u(state);
+  };
+  protoOf(AbstractCoroutine).f4u = function (state) {
+    return this.g4u(state);
+  };
+  protoOf(AbstractCoroutine).h4u = function (exception) {
+    handleCoroutineException(this.u4t_1, exception);
+  };
+  protoOf(AbstractCoroutine).i4u = function () {
+    var tmp0_elvis_lhs = get_coroutineName(this.u4t_1);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return protoOf(JobSupport).i4u.call(this);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var coroutineName = tmp;
+    return '"' + coroutineName + '":' + protoOf(JobSupport).i4u.call(this);
+  };
+  protoOf(AbstractCoroutine).j4u = function (start, receiver, block) {
+    start.m4u(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.n4v() ? new LazyDeferredCoroutine(newContext, block) : new DeferredCoroutine(newContext, true);
+    coroutine.j4u(start, coroutine, block);
+    return coroutine;
+  }
+  function DeferredCoroutine(parentContext, active) {
+    AbstractCoroutine.call(this, parentContext, true, active);
+  }
+  protoOf(DeferredCoroutine).r4v = function () {
+    var tmp = this.m4v();
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  function LazyDeferredCoroutine(parentContext, block) {
+    DeferredCoroutine.call(this, parentContext, false);
+    this.v4v_1 = createCoroutineUnintercepted(block, this, this);
+  }
+  protoOf(LazyDeferredCoroutine).s4u = function () {
+    startCoroutineCancellable_0(this.v4v_1, this);
+  };
+  function _get_parentHandle__f8dcex($this) {
+    return $this.b4w_1.kotlinx$atomicfu$value;
+  }
+  function _get_stateDebugRepresentation__bf18u4($this) {
+    var tmp0_subject = $this.p4u();
+    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.j4w_1)) {
+      var tmp_0 = $this.x4v_1;
+      tmp = (tmp_0 instanceof DispatchedContinuation ? tmp_0 : THROW_CCE()).i4w();
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  function cancelLater($this, cause) {
+    if (!isReusable($this))
+      return false;
+    var tmp = $this.x4v_1;
+    var dispatched = tmp instanceof DispatchedContinuation ? tmp : THROW_CCE();
+    return dispatched.k4w(cause);
+  }
+  function callSegmentOnCancellation($this, segment, cause) {
+    // Inline function 'kotlinx.coroutines.index' call
+    var index = $this.z4v_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.l4w(index, cause, $this.f8());
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        handleCoroutineException($this.f8(), 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.z4v_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.z4v_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.z4v_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.z4v_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.f8().m8(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.b4w_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.m4w();
+    }
+  }
+  function CancellableContinuationImpl(delegate, resumeMode) {
+    DispatchedTask.call(this, resumeMode);
+    this.x4v_1 = delegate;
+    // Inline function 'kotlinx.coroutines.assert' call
+    this.y4v_1 = this.x4v_1.f8();
+    var tmp = this;
+    // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+    var tmp$ret$1 = (0 << 29) + 536870911 | 0;
+    tmp.z4v_1 = atomic$int$1(tmp$ret$1);
+    this.a4w_1 = atomic$ref$1(Active_instance);
+    this.b4w_1 = atomic$ref$1(null);
+  }
+  protoOf(CancellableContinuationImpl).n4w = function () {
+    return this.x4v_1;
+  };
+  protoOf(CancellableContinuationImpl).f8 = function () {
+    return this.y4v_1;
+  };
+  protoOf(CancellableContinuationImpl).p4u = function () {
+    return this.a4w_1.kotlinx$atomicfu$value;
+  };
+  protoOf(CancellableContinuationImpl).q4u = function () {
+    var tmp = this.p4u();
+    return !(!(tmp == null) ? isInterface(tmp, NotCompleted) : false);
+  };
+  protoOf(CancellableContinuationImpl).o4w = 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.q4u()) {
+      handle.p4w();
+      this.b4w_1.kotlinx$atomicfu$value = NonDisposableHandle_instance;
+    }
+  };
+  protoOf(CancellableContinuationImpl).q4w = function () {
+    return this.p4u();
+  };
+  protoOf(CancellableContinuationImpl).r4w = function (takenState, cause) {
+    var this_0 = this.a4w_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.x4w()) {
+              var message_0 = 'Must be called at most once';
+              throw IllegalStateException_init_$Create$(toString(message_0));
+            }
+            var update = state.y4w(VOID, VOID, VOID, VOID, cause);
+            if (this.a4w_1.atomicfu$compareAndSet(state, update)) {
+              state.z4w(this, cause);
+              return Unit_instance;
+            }
+          } else {
+            if (this.a4w_1.atomicfu$compareAndSet(state, new CompletedContinuation(state, VOID, VOID, VOID, cause))) {
+              return Unit_instance;
+            }
+          }
+        }
+      }
+    }
+    return Unit_instance;
+  };
+  protoOf(CancellableContinuationImpl).a4x = function (cause) {
+    // Inline function 'kotlinx.atomicfu.loop' call
+    var this_0 = this.a4w_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.a4w_1.atomicfu$compareAndSet(tmp0, update)) {
+          break $l$block;
+        }
+        if (isInterface(tmp0, CancelHandler)) {
+          this.b4x(tmp0, cause);
+        } else {
+          if (tmp0 instanceof Segment) {
+            callSegmentOnCancellation(this, tmp0, cause);
+          }
+        }
+        detachChildIfNonReusable(this);
+        dispatchResume(this, this.j4w_1);
+        return true;
+      }
+    }
+  };
+  protoOf(CancellableContinuationImpl).c4x = function (cause) {
+    if (cancelLater(this, cause))
+      return Unit_instance;
+    this.a4x(cause);
+    detachChildIfNonReusable(this);
+  };
+  protoOf(CancellableContinuationImpl).b4x = function (handler, cause) {
+    // Inline function 'kotlinx.coroutines.CancellableContinuationImpl.callCancelHandlerSafely' call
+    try {
+      handler.d4x(cause);
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        handleCoroutineException(this.f8(), new CompletionHandlerException('Exception in invokeOnCancellation handler for ' + this.toString(), ex));
+      } else {
+        throw $p;
+      }
+    }
+    return Unit_instance;
+  };
+  protoOf(CancellableContinuationImpl).e4x = function (onCancellation, cause, value) {
+    try {
+      onCancellation(cause, value, this.f8());
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        handleCoroutineException(this.f8(), new CompletionHandlerException('Exception in resume onCancellation handler for ' + this.toString(), ex));
+      } else {
+        throw $p;
+      }
+    }
+  };
+  protoOf(CancellableContinuationImpl).f4x = function (parent) {
+    return parent.t4u();
+  };
+  protoOf(CancellableContinuationImpl).g4x = function () {
+    var isReusable_0 = isReusable(this);
+    if (trySuspend(this)) {
+      if (_get_parentHandle__f8dcex(this) == null) {
+        installParentHandle(this);
+      }
+      if (isReusable_0) {
+        this.h4x();
+      }
+      return get_COROUTINE_SUSPENDED();
+    }
+    if (isReusable_0) {
+      this.h4x();
+    }
+    var state = this.p4u();
+    if (state instanceof CompletedExceptionally)
+      throw recoverStackTrace(state.b4u_1, this);
+    if (get_isCancellableMode(this.j4w_1)) {
+      var job = this.f8().m8(Key_instance_2);
+      if (!(job == null) && !job.w4t()) {
+        var cause = job.t4u();
+        this.r4w(state, cause);
+        throw recoverStackTrace(cause, this);
+      }
+    }
+    return this.i4x(state);
+  };
+  protoOf(CancellableContinuationImpl).h4x = function () {
+    var tmp = this.x4v_1;
+    var tmp0_safe_receiver = tmp instanceof DispatchedContinuation ? tmp : null;
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j4x(this);
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return Unit_instance;
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var cancellationCause = tmp_0;
+    this.m4w();
+    this.a4x(cancellationCause);
+  };
+  protoOf(CancellableContinuationImpl).k8 = function (result) {
+    return this.k4x(toState(result, this), this.j4w_1);
+  };
+  protoOf(CancellableContinuationImpl).l4x = function (proposedUpdate, resumeMode, onCancellation) {
+    // Inline function 'kotlinx.atomicfu.loop' call
+    var this_0 = this.a4w_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.a4w_1.atomicfu$compareAndSet(tmp0, update)) {
+            break $l$block;
+          }
+          detachChildIfNonReusable(this);
+          dispatchResume(this, resumeMode);
+          return Unit_instance;
+        } else {
+          if (tmp0 instanceof CancelledContinuation) {
+            if (tmp0.p4x()) {
+              if (onCancellation == null)
+                null;
+              else {
+                // Inline function 'kotlin.let' call
+                this.e4x(onCancellation, tmp0.b4u_1, proposedUpdate);
+              }
+              return Unit_instance;
+            }
+          }
+        }
+        alreadyResumedError(this, proposedUpdate);
+      }
+    }
+  };
+  protoOf(CancellableContinuationImpl).k4x = function (proposedUpdate, resumeMode, onCancellation, $super) {
+    onCancellation = onCancellation === VOID ? null : onCancellation;
+    var tmp;
+    if ($super === VOID) {
+      this.l4x(proposedUpdate, resumeMode, onCancellation);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.l4x.call(this, proposedUpdate, resumeMode, onCancellation);
+    }
+    return tmp;
+  };
+  protoOf(CancellableContinuationImpl).m4w = 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.p4w();
+    this.b4w_1.kotlinx$atomicfu$value = NonDisposableHandle_instance;
+  };
+  protoOf(CancellableContinuationImpl).i4x = function (state) {
+    var tmp;
+    if (state instanceof CompletedContinuation) {
+      var tmp_0 = state.s4w_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).q4x = function (state) {
+    var tmp0_safe_receiver = protoOf(DispatchedTask).q4x.call(this, state);
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp = recoverStackTrace(tmp0_safe_receiver, this.x4v_1);
+    }
+    return tmp;
+  };
+  protoOf(CancellableContinuationImpl).toString = function () {
+    return this.r4x() + '(' + toDebugString(this.x4v_1) + '){' + _get_stateDebugRepresentation__bf18u4(this) + '}@' + get_hexAddress(this);
+  };
+  protoOf(CancellableContinuationImpl).r4x = 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.s4w_1 = result;
+    this.t4w_1 = cancelHandler;
+    this.u4w_1 = onCancellation;
+    this.v4w_1 = idempotentResume;
+    this.w4w_1 = cancelCause;
+  }
+  protoOf(CompletedContinuation).x4w = function () {
+    return !(this.w4w_1 == null);
+  };
+  protoOf(CompletedContinuation).z4w = function (cont, cause) {
+    var tmp0_safe_receiver = this.t4w_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      cont.b4x(tmp0_safe_receiver, cause);
+    }
+    var tmp1_safe_receiver = this.u4w_1;
+    if (tmp1_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      cont.e4x(tmp1_safe_receiver, cause, this.s4w_1);
+    }
+  };
+  protoOf(CompletedContinuation).u4x = function (result, cancelHandler, onCancellation, idempotentResume, cancelCause) {
+    return new CompletedContinuation(result, cancelHandler, onCancellation, idempotentResume, cancelCause);
+  };
+  protoOf(CompletedContinuation).y4w = function (result, cancelHandler, onCancellation, idempotentResume, cancelCause, $super) {
+    result = result === VOID ? this.s4w_1 : result;
+    cancelHandler = cancelHandler === VOID ? this.t4w_1 : cancelHandler;
+    onCancellation = onCancellation === VOID ? this.u4w_1 : onCancellation;
+    idempotentResume = idempotentResume === VOID ? this.v4w_1 : idempotentResume;
+    cancelCause = cancelCause === VOID ? this.w4w_1 : cancelCause;
+    return $super === VOID ? this.u4x(result, cancelHandler, onCancellation, idempotentResume, cancelCause) : $super.u4x.call(this, result, cancelHandler, onCancellation, idempotentResume, cancelCause);
+  };
+  protoOf(CompletedContinuation).toString = function () {
+    return 'CompletedContinuation(result=' + toString_0(this.s4w_1) + ', cancelHandler=' + toString_0(this.t4w_1) + ', onCancellation=' + toString_0(this.u4w_1) + ', idempotentResume=' + toString_0(this.v4w_1) + ', cancelCause=' + toString_0(this.w4w_1) + ')';
+  };
+  protoOf(CompletedContinuation).hashCode = function () {
+    var result = this.s4w_1 == null ? 0 : hashCode(this.s4w_1);
+    result = imul(result, 31) + (this.t4w_1 == null ? 0 : hashCode(this.t4w_1)) | 0;
+    result = imul(result, 31) + (this.u4w_1 == null ? 0 : hashCode(this.u4w_1)) | 0;
+    result = imul(result, 31) + (this.v4w_1 == null ? 0 : hashCode(this.v4w_1)) | 0;
+    result = imul(result, 31) + (this.w4w_1 == null ? 0 : hashCode(this.w4w_1)) | 0;
+    return result;
+  };
+  protoOf(CompletedContinuation).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CompletedContinuation))
+      return false;
+    if (!equals(this.s4w_1, other.s4w_1))
+      return false;
+    if (!equals(this.t4w_1, other.t4w_1))
+      return false;
+    if (!equals(this.u4w_1, other.u4w_1))
+      return false;
+    if (!equals(this.v4w_1, other.v4w_1))
+      return false;
+    if (!equals(this.w4w_1, other.w4w_1))
+      return false;
+    return true;
+  };
+  function ChildContinuation(child) {
+    JobNode.call(this);
+    this.z4x_1 = child;
+  }
+  protoOf(ChildContinuation).a4y = function () {
+    return true;
+  };
+  protoOf(ChildContinuation).d4x = function (cause) {
+    this.z4x_1.c4x(this.z4x_1.f4x(this.f4y()));
+  };
+  function CompletedExceptionally(cause, handled) {
+    handled = handled === VOID ? false : handled;
+    this.b4u_1 = cause;
+    this.c4u_1 = atomic$boolean$1(handled);
+  }
+  protoOf(CompletedExceptionally).d4u = function () {
+    return this.c4u_1.kotlinx$atomicfu$value;
+  };
+  protoOf(CompletedExceptionally).n4y = function () {
+    return this.c4u_1.atomicfu$compareAndSet(false, true);
+  };
+  protoOf(CompletedExceptionally).toString = function () {
+    return get_classSimpleName(this) + '[' + this.b4u_1.toString() + ']';
+  };
+  function CancelledContinuation(continuation, cause, handled) {
+    CompletedExceptionally.call(this, cause == null ? CancellationException_init_$Create$('Continuation ' + toString(continuation) + ' was cancelled normally') : cause, handled);
+    this.o4x_1 = atomic$boolean$1(false);
+  }
+  protoOf(CancelledContinuation).p4x = function () {
+    return this.o4x_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).p4y = function (context) {
+    return true;
+  };
+  protoOf(CoroutineDispatcher).n8 = function (continuation) {
+    return new DispatchedContinuation(this, continuation);
+  };
+  protoOf(CoroutineDispatcher).o8 = function (continuation) {
+    var dispatched = continuation instanceof DispatchedContinuation ? continuation : THROW_CCE();
+    dispatched.r4y();
+  };
+  protoOf(CoroutineDispatcher).toString = function () {
+    return get_classSimpleName(this) + '@' + get_hexAddress(this);
+  };
+  function handleCoroutineException(context, exception) {
+    var tmp;
+    if (exception instanceof DispatchException) {
+      tmp = exception.s4y_1;
+    } else {
+      tmp = exception;
+    }
+    var reportException = tmp;
+    try {
+      var tmp0_safe_receiver = context.m8(Key_instance_1);
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        tmp0_safe_receiver.t4y(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).v4t = 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).m4u = function (block, receiver, completion) {
+    var tmp;
+    switch (this.e2_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).n4v = 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.v4y_1 = new Long(0, 0);
+    this.w4y_1 = false;
+    this.x4y_1 = null;
+  }
+  protoOf(EventLoop).y4y = function () {
+    var tmp0_elvis_lhs = this.x4y_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var queue = tmp;
+    var tmp1_elvis_lhs = queue.id();
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var task = tmp_0;
+    task.s4x();
+    return true;
+  };
+  protoOf(EventLoop).z4y = function (task) {
+    var tmp0_elvis_lhs = this.x4y_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      // Inline function 'kotlin.also' call
+      var this_0 = ArrayDeque_init_$Create$();
+      this.x4y_1 = this_0;
+      tmp = this_0;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var queue = tmp;
+    queue.gd(task);
+  };
+  protoOf(EventLoop).a4z = function () {
+    return compare(this.v4y_1, delta(this, true)) >= 0;
+  };
+  protoOf(EventLoop).b4z = function () {
+    var tmp0_safe_receiver = this.x4y_1;
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.l();
+    return tmp1_elvis_lhs == null ? true : tmp1_elvis_lhs;
+  };
+  protoOf(EventLoop).c4z = function (unconfined) {
+    this.v4y_1 = add(this.v4y_1, delta(this, unconfined));
+    if (!unconfined)
+      this.w4y_1 = true;
+  };
+  protoOf(EventLoop).d4z = function (unconfined) {
+    this.v4y_1 = subtract(this.v4y_1, delta(this, unconfined));
+    if (compare(this.v4y_1, new Long(0, 0)) > 0)
+      return Unit_instance;
+    // Inline function 'kotlinx.coroutines.assert' call
+    if (this.w4y_1) {
+      this.e4z();
+    }
+  };
+  protoOf(EventLoop).e4z = function () {
+  };
+  function ThreadLocalEventLoop() {
+    ThreadLocalEventLoop_instance = this;
+    this.f4z_1 = commonThreadLocal(new Symbol('ThreadLocalEventLoop'));
+  }
+  protoOf(ThreadLocalEventLoop).g4z = function () {
+    var tmp0_elvis_lhs = this.f4z_1.i4z();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      // Inline function 'kotlin.also' call
+      var this_0 = createEventLoop();
+      ThreadLocalEventLoop_getInstance().f4z_1.r3(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).p4w = function () {
+  };
+  protoOf(NonDisposableHandle).c4v = 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.y4u(invokeImmediately, handler);
+    } else {
+      var tmp_0 = handler.a4y();
+      tmp = _this__u8e3s4.x4u(tmp_0, invokeImmediately, JobNode$invoke$ref(handler));
+    }
+    return tmp;
+  }
+  function JobNode$invoke$ref(p0) {
+    var l = function (_this__u8e3s4) {
+      p0.d4x(_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.j4z_1 = isActive;
+  }
+  protoOf(Empty).w4t = function () {
+    return this.j4z_1;
+  };
+  protoOf(Empty).g4y = function () {
+    return null;
+  };
+  protoOf(Empty).toString = function () {
+    return 'Empty{' + (this.j4z_1 ? 'Active' : 'New') + '}';
+  };
+  function Incomplete() {
+  }
+  function NodeList() {
+    LockFreeLinkedListHead.call(this);
+  }
+  protoOf(NodeList).w4t = function () {
+    return true;
+  };
+  protoOf(NodeList).g4y = function () {
+    return this;
+  };
+  protoOf(NodeList).n4z = function (state) {
+    // Inline function 'kotlin.text.buildString' call
+    // Inline function 'kotlin.apply' call
+    var this_0 = StringBuilder_init_$Create$();
+    this_0.e7('List{');
+    this_0.e7(state);
+    this_0.e7('}[');
+    var first = true;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+    var cur = this.h4y_1;
+    while (!equals(cur, this)) {
+      var node = cur;
+      if (node instanceof JobNode) {
+        if (first) {
+          first = false;
+        } else
+          this_0.e7(', ');
+        this_0.d7(node);
+      }
+      cur = cur.h4y_1;
+    }
+    this_0.e7(']');
+    return this_0.toString();
+  };
+  protoOf(NodeList).toString = function () {
+    return get_DEBUG() ? this.n4z('Active') : protoOf(LockFreeLinkedListHead).toString.call(this);
+  };
+  function JobNode() {
+    LockFreeLinkedListNode.call(this);
+  }
+  protoOf(JobNode).f4y = function () {
+    var tmp = this.e4y_1;
+    if (!(tmp == null))
+      return tmp;
+    else {
+      throwUninitializedPropertyAccessException('job');
+    }
+  };
+  protoOf(JobNode).w4t = function () {
+    return true;
+  };
+  protoOf(JobNode).g4y = function () {
+    return null;
+  };
+  protoOf(JobNode).p4w = function () {
+    return this.f4y().z4u(this);
+  };
+  protoOf(JobNode).toString = function () {
+    return get_classSimpleName(this) + '@' + get_hexAddress(this) + '[job@' + get_hexAddress(this.f4y()) + ']';
+  };
+  function _set_exceptionsHolder__tqm22h($this, value) {
+    $this.s4z_1.kotlinx$atomicfu$value = value;
+  }
+  function _get_exceptionsHolder__nhszp($this) {
+    return $this.s4z_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.b4u_1;
+    var wasCancelling;
+    // Inline function 'kotlinx.coroutines.internal.synchronized' call
+    // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+    wasCancelling = state.t4z();
+    var exceptions = state.u4z(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.j4v(finalException);
+      if (handled) {
+        (finalState instanceof CompletedExceptionally ? finalState : THROW_CCE()).n4y();
+      }
+    }
+    if (!wasCancelling) {
+      $this.g4v(finalException);
+    }
+    $this.a4u(finalState);
+    var casSuccess = $this.p4t_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.l()) {
+      if (state.t4z()) {
+        // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+        return new JobCancellationException(null == null ? $this.z4t() : null, null, $this);
+      }
+      return null;
+    }
+    var tmp$ret$2;
+    $l$block: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s = exceptions.i();
+      while (_iterator__ex2g4s.j()) {
+        var element = _iterator__ex2g4s.k();
+        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.m(0);
+    if (first instanceof TimeoutCancellationException) {
+      var tmp$ret$4;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.firstOrNull' call
+        var _iterator__ex2g4s_0 = exceptions.i();
+        while (_iterator__ex2g4s_0.j()) {
+          var element_0 = _iterator__ex2g4s_0.k();
+          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.n() <= 1)
+      return Unit_instance;
+    var seenExceptions = identitySet(exceptions.n());
+    var unwrappedCause = unwrap(rootCause);
+    var _iterator__ex2g4s = exceptions.i();
+    while (_iterator__ex2g4s.j()) {
+      var exception = _iterator__ex2g4s.k();
+      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.h(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.p4t_1.atomicfu$compareAndSet(state, boxIncomplete(update)))
+      return false;
+    $this.g4v(null);
+    $this.a4u(update);
+    completeStateFinalization($this, state, update);
+    return true;
+  }
+  function completeStateFinalization($this, state, update) {
+    var tmp0_safe_receiver = $this.o4u();
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      tmp0_safe_receiver.p4w();
+      $this.n4u(NonDisposableHandle_instance);
+    }
+    var tmp1_safe_receiver = update instanceof CompletedExceptionally ? update : null;
+    var cause = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.b4u_1;
+    if (state instanceof JobNode) {
+      try {
+        state.d4x(cause);
+      } catch ($p) {
+        if ($p instanceof Error) {
+          var ex = $p;
+          $this.h4u(new CompletionHandlerException('Exception in completion handler ' + state.toString() + ' for ' + $this.toString(), ex));
+        } else {
+          throw $p;
+        }
+      }
+    } else {
+      var tmp2_safe_receiver = state.g4y();
+      if (tmp2_safe_receiver == null)
+        null;
+      else {
+        notifyCompletion($this, tmp2_safe_receiver, cause);
+      }
+    }
+  }
+  function notifyCancelling($this, list, cause) {
+    $this.g4v(cause);
+    list.o4z(4);
+    // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+    var exception = null;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+    var cur = list.h4y_1;
+    while (!equals(cur, list)) {
+      var node = cur;
+      var tmp;
+      if (node instanceof JobNode) {
+        tmp = node.a4y();
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        try {
+          node.d4x(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.h4y_1;
+    }
+    var tmp0_safe_receiver_0 = exception;
+    if (tmp0_safe_receiver_0 == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      $this.h4u(tmp0_safe_receiver_0);
+    }
+    cancelParent($this, cause);
+  }
+  function cancelParent($this, cause) {
+    if ($this.h4v())
+      return true;
+    var isCancellation = cause instanceof CancellationException;
+    var parent = $this.o4u();
+    if (parent === null || parent === NonDisposableHandle_instance) {
+      return isCancellation;
+    }
+    return parent.c4v(cause) || isCancellation;
+  }
+  function notifyCompletion($this, _this__u8e3s4, cause) {
+    _this__u8e3s4.o4z(1);
+    // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+    var exception = null;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+    var cur = _this__u8e3s4.h4y_1;
+    while (!equals(cur, _this__u8e3s4)) {
+      var node = cur;
+      var tmp;
+      if (node instanceof JobNode) {
+        tmp = true;
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        try {
+          node.d4x(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.h4y_1;
+    }
+    var tmp0_safe_receiver_0 = exception;
+    if (tmp0_safe_receiver_0 == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      $this.h4u(tmp0_safe_receiver_0);
+    }
+  }
+  function startInternal($this, state) {
+    if (state instanceof Empty) {
+      if (state.j4z_1)
+        return 0;
+      if (!$this.p4t_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+        return -1;
+      $this.s4u();
+      return 1;
+    } else {
+      if (state instanceof InactiveNodeList) {
+        if (!$this.p4t_1.atomicfu$compareAndSet(state, state.v4z_1))
+          return -1;
+        $this.s4u();
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+  }
+  function promoteEmptyToNodeList($this, state) {
+    var list = new NodeList();
+    var update = state.j4z_1 ? list : new InactiveNodeList(list);
+    $this.p4t_1.atomicfu$compareAndSet(state, update);
+  }
+  function promoteSingleToNodeList($this, state) {
+    state.m4y(new NodeList());
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+    var list = state.h4y_1;
+    $this.p4t_1.atomicfu$compareAndSet(state, list);
+  }
+  function cancelMakeCompleting($this, cause) {
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var state = $this.p4u();
+      var tmp;
+      if (!(!(state == null) ? isInterface(state, Incomplete) : false)) {
+        tmp = true;
+      } else {
+        var tmp_0;
+        if (state instanceof Finishing) {
+          tmp_0 = state.w4z();
+        } 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.z4t() : null, null, $this);
+      } else {
+        tmp_0 = cause;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = (isInterface(cause, ParentJob) ? cause : THROW_CCE()).e4v();
+    }
+    return tmp;
+  }
+  function makeCancelling($this, cause) {
+    var causeExceptionCache = null;
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var tmp0 = $this.p4u();
+      $l$block: {
+        if (tmp0 instanceof Finishing) {
+          // Inline function 'kotlinx.coroutines.internal.synchronized' call
+          // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+          if (tmp0.x4z())
+            return get_TOO_LATE_TO_CANCEL();
+          var wasCancelling = tmp0.t4z();
+          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.y4z(causeException);
+          }
+          // Inline function 'kotlin.takeIf' call
+          var this_1 = tmp0.z4z();
+          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.p4z_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.w4t()) {
+              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.g4y();
+    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.p4t_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.w4z())
+      return get_COMPLETING_ALREADY();
+    finishing.a50(true);
+    if (!(finishing === state)) {
+      if (!$this.p4t_1.atomicfu$compareAndSet(state, finishing))
+        return get_COMPLETING_RETRY();
+    }
+    // Inline function 'kotlinx.coroutines.assert' call
+    var wasCancelling = finishing.t4z();
+    var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally ? proposedUpdate : null;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      finishing.y4z(tmp0_safe_receiver.b4u_1);
+    }
+    // Inline function 'kotlin.takeIf' call
+    var this_0 = finishing.z4z();
+    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.o4z(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.b4u_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.f50_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.p4z_1.o4z(2);
+    var waitChildAgain = nextChild($this, lastChild);
+    if (!(waitChildAgain == null) && tryWaitForChild($this, state, waitChildAgain, proposedUpdate)) {
+      return Unit_instance;
+    }
+    var finalState = finalizeFinishingState($this, state, proposedUpdate);
+    $this.g4u(finalState);
+  }
+  function nextChild($this, _this__u8e3s4) {
+    var cur = _this__u8e3s4;
+    $l$loop: while (true) {
+      // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+      if (!cur.j4y_1) {
+        break $l$loop;
+      }
+      // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.prevNode' call
+      cur = cur.i4y_1;
+    }
+    $l$loop_0: while (true) {
+      // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+      cur = cur.h4y_1;
+      // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+      if (cur.j4y_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.t4z() ? 'Cancelling' : state.w4z() ? 'Completing' : 'Active';
+    } else {
+      if (!(state == null) ? isInterface(state, Incomplete) : false) {
+        tmp = state.w4t() ? 'Active' : 'New';
+      } else {
+        if (state instanceof CompletedExceptionally) {
+          tmp = 'Cancelled';
+        } else {
+          tmp = 'Completed';
+        }
+      }
+    }
+    return tmp;
+  }
+  function Finishing(list, isCompleting, rootCause) {
+    SynchronizedObject.call(this);
+    this.p4z_1 = list;
+    this.q4z_1 = atomic$boolean$1(isCompleting);
+    this.r4z_1 = atomic$ref$1(rootCause);
+    this.s4z_1 = atomic$ref$1(null);
+  }
+  protoOf(Finishing).g4y = function () {
+    return this.p4z_1;
+  };
+  protoOf(Finishing).a50 = function (value) {
+    this.q4z_1.kotlinx$atomicfu$value = value;
+  };
+  protoOf(Finishing).w4z = function () {
+    return this.q4z_1.kotlinx$atomicfu$value;
+  };
+  protoOf(Finishing).g50 = function (value) {
+    this.r4z_1.kotlinx$atomicfu$value = value;
+  };
+  protoOf(Finishing).z4z = function () {
+    return this.r4z_1.kotlinx$atomicfu$value;
+  };
+  protoOf(Finishing).x4z = function () {
+    return _get_exceptionsHolder__nhszp(this) === get_SEALED();
+  };
+  protoOf(Finishing).t4z = function () {
+    return !(this.z4z() == null);
+  };
+  protoOf(Finishing).w4t = function () {
+    return this.z4z() == null;
+  };
+  protoOf(Finishing).u4z = 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.h(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.z4z();
+    if (rootCause == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      list.a2(0, rootCause);
+    }
+    if (!(proposedException == null) && !equals(proposedException, rootCause)) {
+      list.h(proposedException);
+    }
+    _set_exceptionsHolder__tqm22h(this, get_SEALED());
+    return list;
+  };
+  protoOf(Finishing).y4z = function (exception) {
+    var rootCause = this.z4z();
+    if (rootCause == null) {
+      this.g50(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.h(eh);
+        this_0.h(exception);
+        _set_exceptionsHolder__tqm22h(this, this_0);
+      } else {
+        if (eh instanceof ArrayList) {
+          (eh instanceof ArrayList ? eh : THROW_CCE()).h(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.t4z() + ', completing=' + this.w4z() + ', rootCause=' + toString_0(this.z4z()) + ', exceptions=' + toString_0(_get_exceptionsHolder__nhszp(this)) + ', list=' + this.p4z_1.toString() + ']';
+  };
+  function ChildCompletion(parent, state, child, proposedUpdate) {
+    JobNode.call(this);
+    this.l50_1 = parent;
+    this.m50_1 = state;
+    this.n50_1 = child;
+    this.o50_1 = proposedUpdate;
+  }
+  protoOf(ChildCompletion).a4y = function () {
+    return false;
+  };
+  protoOf(ChildCompletion).d4x = function (cause) {
+    continueCompleting(this.l50_1, this.m50_1, this.n50_1, this.o50_1);
+  };
+  function JobSupport(active) {
+    this.p4t_1 = atomic$ref$1(active ? get_EMPTY_ACTIVE() : get_EMPTY_NEW());
+    this.q4t_1 = atomic$ref$1(null);
+  }
+  protoOf(JobSupport).n1 = function () {
+    return Key_instance_2;
+  };
+  protoOf(JobSupport).n4u = function (value) {
+    this.q4t_1.kotlinx$atomicfu$value = value;
+  };
+  protoOf(JobSupport).o4u = function () {
+    return this.q4t_1.kotlinx$atomicfu$value;
+  };
+  protoOf(JobSupport).r4t = function (parent) {
+    // Inline function 'kotlinx.coroutines.assert' call
+    if (parent == null) {
+      this.n4u(NonDisposableHandle_instance);
+      return Unit_instance;
+    }
+    parent.r4u();
+    var handle = parent.f4v(this);
+    this.n4u(handle);
+    if (this.q4u()) {
+      handle.p4w();
+      this.n4u(NonDisposableHandle_instance);
+    }
+  };
+  protoOf(JobSupport).p4u = function () {
+    return this.p4t_1.kotlinx$atomicfu$value;
+  };
+  protoOf(JobSupport).w4t = function () {
+    var state = this.p4u();
+    var tmp;
+    if (!(state == null) ? isInterface(state, Incomplete) : false) {
+      tmp = state.w4t();
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(JobSupport).q4u = function () {
+    var tmp = this.p4u();
+    return !(!(tmp == null) ? isInterface(tmp, Incomplete) : false);
+  };
+  protoOf(JobSupport).r4u = function () {
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var state = this.p4u();
+      var tmp0_subject = startInternal(this, state);
+      if (tmp0_subject === 0)
+        return false;
+      else if (tmp0_subject === 1)
+        return true;
+    }
+  };
+  protoOf(JobSupport).s4u = function () {
+  };
+  protoOf(JobSupport).t4u = function () {
+    var state = this.p4u();
+    var tmp;
+    if (state instanceof Finishing) {
+      var tmp0_safe_receiver = state.z4z();
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : this.u4u(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.v4u(state.b4u_1);
+        } else {
+          tmp = new JobCancellationException(get_classSimpleName(this) + ' has completed normally', null, this);
+        }
+      }
+    }
+    return tmp;
+  };
+  protoOf(JobSupport).u4u = 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.z4t() : message, _this__u8e3s4, this);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(JobSupport).v4u = function (_this__u8e3s4, message, $super) {
+    message = message === VOID ? null : message;
+    return $super === VOID ? this.u4u(_this__u8e3s4, message) : $super.u4u.call(this, _this__u8e3s4, message);
+  };
+  protoOf(JobSupport).w4u = function (handler) {
+    return this.y4u(true, new InvokeOnCompletion(handler));
+  };
+  protoOf(JobSupport).x4u = function (onCancelling, invokeImmediately, handler) {
+    var tmp;
+    if (onCancelling) {
+      tmp = new InvokeOnCancelling(handler);
+    } else {
+      tmp = new InvokeOnCompletion(handler);
+    }
+    return this.y4u(invokeImmediately, tmp);
+  };
+  protoOf(JobSupport).y4u = function (invokeImmediately, node) {
+    node.e4y_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.p4u();
+        if (state instanceof Empty) {
+          if (state.j4z_1) {
+            if (this.p4t_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.g4y();
+            if (list == null) {
+              promoteSingleToNodeList(this, state instanceof JobNode ? state : THROW_CCE());
+            } else {
+              var tmp;
+              if (node.a4y()) {
+                var tmp0_safe_receiver = state instanceof Finishing ? state : null;
+                var rootCause = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z4z();
+                var tmp_0;
+                if (rootCause == null) {
+                  tmp_0 = list.k4y(node, 5);
+                } else {
+                  if (invokeImmediately) {
+                    node.d4x(rootCause);
+                  }
+                  return NonDisposableHandle_instance;
+                }
+                tmp = tmp_0;
+              } else {
+                tmp = list.k4y(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.p4u();
+      var tmp0_safe_receiver_0 = tmp_1 instanceof CompletedExceptionally ? tmp_1 : null;
+      node.d4x(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.b4u_1);
+    }
+    return NonDisposableHandle_instance;
+  };
+  protoOf(JobSupport).z4u = function (node) {
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var state = this.p4u();
+      if (state instanceof JobNode) {
+        if (!(state === node))
+          return Unit_instance;
+        if (this.p4t_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+          return Unit_instance;
+      } else {
+        if (!(state == null) ? isInterface(state, Incomplete) : false) {
+          if (!(state.g4y() == null)) {
+            node.l4y();
+          }
+          return Unit_instance;
+        } else {
+          return Unit_instance;
+        }
+      }
+    }
+  };
+  protoOf(JobSupport).a4v = function () {
+    return false;
+  };
+  protoOf(JobSupport).z4t = function () {
+    return 'Job was cancelled';
+  };
+  protoOf(JobSupport).b4v = function (parentJob) {
+    this.d4v(parentJob);
+  };
+  protoOf(JobSupport).c4v = function (cause) {
+    if (cause instanceof CancellationException)
+      return true;
+    return this.d4v(cause) && this.i4v();
+  };
+  protoOf(JobSupport).d4v = function (cause) {
+    var finalState = get_COMPLETING_ALREADY();
+    if (this.a4v()) {
+      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.g4u(finalState);
+      tmp = true;
+    }
+    return tmp;
+  };
+  protoOf(JobSupport).e4v = function () {
+    var state = this.p4u();
+    var tmp;
+    if (state instanceof Finishing) {
+      tmp = state.z4z();
+    } else {
+      if (state instanceof CompletedExceptionally) {
+        tmp = state.b4u_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).e4u = function (proposedUpdate) {
+    // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+    while (true) {
+      var tmp0 = this.p4u();
+      $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).f4v = function (child) {
+    // Inline function 'kotlin.also' call
+    var this_0 = new ChildHandleNode(child);
+    this_0.e4y_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.p4u();
+        if (state instanceof Empty) {
+          if (state.j4z_1) {
+            if (this.p4t_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.g4y();
+            if (list == null) {
+              promoteSingleToNodeList(this, state instanceof JobNode ? state : THROW_CCE());
+            } else {
+              var addedBeforeCancellation = list.k4y(node, 7);
+              var tmp;
+              if (addedBeforeCancellation) {
+                tmp = true;
+              } else {
+                var addedBeforeCompletion = list.k4y(node, 3);
+                var latestState = this.p4u();
+                var tmp_0;
+                if (latestState instanceof Finishing) {
+                  tmp_0 = latestState.z4z();
+                } 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.b4u_1;
+                }
+                var rootCause = tmp_0;
+                node.d4x(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.p4u();
+    var tmp0_safe_receiver_0 = tmp_2 instanceof CompletedExceptionally ? tmp_2 : null;
+    node.d4x(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.b4u_1);
+    return NonDisposableHandle_instance;
+  };
+  protoOf(JobSupport).h4u = function (exception) {
+    throw exception;
+  };
+  protoOf(JobSupport).g4v = function (cause) {
+  };
+  protoOf(JobSupport).h4v = function () {
+    return false;
+  };
+  protoOf(JobSupport).i4v = function () {
+    return true;
+  };
+  protoOf(JobSupport).j4v = function (exception) {
+    return false;
+  };
+  protoOf(JobSupport).a4u = function (state) {
+  };
+  protoOf(JobSupport).g4u = function (state) {
+  };
+  protoOf(JobSupport).toString = function () {
+    return this.k4v() + '@' + get_hexAddress(this);
+  };
+  protoOf(JobSupport).k4v = function () {
+    return this.i4u() + '{' + stateString(this, this.p4u()) + '}';
+  };
+  protoOf(JobSupport).i4u = function () {
+    return get_classSimpleName(this);
+  };
+  protoOf(JobSupport).l4v = function () {
+    var state = this.p4u();
+    // 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).m4v = function () {
+    var state = this.p4u();
+    // 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.b4u_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.v4z_1 = list;
+  }
+  protoOf(InactiveNodeList).g4y = function () {
+    return this.v4z_1;
+  };
+  protoOf(InactiveNodeList).w4t = function () {
+    return false;
+  };
+  protoOf(InactiveNodeList).toString = function () {
+    return get_DEBUG() ? this.v4z_1.n4z('New') : anyToString(this);
+  };
+  function InvokeOnCompletion(handler) {
+    JobNode.call(this);
+    this.t50_1 = handler;
+  }
+  protoOf(InvokeOnCompletion).a4y = function () {
+    return false;
+  };
+  protoOf(InvokeOnCompletion).d4x = function (cause) {
+    return this.t50_1(cause);
+  };
+  function InvokeOnCancelling(handler) {
+    JobNode.call(this);
+    this.y50_1 = handler;
+    this.z50_1 = atomic$boolean$1(false);
+  }
+  protoOf(InvokeOnCancelling).a4y = function () {
+    return true;
+  };
+  protoOf(InvokeOnCancelling).d4x = function (cause) {
+    if (this.z50_1.atomicfu$compareAndSet(false, true))
+      this.y50_1(cause);
+  };
+  function ChildHandleNode(childJob) {
+    JobNode.call(this);
+    this.f50_1 = childJob;
+  }
+  protoOf(ChildHandleNode).a4y = function () {
+    return true;
+  };
+  protoOf(ChildHandleNode).d4x = function (cause) {
+    return this.f50_1.b4v(this.f4y());
+  };
+  protoOf(ChildHandleNode).c4v = function (cause) {
+    return this.f4y().c4v(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.a51_1;
+    return tmp1_elvis_lhs == null ? _this__u8e3s4 : tmp1_elvis_lhs;
+  }
+  function IncompleteStateBox(state) {
+    this.a51_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.d51();
+    return tmp0_elvis_lhs == null ? get_classSimpleName(this) + '@' + get_hexAddress(this) : tmp0_elvis_lhs;
+  };
+  protoOf(MainCoroutineDispatcher).d51 = function () {
+    var main = Dispatchers_getInstance().i51();
+    if (this === main)
+      return 'Dispatchers.Main';
+    var tmp;
+    try {
+      tmp = main.c51();
+    } 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).p4y = function (context) {
+    return false;
+  };
+  protoOf(Unconfined).q4y = function (context, block) {
+    var yieldContext = context.m8(Key_instance_3);
+    if (!(yieldContext == null)) {
+      yieldContext.l51_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().i();
+    while (_iterator__ex2g4s.j()) {
+      var handler = _iterator__ex2g4s.k();
+      try {
+        handler.t4y(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.h4w_1.kotlinx$atomicfu$value;
+    return tmp instanceof CancellableContinuationImpl ? tmp : null;
+  }
+  function DispatchedContinuation(dispatcher, continuation) {
+    DispatchedTask.call(this, -1);
+    this.d4w_1 = dispatcher;
+    this.e4w_1 = continuation;
+    this.f4w_1 = get_UNDEFINED();
+    this.g4w_1 = threadContextElements(this.f8());
+    this.h4w_1 = atomic$ref$1(null);
+  }
+  protoOf(DispatchedContinuation).i4w = function () {
+    return !(this.h4w_1.kotlinx$atomicfu$value == null);
+  };
+  protoOf(DispatchedContinuation).m51 = function () {
+    // Inline function 'kotlinx.atomicfu.loop' call
+    var this_0 = this.h4w_1;
+    while (true) {
+      if (!(this_0.kotlinx$atomicfu$value === get_REUSABLE_CLAIMED()))
+        return Unit_instance;
+    }
+  };
+  protoOf(DispatchedContinuation).r4y = function () {
+    this.m51();
+    var tmp0_safe_receiver = _get_reusableCancellableContinuation__9qex09(this);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      tmp0_safe_receiver.m4w();
+    }
+  };
+  protoOf(DispatchedContinuation).j4x = function (continuation) {
+    // Inline function 'kotlinx.atomicfu.loop' call
+    var this_0 = this.h4w_1;
+    while (true) {
+      var state = this_0.kotlinx$atomicfu$value;
+      if (state === get_REUSABLE_CLAIMED()) {
+        if (this.h4w_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.h4w_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).k4w = function (cause) {
+    // Inline function 'kotlinx.atomicfu.loop' call
+    var this_0 = this.h4w_1;
+    while (true) {
+      var state = this_0.kotlinx$atomicfu$value;
+      if (equals(state, get_REUSABLE_CLAIMED())) {
+        if (this.h4w_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), cause))
+          return true;
+      } else {
+        if (state instanceof Error)
+          return true;
+        else {
+          if (this.h4w_1.atomicfu$compareAndSet(state, null))
+            return false;
+        }
+      }
+    }
+  };
+  protoOf(DispatchedContinuation).q4w = function () {
+    var state = this.f4w_1;
+    // Inline function 'kotlinx.coroutines.assert' call
+    this.f4w_1 = get_UNDEFINED();
+    return state;
+  };
+  protoOf(DispatchedContinuation).n4w = function () {
+    return this;
+  };
+  protoOf(DispatchedContinuation).k8 = function (result) {
+    var state = toState_0(result);
+    if (safeIsDispatchNeeded(this.d4w_1, this.f8())) {
+      this.f4w_1 = state;
+      this.j4w_1 = 0;
+      safeDispatch(this.d4w_1, this.f8(), this);
+    } else {
+      $l$block: {
+        // Inline function 'kotlinx.coroutines.internal.executeUnconfined' call
+        // Inline function 'kotlinx.coroutines.assert' call
+        var eventLoop = ThreadLocalEventLoop_getInstance().g4z();
+        if (false && eventLoop.b4z()) {
+          break $l$block;
+        }
+        var tmp;
+        if (eventLoop.a4z()) {
+          this.f4w_1 = state;
+          this.j4w_1 = 0;
+          eventLoop.z4y(this);
+          tmp = true;
+        } else {
+          // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+          eventLoop.c4z(true);
+          try {
+            this.f8();
+            // Inline function 'kotlinx.coroutines.withCoroutineContext' call
+            this.g4w_1;
+            this.e4w_1.k8(result);
+            $l$loop: while (eventLoop.y4y()) {
+            }
+          } catch ($p) {
+            if ($p instanceof Error) {
+              var e = $p;
+              this.t4x(e);
+            } else {
+              throw $p;
+            }
+          }
+          finally {
+            eventLoop.d4z(true);
+          }
+          tmp = false;
+        }
+      }
+    }
+  };
+  protoOf(DispatchedContinuation).toString = function () {
+    return 'DispatchedContinuation[' + this.d4w_1.toString() + ', ' + toDebugString(this.e4w_1) + ']';
+  };
+  protoOf(DispatchedContinuation).f8 = function () {
+    return this.e4w_1.f8();
+  };
+  function safeDispatch(_this__u8e3s4, context, runnable) {
+    _init_properties_DispatchedContinuation_kt__tnmqc0();
+    try {
+      _this__u8e3s4.q4y(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.p4y(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.d4w_1, _this__u8e3s4.f8())) {
+        _this__u8e3s4.f4w_1 = state;
+        _this__u8e3s4.j4w_1 = 1;
+        safeDispatch(_this__u8e3s4.d4w_1, _this__u8e3s4.f8(), _this__u8e3s4);
+      } else {
+        $l$block: {
+          // Inline function 'kotlinx.coroutines.internal.executeUnconfined' call
+          // Inline function 'kotlinx.coroutines.assert' call
+          var eventLoop = ThreadLocalEventLoop_getInstance().g4z();
+          if (false && eventLoop.b4z()) {
+            break $l$block;
+          }
+          var tmp_0;
+          if (eventLoop.a4z()) {
+            _this__u8e3s4.f4w_1 = state;
+            _this__u8e3s4.j4w_1 = 1;
+            eventLoop.z4y(_this__u8e3s4);
+            tmp_0 = true;
+          } else {
+            // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+            eventLoop.c4z(true);
+            try {
+              var tmp$ret$4;
+              $l$block_0: {
+                // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeCancelled' call
+                var job = _this__u8e3s4.f8().m8(Key_instance_2);
+                if (!(job == null) && !job.w4t()) {
+                  var cause = job.t4u();
+                  _this__u8e3s4.r4w(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.k8(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.e4w_1;
+                // Inline function 'kotlinx.coroutines.withContinuationContext' call
+                _this__u8e3s4.g4w_1;
+                _this__u8e3s4.e4w_1.k8(result);
+              }
+              $l$loop: while (eventLoop.y4y()) {
+              }
+            } catch ($p) {
+              if ($p instanceof Error) {
+                var e = $p;
+                _this__u8e3s4.t4x(e);
+              } else {
+                throw $p;
+              }
+            }
+            finally {
+              eventLoop.d4z(true);
+            }
+            tmp_0 = false;
+          }
+        }
+      }
+      tmp = Unit_instance;
+    } else {
+      _this__u8e3s4.k8(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.j4w_1 = resumeMode;
+  }
+  protoOf(DispatchedTask).r4w = function (takenState, cause) {
+  };
+  protoOf(DispatchedTask).i4x = function (state) {
+    return (state == null ? true : !(state == null)) ? state : THROW_CCE();
+  };
+  protoOf(DispatchedTask).q4x = function (state) {
+    var tmp0_safe_receiver = state instanceof CompletedExceptionally ? state : null;
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.b4u_1;
+  };
+  protoOf(DispatchedTask).s4x = function () {
+    // Inline function 'kotlinx.coroutines.assert' call
+    try {
+      var tmp = this.n4w();
+      var delegate = tmp instanceof DispatchedContinuation ? tmp : THROW_CCE();
+      var continuation = delegate.e4w_1;
+      // Inline function 'kotlinx.coroutines.withContinuationContext' call
+      delegate.g4w_1;
+      var context = continuation.f8();
+      var state = this.q4w();
+      var exception = this.q4x(state);
+      var job = exception == null && get_isCancellableMode(this.j4w_1) ? context.m8(Key_instance_2) : null;
+      if (!(job == null) && !job.w4t()) {
+        var cause = job.t4u();
+        this.r4w(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.k8(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.k8(tmp$ret$3);
+        } else {
+          // Inline function 'kotlin.coroutines.resume' call
+          // Inline function 'kotlin.Companion.success' call
+          var value = this.i4x(state);
+          var tmp$ret$5 = _Result___init__impl__xyqfz8(value);
+          continuation.k8(tmp$ret$5);
+        }
+      }
+    } catch ($p) {
+      if ($p instanceof DispatchException) {
+        var e = $p;
+        handleCoroutineException(this.n4w().f8(), e.s4y_1);
+      } else {
+        if ($p instanceof Error) {
+          var e_0 = $p;
+          this.t4x(e_0);
+        } else {
+          throw $p;
+        }
+      }
+    }
+  };
+  protoOf(DispatchedTask).t4x = 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.n4w().f8(), 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.n4w();
+    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.j4w_1);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      var dispatcher = delegate.d4w_1;
+      var context = delegate.f8();
+      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.s4y_1 = cause;
+    delete this.cause;
+  }
+  protoOf(DispatchException).f = function () {
+    return this.s4y_1;
+  };
+  function resumeUnconfined(_this__u8e3s4) {
+    var eventLoop = ThreadLocalEventLoop_getInstance().g4z();
+    if (eventLoop.a4z()) {
+      eventLoop.z4y(_this__u8e3s4);
+    } else {
+      // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+      eventLoop.c4z(true);
+      try {
+        resume(_this__u8e3s4, _this__u8e3s4.n4w(), true);
+        $l$loop: while (eventLoop.y4y()) {
+        }
+      } catch ($p) {
+        if ($p instanceof Error) {
+          var e = $p;
+          _this__u8e3s4.t4x(e);
+        } else {
+          throw $p;
+        }
+      }
+      finally {
+        eventLoop.d4z(true);
+      }
+    }
+  }
+  function resume(_this__u8e3s4, delegate, undispatched) {
+    var state = _this__u8e3s4.q4w();
+    var exception = _this__u8e3s4.q4x(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.i4x(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.e4w_1;
+      // Inline function 'kotlinx.coroutines.withContinuationContext' call
+      this_0.g4w_1;
+      this_0.e4w_1.k8(result);
+    } else {
+      delegate.k8(result);
+    }
+  }
+  function Symbol(symbol) {
+    this.n51_1 = symbol;
+  }
+  protoOf(Symbol).toString = function () {
+    return '<' + this.n51_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.s4y_1;
+    } else {
+      tmp = e;
+    }
+    var reportException = tmp;
+    // Inline function 'kotlin.Companion.failure' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(reportException));
+    completion.k8(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.f8();
+      // 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.s4y_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.k8(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.k8(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).j9();
+    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).q51 = function () {
+    process.nextTick(this.x51_1.v51_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.b52();
+      return Unit_instance;
+    };
+  }
+  function ScheduledMessageQueue(dispatcher) {
+    MessageQueue.call(this);
+    this.u51_1 = dispatcher;
+    var tmp = this;
+    tmp.v51_1 = ScheduledMessageQueue$processQueue$lambda(this);
+  }
+  protoOf(ScheduledMessageQueue).c52 = function () {
+    this.u51_1.q51();
+  };
+  protoOf(ScheduledMessageQueue).d52 = function () {
+    setTimeout(this.v51_1, 0);
+  };
+  protoOf(ScheduledMessageQueue).e52 = function (timeout) {
+    setTimeout(this.v51_1, timeout);
+  };
+  function WindowMessageQueue$lambda(this$0) {
+    return function (event) {
+      var tmp;
+      if (event.source == this$0.p52_1 && event.data == this$0.q52_1) {
+        event.stopPropagation();
+        this$0.b52();
+        tmp = Unit_instance;
+      }
+      return Unit_instance;
+    };
+  }
+  function WindowMessageQueue$schedule$lambda(this$0) {
+    return function (it) {
+      this$0.b52();
+      return Unit_instance;
+    };
+  }
+  function WindowMessageQueue(window_0) {
+    MessageQueue.call(this);
+    this.p52_1 = window_0;
+    this.q52_1 = 'dispatchCoroutine';
+    this.p52_1.addEventListener('message', WindowMessageQueue$lambda(this), true);
+  }
+  protoOf(WindowMessageQueue).c52 = function () {
+    var tmp = Promise.resolve(Unit_instance);
+    tmp.then(WindowMessageQueue$schedule$lambda(this));
+  };
+  protoOf(WindowMessageQueue).d52 = function () {
+    this.p52_1.postMessage(this.q52_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.v4t().xe(context);
+    return !(combined === Dispatchers_getInstance().e51_1) && combined.m8(Key_instance) == null ? combined.xe(Dispatchers_getInstance().e51_1) : combined;
+  }
+  function get_coroutineName(_this__u8e3s4) {
+    return null;
+  }
+  function Dispatchers() {
+    Dispatchers_instance = this;
+    this.e51_1 = createDefaultDispatcher();
+    this.f51_1 = Unconfined_getInstance();
+    this.g51_1 = new JsMainDispatcher(this.e51_1, false);
+    this.h51_1 = null;
+  }
+  protoOf(Dispatchers).i51 = function () {
+    var tmp0_elvis_lhs = this.h51_1;
+    return tmp0_elvis_lhs == null ? this.g51_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.s52_1 = delegate;
+    this.t52_1 = invokeImmediately;
+    this.u52_1 = this.t52_1 ? this : new JsMainDispatcher(this.s52_1, true);
+  }
+  protoOf(JsMainDispatcher).c51 = function () {
+    return this.u52_1;
+  };
+  protoOf(JsMainDispatcher).p4y = function (context) {
+    return !this.t52_1;
+  };
+  protoOf(JsMainDispatcher).q4y = function (context, block) {
+    return this.s52_1.q4y(context, block);
+  };
+  protoOf(JsMainDispatcher).toString = function () {
+    var tmp0_elvis_lhs = this.d51();
+    return tmp0_elvis_lhs == null ? this.s52_1.toString() : tmp0_elvis_lhs;
+  };
+  function JobCancellationException(message, cause, job) {
+    CancellationException_init_$Init$(message, cause, this);
+    captureStack(this, JobCancellationException);
+    this.v52_1 = job;
+  }
+  protoOf(JobCancellationException).toString = function () {
+    return protoOf(CancellationException).toString.call(this) + '; job=' + toString(this.v52_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.v52_1, this.v52_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.v52_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.h4y_1 = this;
+    this.i4y_1 = this;
+    this.j4y_1 = false;
+  }
+  protoOf(LockFreeLinkedListNode).k4y = function (node, permissionsBitmask) {
+    var prev = this.i4y_1;
+    var tmp;
+    if (prev instanceof ListClosed) {
+      tmp = ((prev.z52_1 & permissionsBitmask) === 0 && prev.k4y(node, permissionsBitmask));
+    } else {
+      node.h4y_1 = this;
+      node.i4y_1 = prev;
+      prev.h4y_1 = node;
+      this.i4y_1 = node;
+      tmp = true;
+    }
+    return tmp;
+  };
+  protoOf(LockFreeLinkedListNode).o4z = function (forbiddenElementsBit) {
+    this.k4y(new ListClosed(forbiddenElementsBit), forbiddenElementsBit);
+  };
+  protoOf(LockFreeLinkedListNode).l4y = function () {
+    if (this.j4y_1)
+      return false;
+    var prev = this.i4y_1;
+    var next = this.h4y_1;
+    prev.h4y_1 = next;
+    next.i4y_1 = prev;
+    this.j4y_1 = true;
+    return true;
+  };
+  protoOf(LockFreeLinkedListNode).m4y = function (node) {
+    if (!(this.h4y_1 === this))
+      return false;
+    this.k4y(node, -2147483648);
+    return true;
+  };
+  function ListClosed(forbiddenElementsBitmask) {
+    LockFreeLinkedListNode.call(this);
+    this.z52_1 = forbiddenElementsBitmask;
+  }
+  function unwrap(exception) {
+    return exception;
+  }
+  function recoverStackTrace(exception, continuation) {
+    return exception;
+  }
+  function SynchronizedObject() {
+  }
+  function threadContextElements(context) {
+    return 0;
+  }
+  function CommonThreadLocal() {
+    this.h4z_1 = null;
+  }
+  protoOf(CommonThreadLocal).i4z = function () {
+    var tmp = this.h4z_1;
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  protoOf(CommonThreadLocal).r3 = function (value) {
+    this.h4z_1 = value;
+  };
+  function commonThreadLocal(name) {
+    return new CommonThreadLocal();
+  }
+  function createEventLoop() {
+    return new UnconfinedEventLoop();
+  }
+  function UnconfinedEventLoop() {
+    EventLoop.call(this);
+  }
+  protoOf(UnconfinedEventLoop).q4y = 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.o4w();
+    var tmp = await$lambda(cancellable);
+    _this__u8e3s4.then(tmp, await$lambda_0(cancellable));
+    return cancellable.g4x();
+  }
+  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.k8(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.k8(tmp$ret$0);
+      return null;
+    };
+  }
+  function asPromise$lambda$lambda($this_asPromise, $reject, $resolve) {
+    return function (it) {
+      var e = $this_asPromise.l4v();
+      var tmp;
+      if (!(e == null)) {
+        tmp = $reject(toJsPromiseError(e));
+      } else {
+        tmp = $resolve($this_asPromise.r4v());
+      }
+      return Unit_instance;
+    };
+  }
+  function asPromise$lambda($this_asPromise) {
+    return function (resolve, reject) {
+      $this_asPromise.w4u(asPromise$lambda$lambda($this_asPromise, reject, resolve));
+      return Unit_instance;
+    };
+  }
+  function propagateExceptionFinalResort(exception) {
+    // Inline function 'kotlin.with' call
+    throwAsyncJsError(exception.message, getKClassFromExpression(exception).j9(), 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).q51 = function () {
+    this.x51_1.e52(0);
+  };
+  var SetTimeoutDispatcher_instance;
+  function SetTimeoutDispatcher_getInstance() {
+    if (SetTimeoutDispatcher_instance == null)
+      new SetTimeoutDispatcher();
+    return SetTimeoutDispatcher_instance;
+  }
+  function SetTimeoutBasedDispatcher() {
+    CoroutineDispatcher.call(this);
+    this.x51_1 = new ScheduledMessageQueue(this);
+  }
+  protoOf(SetTimeoutBasedDispatcher).q4y = function (context, block) {
+    this.x51_1.f52(block);
+  };
+  function MessageQueue() {
+    this.y51_1 = ArrayDeque_init_$Create$();
+    this.z51_1 = 16;
+    this.a52_1 = false;
+  }
+  protoOf(MessageQueue).f52 = function (element) {
+    this.g52(element);
+    if (!this.a52_1) {
+      this.a52_1 = true;
+      this.c52();
+    }
+  };
+  protoOf(MessageQueue).b52 = function () {
+    try {
+      // Inline function 'kotlin.repeat' call
+      var times = this.z51_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.s4x();
+        }
+         while (inductionVariable < times);
+    }finally {
+      if (this.l()) {
+        this.a52_1 = false;
+      } else {
+        this.d52();
+      }
+    }
+  };
+  protoOf(MessageQueue).g52 = function (element) {
+    return this.y51_1.h(element);
+  };
+  protoOf(MessageQueue).h = function (element) {
+    return this.g52((!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+  };
+  protoOf(MessageQueue).h52 = function (index, element) {
+    this.y51_1.a2(index, element);
+  };
+  protoOf(MessageQueue).a2 = function (index, element) {
+    return this.h52(index, (!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+  };
+  protoOf(MessageQueue).i52 = function (elements) {
+    return this.y51_1.s(elements);
+  };
+  protoOf(MessageQueue).s = function (elements) {
+    return this.i52(elements);
+  };
+  protoOf(MessageQueue).y1 = function () {
+    this.y51_1.y1();
+  };
+  protoOf(MessageQueue).j52 = function (index, element) {
+    return this.y51_1.z1(index, element);
+  };
+  protoOf(MessageQueue).z1 = function (index, element) {
+    return this.j52(index, (!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+  };
+  protoOf(MessageQueue).b2 = function (index) {
+    return this.y51_1.b2(index);
+  };
+  protoOf(MessageQueue).c2 = function () {
+    return this.y51_1.c2();
+  };
+  protoOf(MessageQueue).o = function (index) {
+    return this.y51_1.o(index);
+  };
+  protoOf(MessageQueue).l = function () {
+    return this.y51_1.l();
+  };
+  protoOf(MessageQueue).k52 = function (element) {
+    return this.y51_1.l1(element);
+  };
+  protoOf(MessageQueue).l1 = function (element) {
+    if (!(!(element == null) ? isInterface(element, Runnable) : false))
+      return false;
+    return this.k52((!(element == null) ? isInterface(element, Runnable) : false) ? element : THROW_CCE());
+  };
+  protoOf(MessageQueue).i = function () {
+    return this.y51_1.i();
+  };
+  protoOf(MessageQueue).l52 = function (elements) {
+    return this.y51_1.m1(elements);
+  };
+  protoOf(MessageQueue).m1 = function (elements) {
+    return this.l52(elements);
+  };
+  protoOf(MessageQueue).m = function (index) {
+    return this.y51_1.m(index);
+  };
+  protoOf(MessageQueue).n = function () {
+    return this.y51_1.ad_1;
+  };
+  function WindowDispatcher(window_0) {
+    CoroutineDispatcher.call(this);
+    this.h53_1 = window_0;
+    this.i53_1 = new WindowMessageQueue(this.h53_1);
+  }
+  protoOf(WindowDispatcher).q4y = function (context, block) {
+    return this.i53_1.f52(block);
+  };
+  //region block: post-declaration
+  protoOf(JobSupport).xe = plus;
+  protoOf(JobSupport).m8 = get_0;
+  protoOf(JobSupport).we = fold;
+  protoOf(JobSupport).ve = minusKey_0;
+  protoOf(CoroutineDispatcher).m8 = get;
+  protoOf(CoroutineDispatcher).ve = minusKey;
+  defineProp(protoOf(DispatchException), 'cause', function () {
+    return this.f();
+  });
+  //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
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = await_0;
+  _.$_$.b = GlobalScope_instance;
+  _.$_$.c = CoroutineScope;
+  _.$_$.d = promise;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=kotlinx-coroutines-core.js.map