@jakta/jakta-prolog-incarnation 0.0.0-bootstrap

package/2p-utils.js

@@ -0,0 +1,1361 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module '2p-utils'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to '2p-utils'.");
+    }
+    globalThis['2p-utils'] = factory(typeof globalThis['2p-utils'] === 'undefined' ? {} : globalThis['2p-utils'], globalThis['kotlin-kotlin-stdlib']);
+  }
+}(function (_, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var protoOf = kotlin_kotlin.$_$.n6;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.z5;
+  var Unit_instance = kotlin_kotlin.$_$.m;
+  var initMetadataForInterface = kotlin_kotlin.$_$.a6;
+  var THROW_CCE = kotlin_kotlin.$_$.ha;
+  var isInterface = kotlin_kotlin.$_$.f6;
+  var initMetadataForClass = kotlin_kotlin.$_$.y5;
+  var Sequence = kotlin_kotlin.$_$.h7;
+  var VOID = kotlin_kotlin.$_$.b;
+  var arrayIterator = kotlin_kotlin.$_$.j5;
+  var toList = kotlin_kotlin.$_$.q8;
+  var asSequence = kotlin_kotlin.$_$.z1;
+  var asIterable = kotlin_kotlin.$_$.v1;
+  var hashCode = kotlin_kotlin.$_$.x5;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.b2;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.n;
+  var asIterable_0 = kotlin_kotlin.$_$.j7;
+  var sequence = kotlin_kotlin.$_$.k8;
+  var IntRange = kotlin_kotlin.$_$.z6;
+  var zip = kotlin_kotlin.$_$.u8;
+  var equals = kotlin_kotlin.$_$.t5;
+  var FunctionAdapter = kotlin_kotlin.$_$.i5;
+  var Comparator = kotlin_kotlin.$_$.w9;
+  var CoroutineImpl = kotlin_kotlin.$_$.j4;
+  var SequenceScope = kotlin_kotlin.$_$.g7;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.i4;
+  var initMetadataForLambda = kotlin_kotlin.$_$.b6;
+  var constructCallableReference = kotlin_kotlin.$_$.r5;
+  var withIndex = kotlin_kotlin.$_$.t8;
+  var ensureNotNull = kotlin_kotlin.$_$.la;
+  var map = kotlin_kotlin.$_$.d8;
+  var filterNot = kotlin_kotlin.$_$.r7;
+  var toMutableList = kotlin_kotlin.$_$.r8;
+  var minWithOrNull = kotlin_kotlin.$_$.e8;
+  var subtract = kotlin_kotlin.$_$.g5;
+  var convertToInt = kotlin_kotlin.$_$.t4;
+  var toString = kotlin_kotlin.$_$.ra;
+  var initMetadataForObject = kotlin_kotlin.$_$.c6;
+  var KtMap = kotlin_kotlin.$_$.q1;
+  var toString_0 = kotlin_kotlin.$_$.q6;
+  var lazy = kotlin_kotlin.$_$.na;
+  var KProperty1 = kotlin_kotlin.$_$.f7;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.v5;
+  var getKClassFromExpression = kotlin_kotlin.$_$.d7;
+  var NoSuchElementException_init_$Create$ = kotlin_kotlin.$_$.h1;
+  var equalsLong = kotlin_kotlin.$_$.w4;
+  var first = kotlin_kotlin.$_$.n2;
+  var to = kotlin_kotlin.$_$.sa;
+  var Pair = kotlin_kotlin.$_$.fa;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.q;
+  var joinToString = kotlin_kotlin.$_$.z7;
+  var mutableListOf = kotlin_kotlin.$_$.i3;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.o;
+  var addAll = kotlin_kotlin.$_$.s1;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForCompanion(Companion);
+  function getOrSet(key, valueGenerator) {
+    var got = this.f2(key);
+    var tmp;
+    if (got instanceof Some) {
+      tmp = got.ho_1;
+    } else {
+      // Inline function 'kotlin.also' call
+      var this_0 = valueGenerator();
+      this.fo(key, this_0);
+      tmp = this_0;
+    }
+    return tmp;
+  }
+  initMetadataForInterface(Cache, 'Cache');
+  initMetadataForCompanion(Companion_0);
+  function ifValid(consumer) {
+    var tmp;
+    if (this.jo()) {
+      var tmp_0 = Companion_instance_4;
+      // Inline function 'kotlin.let' call
+      var tmp$ret$0 = consumer(this.c2());
+      tmp = tmp_0.no(tmp$ret$0);
+    } else {
+      tmp = Companion_instance_4.mo();
+    }
+    return tmp;
+  }
+  initMetadataForInterface(Cached, 'Cached');
+  function castTo() {
+    return isInterface(this, Castable) ? this : THROW_CCE();
+  }
+  initMetadataForInterface(Castable, 'Castable');
+  initMetadataForCompanion(Companion_1);
+  initMetadataForClass(Cursor$asIterable$$inlined$Iterable$1);
+  initMetadataForClass(Cursor$asSequence$$inlined$Sequence$1, VOID, VOID, VOID, [Sequence]);
+  function asIterable_1() {
+    // Inline function 'kotlin.collections.Iterable' call
+    return new Cursor$asIterable$$inlined$Iterable$1(this);
+  }
+  function asSequence_0() {
+    // Inline function 'kotlin.sequences.Sequence' call
+    return new Cursor$asSequence$$inlined$Sequence$1(this);
+  }
+  initMetadataForInterface(Cursor, 'Cursor');
+  function component1() {
+    return this.wo();
+  }
+  function component2() {
+    return this.c2();
+  }
+  initMetadataForInterface(Indexed, 'Indexed');
+  initMetadataForCompanion(Companion_2);
+  function compareTo(other) {
+    return this.wo() - other.wo() | 0;
+  }
+  initMetadataForInterface(IntIndexed, 'IntIndexed', VOID, VOID, [Indexed]);
+  initMetadataForClass(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+  initMetadataForLambda(dropLast$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForLambda(insertAt$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForClass(sam$kotlin_Comparator$0_0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+  initMetadataForLambda(merge$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForCompanion(Companion_3);
+  function compareTo_0(other) {
+    return convertToInt(subtract(this.wo(), other.wo()));
+  }
+  initMetadataForInterface(LongIndexed, 'LongIndexed', VOID, VOID, [Indexed]);
+  initMetadataForCompanion(Companion_4);
+  initMetadataForClass(Optional, 'Optional');
+  initMetadataForClass(Some, 'Some', VOID, Optional);
+  initMetadataForObject(None, 'None', VOID, Optional);
+  function getTag(name) {
+    return this.vq().f2(name);
+  }
+  function containsTag(name) {
+    // Inline function 'kotlin.collections.contains' call
+    // Inline function 'kotlin.collections.containsKey' call
+    var this_0 = this.vq();
+    return (isInterface(this_0, KtMap) ? this_0 : THROW_CCE()).d2(name);
+  }
+  initMetadataForInterface(Taggable, 'Taggable');
+  initMetadataForCompanion(Companion_5);
+  initMetadataForClass(AbstractCursor$iterator$1);
+  initMetadataForClass(AbstractCursor, 'AbstractCursor', VOID, VOID, [Cursor]);
+  initMetadataForClass(CachedImpl, 'CachedImpl', VOID, VOID, [Cached]);
+  initMetadataForClass(ConjunctionCursor, 'ConjunctionCursor', VOID, AbstractCursor);
+  initMetadataForObject(EmptyCursor, 'EmptyCursor', VOID, AbstractCursor);
+  initMetadataForClass(IntIndexedImpl, 'IntIndexedImpl', VOID, VOID, [IntIndexed]);
+  initMetadataForClass(LazyCursor, 'LazyCursor', VOID, AbstractCursor);
+  initMetadataForClass(LongIndexedImpl, 'LongIndexedImpl', VOID, VOID, [LongIndexed]);
+  initMetadataForClass(MapperCursor, 'MapperCursor', VOID, AbstractCursor);
+  initMetadataForClass(NonLastCursor, 'NonLastCursor', VOID, AbstractCursor);
+  initMetadataForClass(SimpleLRUCache, 'SimpleLRUCache', VOID, VOID, [Cache]);
+  initMetadataForClass(ValueCursor, 'ValueCursor', VOID, AbstractCursor);
+  //endregion
+  function Companion() {
+  }
+  protoOf(Companion).eo = function (capacity) {
+    return new SimpleLRUCache(capacity);
+  };
+  var Companion_instance;
+  function Companion_getInstance() {
+    return Companion_instance;
+  }
+  function Cache() {
+  }
+  function Companion_0() {
+  }
+  protoOf(Companion_0).io = function (generator) {
+    return new CachedImpl(generator);
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_0() {
+    return Companion_instance_0;
+  }
+  function Cached() {
+  }
+  function Castable() {
+  }
+  function Companion_1() {
+  }
+  protoOf(Companion_1).of = function (iterator) {
+    return toCursor(iterator);
+  };
+  protoOf(Companion_1).ofSequence = function (sequence) {
+    return cursor(sequence);
+  };
+  protoOf(Companion_1).empty = function () {
+    return EmptyCursor_getInstance();
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_1() {
+    return Companion_instance_1;
+  }
+  function Cursor$asIterable$$inlined$Iterable$1(this$0) {
+    this.po_1 = this$0;
+  }
+  protoOf(Cursor$asIterable$$inlined$Iterable$1).m = function () {
+    return this.po_1.iterator();
+  };
+  function Cursor$asSequence$$inlined$Sequence$1(this$0) {
+    this.qo_1 = this$0;
+  }
+  protoOf(Cursor$asSequence$$inlined$Sequence$1).m = function () {
+    return this.qo_1.iterator();
+  };
+  function Cursor() {
+  }
+  function cursor(_this__u8e3s4) {
+    return toCursor(_this__u8e3s4.m());
+  }
+  function plus(_this__u8e3s4, other) {
+    return other.to() ? new ConjunctionCursor(_this__u8e3s4, forceCast(other)) : _this__u8e3s4.to() ? _this__u8e3s4 : EmptyCursor_getInstance();
+  }
+  function cursor_0(_this__u8e3s4) {
+    return toCursor(_this__u8e3s4.m());
+  }
+  function cursor_1(_this__u8e3s4) {
+    return toCursor(arrayIterator(_this__u8e3s4));
+  }
+  function toCursor(_this__u8e3s4) {
+    return Companion_instance_5.vo(_this__u8e3s4);
+  }
+  function Indexed() {
+  }
+  function Companion_2() {
+  }
+  protoOf(Companion_2).xo = function (index, value) {
+    return new IntIndexedImpl(index, value);
+  };
+  var Companion_instance_2;
+  function Companion_getInstance_2() {
+    return Companion_instance_2;
+  }
+  function IntIndexed() {
+  }
+  function cached(_this__u8e3s4) {
+    return cursor(_this__u8e3s4).asSequence();
+  }
+  function buffered(_this__u8e3s4) {
+    return asSequence(toList(_this__u8e3s4));
+  }
+  function itemWiseHashCode(items) {
+    return itemWiseHashCode_0(asIterable(items));
+  }
+  function itemWiseHashCode_0(iterable) {
+    var hash = 13;
+    var i = iterable.m();
+    while (i.p()) {
+      var tmp = imul(31, hash);
+      var tmp0_safe_receiver = i.q();
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+      hash = tmp + (tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs) | 0;
+    }
+    return hash;
+  }
+  function itemWiseEquals(iterable1, iterable2) {
+    return itemWiseEquals_1(iterable1, iterable2, itemWiseEquals$lambda);
+  }
+  function mergeSequences(iterables, comparator) {
+    var tmp = new sam$kotlin_Comparator$0(comparator);
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(iterables, 10));
+    var _iterator__ex2g4s = iterables.m();
+    while (_iterator__ex2g4s.p()) {
+      var item = _iterator__ex2g4s.q();
+      var tmp$ret$2 = asIterable_0(item);
+      destination.j(tmp$ret$2);
+    }
+    return merge(tmp, destination);
+  }
+  function dropLast(_this__u8e3s4) {
+    return sequence(dropLast$slambda_0(_this__u8e3s4, null));
+  }
+  function itemWiseHashCode_1(sequence) {
+    return itemWiseHashCode_0(asIterable_0(sequence));
+  }
+  function itemWiseEquals_0(sequence1, sequence2, comparator) {
+    return itemWiseEquals_1(asIterable_0(sequence1), asIterable_0(sequence2), comparator);
+  }
+  function insertAt(_this__u8e3s4, index, item, items) {
+    return sequence(insertAt$slambda_0(_this__u8e3s4, index, item, items, null));
+  }
+  function itemWiseEquals_1(iterable1, iterable2, comparator) {
+    var i = iterable1.m();
+    var j = iterable2.m();
+    while (i.p() && j.p()) {
+      var a = i.q();
+      var b = j.q();
+      if (!comparator(a, b)) {
+        return false;
+      }
+    }
+    return i.p() === j.p();
+  }
+  function merge(comparator, iterables) {
+    return sequence(merge$slambda_0(iterables, comparator, null));
+  }
+  function indexed(_this__u8e3s4) {
+    var tmp = asSequence(new IntRange(0, 2147483647));
+    return zip(_this__u8e3s4, tmp, indexed$lambda);
+  }
+  function sam$kotlin_Comparator$0(function_0) {
+    this.zo_1 = function_0;
+  }
+  protoOf(sam$kotlin_Comparator$0).db = function (a, b) {
+    return this.zo_1(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
+    return this.db(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0).u2 = function () {
+    return this.zo_1;
+  };
+  protoOf(sam$kotlin_Comparator$0).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, Comparator) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.u2(), other.u2());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(sam$kotlin_Comparator$0).hashCode = function () {
+    return hashCode(this.u2());
+  };
+  function itemWiseEquals$lambda(a, b) {
+    return equals(a, b);
+  }
+  function dropLast$slambda($this_dropLast, resultContinuation) {
+    this.ip_1 = $this_dropLast;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(dropLast$slambda).lp = function ($this$sequence, $completion) {
+    var tmp = this.mp($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(dropLast$slambda).f9 = function (p1, $completion) {
+    return this.lp(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(dropLast$slambda).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 5;
+            this.kp_1 = this.ip_1.m();
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.kp_1.p()) {
+              this.g8_1 = 4;
+              continue $sm;
+            }
+
+            var current = this.kp_1.q();
+            if (this.kp_1.p()) {
+              this.g8_1 = 2;
+              suspendResult = this.jp_1.nc(current, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.g8_1 = 3;
+              continue $sm;
+            }
+
+          case 2:
+            this.g8_1 = 3;
+            continue $sm;
+          case 3:
+            this.g8_1 = 1;
+            continue $sm;
+          case 4:
+            return Unit_instance;
+          case 5:
+            throw this.j8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 5) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(dropLast$slambda).mp = function ($this$sequence, completion) {
+    var i = new dropLast$slambda(this.ip_1, completion);
+    i.jp_1 = $this$sequence;
+    return i;
+  };
+  function dropLast$slambda_0($this_dropLast, resultContinuation) {
+    var i = new dropLast$slambda($this_dropLast, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.lp($this$sequence, $completion);
+    }, 1);
+  }
+  function insertAt$slambda($this_insertAt, $index, $item, $items, resultContinuation) {
+    this.vp_1 = $this_insertAt;
+    this.wp_1 = $index;
+    this.xp_1 = $item;
+    this.yp_1 = $items;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(insertAt$slambda).lp = function ($this$sequence, $completion) {
+    var tmp = this.mp($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(insertAt$slambda).f9 = function (p1, $completion) {
+    return this.lp(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(insertAt$slambda).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 7;
+            this.bq_1 = asIterable_0(withIndex(this.vp_1)).m();
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.bq_1.p()) {
+              this.g8_1 = 6;
+              continue $sm;
+            }
+
+            var _destruct__k2r9zo = this.bq_1.q();
+            var i = _destruct__k2r9zo.ac();
+            this.aq_1 = _destruct__k2r9zo.bc();
+            if (i === this.wp_1) {
+              this.g8_1 = 2;
+              suspendResult = this.zp_1.nc(this.xp_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.g8_1 = 4;
+              continue $sm;
+            }
+
+          case 2:
+            this.g8_1 = 3;
+            suspendResult = this.zp_1.pc(asIterable(this.yp_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 3:
+            this.g8_1 = 4;
+            continue $sm;
+          case 4:
+            this.g8_1 = 5;
+            suspendResult = this.zp_1.nc(this.aq_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 5:
+            this.g8_1 = 1;
+            continue $sm;
+          case 6:
+            return Unit_instance;
+          case 7:
+            throw this.j8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 7) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(insertAt$slambda).mp = function ($this$sequence, completion) {
+    var i = new insertAt$slambda(this.vp_1, this.wp_1, this.xp_1, this.yp_1, completion);
+    i.zp_1 = $this$sequence;
+    return i;
+  };
+  function insertAt$slambda_0($this_insertAt, $index, $item, $items, resultContinuation) {
+    var i = new insertAt$slambda($this_insertAt, $index, $item, $items, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.lp($this$sequence, $completion);
+    }, 1);
+  }
+  function sam$kotlin_Comparator$0_0(function_0) {
+    this.cq_1 = function_0;
+  }
+  protoOf(sam$kotlin_Comparator$0_0).db = function (a, b) {
+    return this.cq_1(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0_0).compare = function (a, b) {
+    return this.db(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0_0).u2 = function () {
+    return this.cq_1;
+  };
+  protoOf(sam$kotlin_Comparator$0_0).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, Comparator) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.u2(), other.u2());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(sam$kotlin_Comparator$0_0).hashCode = function () {
+    return hashCode(this.u2());
+  };
+  function merge$slambda$lambda(it) {
+    return cursor_0(it);
+  }
+  function merge$slambda$lambda_0(it) {
+    return it.uo();
+  }
+  function merge$slambda$lambda_1(it) {
+    return ensureNotNull(it.so());
+  }
+  function merge$slambda$lambda_2($comparator) {
+    return function (a, b) {
+      return $comparator.compare(a.c2(), b.c2());
+    };
+  }
+  function merge$slambda($iterables, $comparator, resultContinuation) {
+    this.lq_1 = $iterables;
+    this.mq_1 = $comparator;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(merge$slambda).lp = function ($this$sequence, $completion) {
+    var tmp = this.mp($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(merge$slambda).f9 = function (p1, $completion) {
+    return this.lp(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(merge$slambda).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 3;
+            var tmp_0 = this;
+            var tmp_1 = asSequence(this.lq_1);
+            var tmp_2 = map(tmp_1, merge$slambda$lambda);
+            tmp_0.pq_1 = toMutableList(filterNot(tmp_2, merge$slambda$lambda_0));
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!!this.pq_1.g()) {
+              this.g8_1 = 4;
+              continue $sm;
+            }
+
+            var tmp_3 = asSequence(this.pq_1);
+            var tmp_4 = indexed(map(tmp_3, merge$slambda$lambda_1));
+            var tmp_5 = merge$slambda$lambda_2(this.mq_1);
+            var _destruct__k2r9zo = ensureNotNull(minWithOrNull(tmp_4, new sam$kotlin_Comparator$0_0(tmp_5)));
+            this.oq_1 = _destruct__k2r9zo.ac();
+            var minValue = _destruct__k2r9zo.bc();
+            this.g8_1 = 2;
+            suspendResult = this.nq_1.nc(minValue, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            var it = this.pq_1.t(this.oq_1).ro();
+            var tmp_6;
+            if (it.uo()) {
+              tmp_6 = this.pq_1.l3(this.oq_1);
+            } else {
+              this.pq_1.d4(this.oq_1, it);
+              tmp_6 = Unit_instance;
+            }
+
+            this.g8_1 = 1;
+            continue $sm;
+          case 3:
+            throw this.j8_1;
+          case 4:
+            return Unit_instance;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 3) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(merge$slambda).mp = function ($this$sequence, completion) {
+    var i = new merge$slambda(this.lq_1, this.mq_1, completion);
+    i.nq_1 = $this$sequence;
+    return i;
+  };
+  function merge$slambda_0($iterables, $comparator, resultContinuation) {
+    var i = new merge$slambda($iterables, $comparator, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.lp($this$sequence, $completion);
+    }, 1);
+  }
+  function indexed$lambda(it, i) {
+    return Companion_instance_2.xo(i, it);
+  }
+  function Companion_3() {
+  }
+  protoOf(Companion_3).qq = function (index, value) {
+    return new LongIndexedImpl(index, value);
+  };
+  var Companion_instance_3;
+  function Companion_getInstance_3() {
+    return Companion_instance_3;
+  }
+  function LongIndexed() {
+  }
+  function Companion_4() {
+  }
+  protoOf(Companion_4).sq = function (value) {
+    return new Some(value);
+  };
+  protoOf(Companion_4).no = function (value) {
+    var tmp;
+    if (value == null) {
+      tmp = this.mo();
+    } else {
+      tmp = this.sq(value);
+    }
+    return tmp;
+  };
+  protoOf(Companion_4).mo = function () {
+    return None_getInstance();
+  };
+  var Companion_instance_4;
+  function Companion_getInstance_4() {
+    return Companion_instance_4;
+  }
+  function Some(value) {
+    Optional.call(this);
+    this.ho_1 = value;
+  }
+  protoOf(Some).c2 = function () {
+    return this.ho_1;
+  };
+  protoOf(Some).tq = function () {
+    return true;
+  };
+  protoOf(Some).toString = function () {
+    return 'Some(' + toString(this.ho_1) + ')';
+  };
+  protoOf(Some).hashCode = function () {
+    return this.ho_1 == null ? 0 : hashCode(this.ho_1);
+  };
+  protoOf(Some).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Some))
+      return false;
+    if (!equals(this.ho_1, other.ho_1))
+      return false;
+    return true;
+  };
+  function None() {
+    None_instance = this;
+    Optional.call(this);
+  }
+  protoOf(None).c2 = function () {
+    return null;
+  };
+  protoOf(None).tq = function () {
+    return false;
+  };
+  protoOf(None).toString = function () {
+    return 'None';
+  };
+  var None_instance;
+  function None_getInstance() {
+    if (None_instance == null)
+      new None();
+    return None_instance;
+  }
+  function Optional() {
+  }
+  protoOf(Optional).uq = function () {
+    return !this.tq();
+  };
+  function Taggable() {
+  }
+  function setTags(_this__u8e3s4, tags) {
+    var tmp = _this__u8e3s4.resetTags(tags);
+    return isInterface(tmp, Taggable) ? tmp : THROW_CCE();
+  }
+  function synchronizedOnSelf(_this__u8e3s4, action) {
+    return synchronizedOn(_this__u8e3s4, action);
+  }
+  function Companion_5() {
+  }
+  protoOf(Companion_5).vo = function (source) {
+    var tmp;
+    if (source.p()) {
+      tmp = new LazyCursor(source);
+    } else {
+      tmp = EmptyCursor_getInstance();
+    }
+    return tmp;
+  };
+  var Companion_instance_5;
+  function Companion_getInstance_5() {
+    return Companion_instance_5;
+  }
+  function AbstractCursor$iterator$1(this$0) {
+    this.wq_1 = this$0;
+  }
+  protoOf(AbstractCursor$iterator$1).p = function () {
+    return !this.wq_1.uo();
+  };
+  protoOf(AbstractCursor$iterator$1).q = function () {
+    var result = this.wq_1.so();
+    this.wq_1 = this.wq_1.ro();
+    return ensureNotNull(result);
+  };
+  function AbstractCursor() {
+  }
+  protoOf(AbstractCursor).toString = function () {
+    return this.uo() ? '[]' : !this.to() ? '[' + toString(this.so()) + ']' : '[' + toString(this.so()) + ', ...]';
+  };
+  protoOf(AbstractCursor).m = function () {
+    return new AbstractCursor$iterator$1(this);
+  };
+  protoOf(AbstractCursor).iterator = function () {
+    return this.m();
+  };
+  protoOf(AbstractCursor).xq = function () {
+    return false;
+  };
+  protoOf(AbstractCursor).yq = function (mapper) {
+    return new MapperCursor(this, mapper);
+  };
+  protoOf(AbstractCursor).map = function (mapper) {
+    return this.yq(mapper);
+  };
+  function CachedImpl(generator) {
+    this.zq_1 = generator;
+    this.ar_1 = Companion_instance_4.mo();
+  }
+  protoOf(CachedImpl).jo = function () {
+    return this.ar_1.tq();
+  };
+  protoOf(CachedImpl).br = function () {
+    return this.ar_1.uq();
+  };
+  protoOf(CachedImpl).c2 = function () {
+    this.cr();
+    return ensureNotNull(this.ar_1.c2());
+  };
+  protoOf(CachedImpl).cr = function () {
+    if (this.br()) {
+      this.ar_1 = Companion_instance_4.sq(this.zq_1());
+    }
+  };
+  protoOf(CachedImpl).ko = function () {
+    this.ar_1 = Companion_instance_4.mo();
+  };
+  protoOf(CachedImpl).toString = function () {
+    return 'CachedImpl(generator=' + toString_0(this.zq_1) + ')';
+  };
+  protoOf(CachedImpl).hashCode = function () {
+    return hashCode(this.zq_1);
+  };
+  protoOf(CachedImpl).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CachedImpl))
+      return false;
+    if (!equals(this.zq_1, other.zq_1))
+      return false;
+    return true;
+  };
+  function ConjunctionCursor$next$delegate$lambda(this$0) {
+    return function () {
+      return this$0.dr_1.to() ? new ConjunctionCursor(this$0.dr_1.ro(), this$0.er_1) : this$0.er_1.xq() ? this$0.er_1.ro() : this$0.er_1;
+    };
+  }
+  function ConjunctionCursor$_get_next_$ref_xfvrtr() {
+    return constructCallableReference(function (p0) {
+      return p0.ro();
+    }, 1, 0, 1);
+  }
+  function ConjunctionCursor(first, second) {
+    AbstractCursor.call(this);
+    this.dr_1 = first;
+    this.er_1 = second;
+    var tmp = this;
+    tmp.fr_1 = lazy(ConjunctionCursor$next$delegate$lambda(this));
+  }
+  protoOf(ConjunctionCursor).uo = function () {
+    return this.dr_1.uo() && this.er_1.uo();
+  };
+  protoOf(ConjunctionCursor).ro = function () {
+    var tmp0 = this.fr_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('next', 1, tmp, ConjunctionCursor$_get_next_$ref_xfvrtr(), null);
+    return tmp0.c2();
+  };
+  protoOf(ConjunctionCursor).so = function () {
+    return this.dr_1.to() ? this.dr_1.so() : this.er_1.so();
+  };
+  protoOf(ConjunctionCursor).to = function () {
+    return this.dr_1.to() || this.er_1.to();
+  };
+  protoOf(ConjunctionCursor).equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (!(other instanceof ConjunctionCursor))
+      THROW_CCE();
+    if (!equals(this.dr_1, other.dr_1))
+      return false;
+    if (!equals(this.er_1, other.er_1))
+      return false;
+    return true;
+  };
+  protoOf(ConjunctionCursor).hashCode = function () {
+    var result = hashCode(this.dr_1);
+    result = imul(31, result) + hashCode(this.er_1) | 0;
+    return result;
+  };
+  function EmptyCursor() {
+    EmptyCursor_instance = this;
+    AbstractCursor.call(this);
+  }
+  protoOf(EmptyCursor).ro = function () {
+    throw NoSuchElementException_init_$Create$();
+  };
+  protoOf(EmptyCursor).so = function () {
+    return null;
+  };
+  protoOf(EmptyCursor).to = function () {
+    return false;
+  };
+  protoOf(EmptyCursor).uo = function () {
+    return true;
+  };
+  protoOf(EmptyCursor).toString = function () {
+    return protoOf(AbstractCursor).toString.call(this);
+  };
+  protoOf(EmptyCursor).gr = function (mapper) {
+    return this;
+  };
+  protoOf(EmptyCursor).map = function (mapper) {
+    return this.gr(mapper);
+  };
+  protoOf(EmptyCursor).yq = function (mapper) {
+    return this.gr(mapper);
+  };
+  var EmptyCursor_instance;
+  function EmptyCursor_getInstance() {
+    if (EmptyCursor_instance == null)
+      new EmptyCursor();
+    return EmptyCursor_instance;
+  }
+  function IntIndexedImpl(index, value) {
+    this.hr_1 = index;
+    this.ir_1 = value;
+  }
+  protoOf(IntIndexedImpl).wo = function () {
+    return this.hr_1;
+  };
+  protoOf(IntIndexedImpl).c2 = function () {
+    return this.ir_1;
+  };
+  protoOf(IntIndexedImpl).ac = function () {
+    return this.hr_1;
+  };
+  protoOf(IntIndexedImpl).bc = function () {
+    return this.ir_1;
+  };
+  protoOf(IntIndexedImpl).toString = function () {
+    return 'IntIndexedImpl(index=' + this.hr_1 + ', value=' + toString(this.ir_1) + ')';
+  };
+  protoOf(IntIndexedImpl).hashCode = function () {
+    var result = this.hr_1;
+    result = imul(result, 31) + (this.ir_1 == null ? 0 : hashCode(this.ir_1)) | 0;
+    return result;
+  };
+  protoOf(IntIndexedImpl).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof IntIndexedImpl))
+      return false;
+    if (!(this.hr_1 === other.hr_1))
+      return false;
+    if (!equals(this.ir_1, other.ir_1))
+      return false;
+    return true;
+  };
+  protoOf(IntIndexedImpl).y1 = function (other) {
+    return this.yo((!(other == null) ? isInterface(other, IntIndexed) : false) ? other : THROW_CCE());
+  };
+  function _get_wrapped__s2ip8($this) {
+    var tmp0 = $this.kr_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('wrapped', 1, tmp, LazyCursor$_get_wrapped_$ref_p28zr5(), null);
+    return tmp0.c2();
+  }
+  function LazyCursor$wrapped$delegate$lambda(this$0) {
+    return function () {
+      return new NonLastCursor(this$0.jr_1);
+    };
+  }
+  function LazyCursor$_get_wrapped_$ref_p28zr5() {
+    return constructCallableReference(function (p0) {
+      return _get_wrapped__s2ip8(p0);
+    }, 1, 0, 2);
+  }
+  function LazyCursor(delegate) {
+    AbstractCursor.call(this);
+    this.jr_1 = delegate;
+    var tmp = this;
+    tmp.kr_1 = lazy(LazyCursor$wrapped$delegate$lambda(this));
+  }
+  protoOf(LazyCursor).xq = function () {
+    return true;
+  };
+  protoOf(LazyCursor).ro = function () {
+    return _get_wrapped__s2ip8(this).ro();
+  };
+  protoOf(LazyCursor).so = function () {
+    return _get_wrapped__s2ip8(this).so();
+  };
+  protoOf(LazyCursor).to = function () {
+    return true;
+  };
+  protoOf(LazyCursor).uo = function () {
+    return false;
+  };
+  protoOf(LazyCursor).toString = function () {
+    return protoOf(AbstractCursor).toString.call(this);
+  };
+  protoOf(LazyCursor).m = function () {
+    return _get_wrapped__s2ip8(this).m();
+  };
+  protoOf(LazyCursor).iterator = function () {
+    return this.m();
+  };
+  protoOf(LazyCursor).hashCode = function () {
+    return hashCode(this.jr_1);
+  };
+  protoOf(LazyCursor).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof LazyCursor))
+      return false;
+    if (!equals(this.jr_1, other.jr_1))
+      return false;
+    return true;
+  };
+  function LongIndexedImpl(index, value) {
+    this.lr_1 = index;
+    this.mr_1 = value;
+  }
+  protoOf(LongIndexedImpl).wo = function () {
+    return this.lr_1;
+  };
+  protoOf(LongIndexedImpl).c2 = function () {
+    return this.mr_1;
+  };
+  protoOf(LongIndexedImpl).rq = function (other) {
+    return convertToInt(subtract(this.lr_1, other.wo()));
+  };
+  protoOf(LongIndexedImpl).y1 = function (other) {
+    return this.rq((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  protoOf(LongIndexedImpl).ac = function () {
+    return this.lr_1;
+  };
+  protoOf(LongIndexedImpl).bc = function () {
+    return this.mr_1;
+  };
+  protoOf(LongIndexedImpl).toString = function () {
+    return 'LongIndexedImpl(index=' + this.lr_1.toString() + ', value=' + toString(this.mr_1) + ')';
+  };
+  protoOf(LongIndexedImpl).hashCode = function () {
+    var result = this.lr_1.hashCode();
+    result = imul(result, 31) + (this.mr_1 == null ? 0 : hashCode(this.mr_1)) | 0;
+    return result;
+  };
+  protoOf(LongIndexedImpl).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof LongIndexedImpl))
+      return false;
+    if (!equalsLong(this.lr_1, other.lr_1))
+      return false;
+    if (!equals(this.mr_1, other.mr_1))
+      return false;
+    return true;
+  };
+  function MapperCursor$current$delegate$lambda(this$0) {
+    return function () {
+      return this$0.pr_1(ensureNotNull(this$0.nr_1.so()));
+    };
+  }
+  function MapperCursor$_get_current_$ref_lsggiu() {
+    return constructCallableReference(function (p0) {
+      return p0.so();
+    }, 1, 0, 3);
+  }
+  function MapperCursor(wrapped, mapper) {
+    AbstractCursor.call(this);
+    this.nr_1 = wrapped;
+    this.pr_1 = mapper;
+    var tmp = this;
+    tmp.qr_1 = lazy(MapperCursor$current$delegate$lambda(this));
+  }
+  protoOf(MapperCursor).ro = function () {
+    return this.nr_1.ro().yq(this.pr_1);
+  };
+  protoOf(MapperCursor).so = function () {
+    var tmp0 = this.qr_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('current', 1, tmp, MapperCursor$_get_current_$ref_lsggiu(), null);
+    return tmp0.c2();
+  };
+  protoOf(MapperCursor).to = function () {
+    return true;
+  };
+  protoOf(MapperCursor).uo = function () {
+    return false;
+  };
+  protoOf(MapperCursor).equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (!(other instanceof MapperCursor))
+      THROW_CCE();
+    if (!equals(this.nr_1, other.nr_1))
+      return false;
+    if (!equals(this.pr_1, other.pr_1))
+      return false;
+    return true;
+  };
+  protoOf(MapperCursor).hashCode = function () {
+    var result = hashCode(this.nr_1);
+    result = imul(31, result) + hashCode(this.pr_1) | 0;
+    return result;
+  };
+  protoOf(MapperCursor).rr = function (mapper) {
+    return new ValueCursor(mapper(this.so()), this.ro().yq(mapper));
+  };
+  protoOf(MapperCursor).map = function (mapper) {
+    return this.rr(mapper);
+  };
+  protoOf(MapperCursor).yq = function (mapper) {
+    return this.rr(mapper);
+  };
+  function NonLastCursor$next$delegate$lambda($source, this$0) {
+    return function () {
+      // Inline function 'kotlin.also' call
+      var this_0 = Companion_instance_5.vo($source);
+      this$0.sr_1 = null;
+      return this_0;
+    };
+  }
+  function NonLastCursor$_get_next_$ref_gp6ycu() {
+    return constructCallableReference(function (p0) {
+      return p0.ro();
+    }, 1, 0, 4);
+  }
+  function NonLastCursor(source) {
+    AbstractCursor.call(this);
+    this.sr_1 = source;
+    var tmp = this;
+    tmp.tr_1 = lazy(NonLastCursor$next$delegate$lambda(source, this));
+    this.ur_1 = source.q();
+  }
+  protoOf(NonLastCursor).ro = function () {
+    var tmp0 = this.tr_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('next', 1, tmp, NonLastCursor$_get_next_$ref_gp6ycu(), null);
+    return tmp0.c2();
+  };
+  protoOf(NonLastCursor).so = function () {
+    return this.ur_1;
+  };
+  protoOf(NonLastCursor).to = function () {
+    return true;
+  };
+  protoOf(NonLastCursor).uo = function () {
+    return false;
+  };
+  protoOf(NonLastCursor).toString = function () {
+    return protoOf(AbstractCursor).toString.call(this);
+  };
+  function removeLeastRecent($this) {
+    // Inline function 'kotlin.collections.asIterable' call
+    var tmp$ret$0 = $this.wr_1.b1();
+    var _destruct__k2r9zo = first(tmp$ret$0);
+    // Inline function 'kotlin.collections.component1' call
+    var key = _destruct__k2r9zo.b2();
+    // Inline function 'kotlin.collections.component2' call
+    var value = _destruct__k2r9zo.c2();
+    $this.wr_1.q4(key);
+    return Companion_instance_4.sq(to(key, value));
+  }
+  function removeLeastRecentIfNecessary($this) {
+    var tmp;
+    if ($this.wr_1.s() >= $this.vr_1) {
+      tmp = removeLeastRecent($this);
+    } else {
+      tmp = Companion_instance_4.mo();
+    }
+    return tmp;
+  }
+  function SimpleLRUCache$set$lambda(this$0, $key, $value) {
+    return function () {
+      var evicted = removeLeastRecentIfNecessary(this$0);
+      var tmp0 = this$0.wr_1;
+      var tmp2 = $key;
+      // Inline function 'kotlin.collections.set' call
+      var value = $value;
+      tmp0.p4(tmp2, value);
+      return evicted;
+    };
+  }
+  function SimpleLRUCache$get$lambda(this$0, $key) {
+    return function () {
+      var tmp;
+      if (this$0.wr_1.d2($key)) {
+        tmp = Companion_instance_4.no(this$0.wr_1.f2($key));
+      } else {
+        tmp = Companion_instance_4.mo();
+      }
+      return tmp;
+    };
+  }
+  function SimpleLRUCache$toSequence$lambda$lambda(it) {
+    // Inline function 'kotlin.collections.toPair' call
+    return new Pair(it.b2(), it.c2());
+  }
+  function SimpleLRUCache$toSequence$lambda(this$0) {
+    return function () {
+      var tmp = asSequence(this$0.wr_1.b1());
+      return buffered(map(tmp, SimpleLRUCache$toSequence$lambda$lambda));
+    };
+  }
+  function SimpleLRUCache$toString$lambda(it) {
+    return toString(it.first) + ' = ' + toString(it.second);
+  }
+  function SimpleLRUCache(capacity) {
+    this.vr_1 = capacity;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!(this.vr_1 > 0)) {
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString_0(message));
+    }
+    this.wr_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(SimpleLRUCache).fo = function (key, value) {
+    return synchronizedOnSelf(this, SimpleLRUCache$set$lambda(this, key, value));
+  };
+  protoOf(SimpleLRUCache).f2 = function (key) {
+    return synchronizedOnSelf(this, SimpleLRUCache$get$lambda(this, key));
+  };
+  protoOf(SimpleLRUCache).equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (!(other instanceof SimpleLRUCache))
+      THROW_CCE();
+    if (!(this.vr_1 === other.vr_1))
+      return false;
+    if (!this.wr_1.equals(other.wr_1))
+      return false;
+    return true;
+  };
+  protoOf(SimpleLRUCache).hashCode = function () {
+    var result = this.vr_1;
+    result = imul(31, result) + this.wr_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(SimpleLRUCache).xr = function () {
+    return synchronizedOnSelf(this, SimpleLRUCache$toSequence$lambda(this));
+  };
+  protoOf(SimpleLRUCache).toString = function () {
+    var tmp = this.xr();
+    return 'SimpleLRUCache(' + joinToString(map(tmp, SimpleLRUCache$toString$lambda), ', ') + ')';
+  };
+  function ValueCursor(current, next) {
+    AbstractCursor.call(this);
+    this.yr_1 = current;
+    this.zr_1 = next;
+  }
+  protoOf(ValueCursor).so = function () {
+    return this.yr_1;
+  };
+  protoOf(ValueCursor).ro = function () {
+    return this.zr_1;
+  };
+  protoOf(ValueCursor).to = function () {
+    return true;
+  };
+  protoOf(ValueCursor).uo = function () {
+    return false;
+  };
+  function dequeOf(items) {
+    return mutableListOf(items.slice());
+  }
+  function dequeOf_0(items) {
+    // Inline function 'kotlin.collections.mutableListOf' call
+    // Inline function 'kotlin.also' call
+    var this_0 = ArrayList_init_$Create$_0();
+    addAll(this_0, items);
+    return this_0;
+  }
+  function dequeOf_1(items) {
+    return toMutableList(items);
+  }
+  function takeFirst(_this__u8e3s4) {
+    if (_this__u8e3s4.g())
+      return null;
+    var first = _this__u8e3s4.t(0);
+    _this__u8e3s4.l3(0);
+    return first;
+  }
+  function addFirst(_this__u8e3s4, item) {
+    _this__u8e3s4.w3(0, item);
+  }
+  function addFirst_0(_this__u8e3s4, items) {
+    var i = _this__u8e3s4.g4();
+    var _iterator__ex2g4s = items.m();
+    while (_iterator__ex2g4s.p()) {
+      var item = _iterator__ex2g4s.q();
+      i.x3(item);
+    }
+  }
+  function synchronizedOn(obj, action) {
+    return action();
+  }
+  function forceCast(_this__u8e3s4) {
+    var it = _this__u8e3s4;
+    return it;
+  }
+  //region block: post-declaration
+  protoOf(AbstractCursor).asIterable = asIterable_1;
+  protoOf(AbstractCursor).asSequence = asSequence_0;
+  protoOf(CachedImpl).lo = ifValid;
+  protoOf(IntIndexedImpl).yo = compareTo;
+  protoOf(SimpleLRUCache).go = getOrSet;
+  //endregion
+  //region block: init
+  Companion_instance = new Companion();
+  Companion_instance_0 = new Companion_0();
+  Companion_instance_1 = new Companion_1();
+  Companion_instance_2 = new Companion_2();
+  Companion_instance_3 = new Companion_3();
+  Companion_instance_4 = new Companion_4();
+  Companion_instance_5 = new Companion_5();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_instance;
+  _.$_$.b = Companion_instance_0;
+  _.$_$.c = Companion_instance_1;
+  _.$_$.d = Companion_instance_3;
+  _.$_$.e = castTo;
+  _.$_$.f = Castable;
+  _.$_$.g = component1;
+  _.$_$.h = component2;
+  _.$_$.i = compareTo_0;
+  _.$_$.j = LongIndexed;
+  _.$_$.k = Some;
+  _.$_$.l = containsTag;
+  _.$_$.m = getTag;
+  _.$_$.n = Taggable;
+  _.$_$.o = addFirst_0;
+  _.$_$.p = addFirst;
+  _.$_$.q = buffered;
+  _.$_$.r = cached;
+  _.$_$.s = cursor_0;
+  _.$_$.t = cursor;
+  _.$_$.u = cursor_1;
+  _.$_$.v = dequeOf_1;
+  _.$_$.w = dequeOf_0;
+  _.$_$.x = dequeOf;
+  _.$_$.y = dropLast;
+  _.$_$.z = forceCast;
+  _.$_$.a1 = insertAt;
+  _.$_$.b1 = itemWiseEquals_0;
+  _.$_$.c1 = itemWiseEquals;
+  _.$_$.d1 = itemWiseHashCode_0;
+  _.$_$.e1 = itemWiseHashCode;
+  _.$_$.f1 = itemWiseHashCode_1;
+  _.$_$.g1 = mergeSequences;
+  _.$_$.h1 = plus;
+  _.$_$.i1 = setTags;
+  _.$_$.j1 = synchronizedOnSelf;
+  _.$_$.k1 = synchronizedOn;
+  _.$_$.l1 = takeFirst;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-utils.js.map