@tuprolog/2p-full 0.30.5 → 0.31.1-dev01

package/2p-utils.js

@@ -0,0 +1,1423 @@
+(function (_, kotlin_kotlin, kotlin_kt_math) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var objectMeta = kotlin_kotlin.$_$.i7;
+  var setMetadataFor = kotlin_kotlin.$_$.j7;
+  var Unit_getInstance = kotlin_kotlin.$_$.r2;
+  var interfaceMeta = kotlin_kotlin.$_$.u6;
+  var THROW_CCE = kotlin_kotlin.$_$.sb;
+  var isInterface = kotlin_kotlin.$_$.y6;
+  var classMeta = kotlin_kotlin.$_$.m6;
+  var Sequence = kotlin_kotlin.$_$.f8;
+  var arrayIterator = kotlin_kotlin.$_$.f6;
+  var Comparable = kotlin_kotlin.$_$.gb;
+  var sequence = kotlin_kotlin.$_$.j9;
+  var hashCode = kotlin_kotlin.$_$.t6;
+  var asIterable = kotlin_kotlin.$_$.h8;
+  var toList = kotlin_kotlin.$_$.p9;
+  var asSequence = kotlin_kotlin.$_$.g3;
+  var asIterable_0 = kotlin_kotlin.$_$.b3;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j3;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var IntCompanionObject_getInstance = kotlin_kotlin.$_$.l2;
+  var IntRange = kotlin_kotlin.$_$.x7;
+  var zip = kotlin_kotlin.$_$.t9;
+  var CoroutineImpl = kotlin_kotlin.$_$.c6;
+  var SequenceScope = kotlin_kotlin.$_$.e8;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.b6;
+  var withIndex = kotlin_kotlin.$_$.s9;
+  var equals = kotlin_kotlin.$_$.o6;
+  var ensureNotNull = kotlin_kotlin.$_$.vb;
+  var map = kotlin_kotlin.$_$.c9;
+  var filterNot = kotlin_kotlin.$_$.q8;
+  var toMutableList = kotlin_kotlin.$_$.q9;
+  var minWithOrNull = kotlin_kotlin.$_$.d9;
+  var Regex_init_$Create$ = kotlin_kotlin.$_$.h1;
+  var toString = kotlin_kotlin.$_$.n7;
+  var Companion_getInstance = kotlin_kt_math.$_$.f;
+  var Companion_getInstance_0 = kotlin_kt_math.$_$.e;
+  var isObject = kotlin_kotlin.$_$.a7;
+  var Map = kotlin_kotlin.$_$.w2;
+  var toMutableMap = kotlin_kotlin.$_$.v5;
+  var lazy = kotlin_kotlin.$_$.xb;
+  var getKClassFromExpression = kotlin_kotlin.$_$.b;
+  var KProperty1 = kotlin_kotlin.$_$.d8;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.r6;
+  var NoSuchElementException_init_$Create$ = kotlin_kotlin.$_$.v1;
+  var Pair = kotlin_kotlin.$_$.qb;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.p1;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.f1;
+  var joinToString$default = kotlin_kotlin.$_$.h;
+  var mutableListOf = kotlin_kotlin.$_$.s4;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.c1;
+  var addAll = kotlin_kotlin.$_$.y2;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(Companion, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function getOrSet(key, valueGenerator) {
+    var got = this.a3(key);
+    var tmp;
+    if (got instanceof Some) {
+      tmp = got.jq_1;
+    } else {
+      var tmp$ret$0;
+      // Inline function 'kotlin.also' call
+      var tmp0_also = valueGenerator();
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'it.unibo.tuprolog.utils.Cache.getOrSet.<anonymous>' call
+      this.hq(key, tmp0_also);
+      tmp$ret$0 = tmp0_also;
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  }
+  setMetadataFor(Cache, 'Cache', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_0, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function ifValid(consumer) {
+    var tmp;
+    if (this.lq()) {
+      var tmp_0 = Companion_getInstance_7();
+      var tmp$ret$0;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = this.b1();
+      // Inline function 'kotlin.contracts.contract' call
+      tmp$ret$0 = consumer(tmp0_let);
+      tmp = tmp_0.pq(tmp$ret$0);
+    } else {
+      tmp = Companion_getInstance_7().oq();
+    }
+    return tmp;
+  }
+  setMetadataFor(Cached, 'Cached', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  function castTo() {
+    return isInterface(this, Castable) ? this : THROW_CCE();
+  }
+  setMetadataFor(Castable, 'Castable', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_1, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(_no_name_provided__qut3iv, undefined, classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(_no_name_provided__qut3iv_0, undefined, classMeta, undefined, [Sequence], undefined, undefined, []);
+  function asIterable_1() {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.Iterable' call
+    tmp$ret$0 = new _no_name_provided__qut3iv(this);
+    return tmp$ret$0;
+  }
+  function asSequence_0() {
+    var tmp$ret$0;
+    // Inline function 'kotlin.sequences.Sequence' call
+    tmp$ret$0 = new _no_name_provided__qut3iv_0(this);
+    return tmp$ret$0;
+  }
+  setMetadataFor(Cursor, 'Cursor', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  function component1() {
+    return this.yq();
+  }
+  function component2() {
+    return this.b1();
+  }
+  setMetadataFor(Indexed, 'Indexed', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_2, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function compareTo(other) {
+    return this.yq() - other.yq() | 0;
+  }
+  setMetadataFor(IntIndexed, 'IntIndexed', interfaceMeta, undefined, [Indexed, Comparable], undefined, undefined, []);
+  setMetadataFor(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(dropLast$slambda, 'dropLast$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(insertAt$slambda, 'insertAt$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(sam$kotlin_Comparator$0_0, 'sam$kotlin_Comparator$0', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(merge$slambda, 'merge$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(Companion_3, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function compareTo_0(other) {
+    return this.yq().ch(other.yq()).rh();
+  }
+  setMetadataFor(LongIndexed, 'LongIndexed', interfaceMeta, undefined, [Indexed, Comparable], undefined, undefined, []);
+  setMetadataFor(Companion_4, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(NumberTypeTester, 'NumberTypeTester', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_5, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Optional, 'Optional', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Some, 'Some', classMeta, Optional, undefined, undefined, undefined, []);
+  setMetadataFor(None, 'None', objectMeta, Optional, undefined, undefined, undefined, []);
+  function getTag(name) {
+    var tmp = this.kt().a3(name);
+    return (tmp == null ? true : isObject(tmp)) ? tmp : THROW_CCE();
+  }
+  function containsTag(name) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.contains' call
+    var tmp0_contains = this.kt();
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.containsKey' call
+    tmp$ret$0 = (isInterface(tmp0_contains, Map) ? tmp0_contains : THROW_CCE()).u2(name);
+    tmp$ret$1 = tmp$ret$0;
+    return tmp$ret$1;
+  }
+  setMetadataFor(Taggable, 'Taggable', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_6, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractCursor$iterator$1, undefined, classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractCursor, 'AbstractCursor', classMeta, undefined, [Cursor], undefined, undefined, []);
+  setMetadataFor(CachedImpl, 'CachedImpl', classMeta, undefined, [Cached], undefined, undefined, []);
+  setMetadataFor(ConjunctionCursor, 'ConjunctionCursor', classMeta, AbstractCursor, undefined, undefined, undefined, []);
+  setMetadataFor(EmptyCursor, 'EmptyCursor', objectMeta, AbstractCursor, undefined, undefined, undefined, []);
+  setMetadataFor(IntIndexedImpl, 'IntIndexedImpl', classMeta, undefined, [IntIndexed], undefined, undefined, []);
+  setMetadataFor(LazyCursor, 'LazyCursor', classMeta, AbstractCursor, undefined, undefined, undefined, []);
+  setMetadataFor(LongIndexedImpl, 'LongIndexedImpl', classMeta, undefined, [LongIndexed], undefined, undefined, []);
+  setMetadataFor(MapperCursor, 'MapperCursor', classMeta, AbstractCursor, undefined, undefined, undefined, []);
+  setMetadataFor(NonLastCursor, 'NonLastCursor', classMeta, AbstractCursor, undefined, undefined, undefined, []);
+  setMetadataFor(SimpleLRUCache, 'SimpleLRUCache', classMeta, undefined, [Cache], undefined, undefined, []);
+  setMetadataFor(ValueCursor, 'ValueCursor', classMeta, AbstractCursor, undefined, undefined, undefined, []);
+  //endregion
+  function Companion() {
+    Companion_instance = this;
+  }
+  Companion.prototype.gq = function (capacity) {
+    return new SimpleLRUCache(capacity);
+  };
+  var Companion_instance;
+  function Companion_getInstance_1() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Cache() {
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+  }
+  Companion_0.prototype.kq = function (generator) {
+    return new CachedImpl(generator);
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_2() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function Cached() {
+  }
+  function Castable() {
+  }
+  function Companion_1() {
+    Companion_instance_1 = this;
+  }
+  Companion_1.prototype.of = function (iterator) {
+    return toCursor(iterator);
+  };
+  Companion_1.prototype.ofSequence = function (sequence) {
+    return cursor_0(sequence);
+  };
+  Companion_1.prototype.empty = function () {
+    return EmptyCursor_getInstance();
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_3() {
+    if (Companion_instance_1 == null)
+      new Companion_1();
+    return Companion_instance_1;
+  }
+  function _no_name_provided__qut3iv(this$0) {
+    this.rq_1 = this$0;
+  }
+  _no_name_provided__qut3iv.prototype.j = function () {
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.utils.Cursor.asIterable.<anonymous>' call
+    tmp$ret$0 = this.rq_1.iterator();
+    return tmp$ret$0;
+  };
+  function _no_name_provided__qut3iv_0(this$0) {
+    this.sq_1 = this$0;
+  }
+  _no_name_provided__qut3iv_0.prototype.j = function () {
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.utils.Cursor.asSequence.<anonymous>' call
+    tmp$ret$0 = this.sq_1.iterator();
+    return tmp$ret$0;
+  };
+  function Cursor() {
+  }
+  function cursor(_this__u8e3s4) {
+    return toCursor(_this__u8e3s4.j());
+  }
+  function cursor_0(_this__u8e3s4) {
+    return toCursor(_this__u8e3s4.j());
+  }
+  function cursor_1(_this__u8e3s4) {
+    return toCursor(arrayIterator(_this__u8e3s4));
+  }
+  function plus(_this__u8e3s4, other) {
+    return other.vq() ? new ConjunctionCursor(_this__u8e3s4, forceCast(other)) : _this__u8e3s4.vq() ? _this__u8e3s4 : EmptyCursor_getInstance();
+  }
+  function toCursor(_this__u8e3s4) {
+    return Companion_getInstance_8().xq(_this__u8e3s4);
+  }
+  function Indexed() {
+  }
+  function Companion_2() {
+    Companion_instance_2 = this;
+  }
+  Companion_2.prototype.zq = function (index, value) {
+    return new IntIndexedImpl(index, value);
+  };
+  var Companion_instance_2;
+  function Companion_getInstance_4() {
+    if (Companion_instance_2 == null)
+      new Companion_2();
+    return Companion_instance_2;
+  }
+  function IntIndexed() {
+  }
+  function dropLast(_this__u8e3s4) {
+    return sequence(dropLast$slambda_0(_this__u8e3s4, null));
+  }
+  function itemWiseHashCode(iterable) {
+    var hash = 13;
+    var i = iterable.j();
+    while (i.m()) {
+      var tmp = imul(31, hash);
+      var tmp0_safe_receiver = i.p();
+      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 insertAt(_this__u8e3s4, index, item, items) {
+    return sequence(insertAt$slambda_0(_this__u8e3s4, index, item, items, null));
+  }
+  function itemWiseHashCode_0(sequence) {
+    return itemWiseHashCode(asIterable(sequence));
+  }
+  function itemWiseEquals(sequence1, sequence2, comparator) {
+    return itemWiseEquals_0(asIterable(sequence1), asIterable(sequence2), comparator);
+  }
+  function cached(_this__u8e3s4) {
+    return cursor_0(_this__u8e3s4).asSequence();
+  }
+  function buffered(_this__u8e3s4) {
+    return asSequence(toList(_this__u8e3s4));
+  }
+  function itemWiseEquals_0(iterable1, iterable2, comparator) {
+    var i = iterable1.j();
+    var j = iterable2.j();
+    while (i.m() ? j.m() : false) {
+      var a = i.p();
+      var b = j.p();
+      if (!comparator(a, b)) {
+        return false;
+      }
+    }
+    return i.m() === j.m();
+  }
+  function itemWiseEquals_1(iterable1, iterable2) {
+    return itemWiseEquals_0(iterable1, iterable2, itemWiseEquals$lambda);
+  }
+  function itemWiseHashCode_1(items) {
+    return itemWiseHashCode(asIterable_0(items));
+  }
+  function mergeSequences(iterables, comparator) {
+    var tmp = new sam$kotlin_Comparator$0(comparator);
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(iterables, 10));
+    var tmp0_iterator = iterables.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.utils.mergeSequences.<anonymous>' call
+      tmp$ret$0 = asIterable(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return merge(tmp, tmp$ret$2);
+  }
+  function merge(comparator, iterables) {
+    return sequence(merge$slambda_0(iterables, comparator, null));
+  }
+  function indexed(_this__u8e3s4) {
+    var tmp = asSequence(new IntRange(0, IntCompanionObject_getInstance().MAX_VALUE));
+    return zip(_this__u8e3s4, tmp, indexed$lambda);
+  }
+  function sam$kotlin_Comparator$0(function_0) {
+    this.br_1 = function_0;
+  }
+  sam$kotlin_Comparator$0.prototype.cg = function (a, b) {
+    return this.br_1(a, b);
+  };
+  sam$kotlin_Comparator$0.prototype.compare = function (a, b) {
+    return this.cg(a, b);
+  };
+  function dropLast$slambda($this_dropLast, resultContinuation) {
+    this.kr_1 = $this_dropLast;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  dropLast$slambda.prototype.pr = function ($this$sequence, $cont) {
+    var tmp = this.qr($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  dropLast$slambda.prototype.wi = function (p1, $cont) {
+    return this.pr(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  dropLast$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 5;
+            this.mr_1 = this.kr_1.j();
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.mr_1.m()) {
+              this.ci_1 = 4;
+              continue $sm;
+            }
+
+            this.nr_1 = this.mr_1.p();
+            if (this.mr_1.m()) {
+              this.ci_1 = 2;
+              suspendResult = this.lr_1.z4(this.nr_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.ci_1 = 3;
+              continue $sm;
+            }
+
+            break;
+          case 2:
+            this.ci_1 = 3;
+            continue $sm;
+          case 3:
+            this.ci_1 = 1;
+            continue $sm;
+          case 4:
+            return Unit_getInstance();
+          case 5:
+            throw this.fi_1;
+        }
+      } catch ($p) {
+        if (this.di_1 === 5) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  dropLast$slambda.prototype.qr = function ($this$sequence, completion) {
+    var i = new dropLast$slambda(this.kr_1, completion);
+    i.lr_1 = $this$sequence;
+    return i;
+  };
+  function dropLast$slambda_0($this_dropLast, resultContinuation) {
+    var i = new dropLast$slambda($this_dropLast, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.pr($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function insertAt$slambda($this_insertAt, $index, $item, $items, resultContinuation) {
+    this.zr_1 = $this_insertAt;
+    this.as_1 = $index;
+    this.bs_1 = $item;
+    this.cs_1 = $items;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  insertAt$slambda.prototype.pr = function ($this$sequence, $cont) {
+    var tmp = this.qr($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  insertAt$slambda.prototype.wi = function (p1, $cont) {
+    return this.pr(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  insertAt$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 7;
+            this.es_1 = asIterable(withIndex(this.zr_1)).j();
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.es_1.m()) {
+              this.ci_1 = 6;
+              continue $sm;
+            }
+
+            this.fs_1 = this.es_1.p();
+            this.gs_1 = this.fs_1.n3();
+            this.hs_1 = this.fs_1.o3();
+            if (this.gs_1 === this.as_1) {
+              this.ci_1 = 2;
+              suspendResult = this.ds_1.z4(this.bs_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.ci_1 = 4;
+              continue $sm;
+            }
+
+            break;
+          case 2:
+            this.ci_1 = 3;
+            suspendResult = this.ds_1.b5(asIterable_0(this.cs_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 3:
+            this.ci_1 = 4;
+            continue $sm;
+          case 4:
+            this.ci_1 = 5;
+            suspendResult = this.ds_1.z4(this.hs_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 5:
+            this.ci_1 = 1;
+            continue $sm;
+          case 6:
+            return Unit_getInstance();
+          case 7:
+            throw this.fi_1;
+        }
+      } catch ($p) {
+        if (this.di_1 === 7) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  insertAt$slambda.prototype.qr = function ($this$sequence, completion) {
+    var i = new insertAt$slambda(this.zr_1, this.as_1, this.bs_1, this.cs_1, completion);
+    i.ds_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);
+    var l = function ($this$sequence, $cont) {
+      return i.pr($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function itemWiseEquals$lambda(a, b) {
+    return equals(a, b);
+  }
+  function sam$kotlin_Comparator$0_0(function_0) {
+    this.is_1 = function_0;
+  }
+  sam$kotlin_Comparator$0_0.prototype.cg = function (a, b) {
+    return this.is_1(a, b);
+  };
+  sam$kotlin_Comparator$0_0.prototype.compare = function (a, b) {
+    return this.cg(a, b);
+  };
+  function merge$slambda$lambda(it) {
+    return cursor(it);
+  }
+  function merge$slambda$lambda_0(it) {
+    return it.wq();
+  }
+  function merge$slambda$lambda_1(it) {
+    return ensureNotNull(it.uq());
+  }
+  function merge$slambda$lambda_2($comparator) {
+    return function (a, b) {
+      return $comparator.compare(a.b1(), b.b1());
+    };
+  }
+  function merge$slambda($iterables, $comparator, resultContinuation) {
+    this.rs_1 = $iterables;
+    this.ss_1 = $comparator;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  merge$slambda.prototype.pr = function ($this$sequence, $cont) {
+    var tmp = this.qr($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  merge$slambda.prototype.wi = function (p1, $cont) {
+    return this.pr(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  merge$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 3;
+            var tmp_0 = this;
+            var tmp_1 = asSequence(this.rs_1);
+            var tmp_2 = map(tmp_1, merge$slambda$lambda);
+            tmp_0.us_1 = toMutableList(filterNot(tmp_2, merge$slambda$lambda_0));
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!!this.us_1.d()) {
+              this.ci_1 = 4;
+              continue $sm;
+            }
+
+            var tmp_3 = this;
+            var tmp_4 = asSequence(this.us_1);
+            var tmp_5 = indexed(map(tmp_4, merge$slambda$lambda_1));
+            var tmp_6 = merge$slambda$lambda_2(this.ss_1);
+            tmp_3.vs_1 = ensureNotNull(minWithOrNull(tmp_5, new sam$kotlin_Comparator$0_0(tmp_6)));
+            this.ws_1 = this.vs_1.n3();
+            this.xs_1 = this.vs_1.o3();
+            this.ci_1 = 2;
+            suspendResult = this.ts_1.z4(this.xs_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            var tmp0_let = this.us_1.n(this.ws_1).tq();
+            if (tmp0_let.wq()) {
+              this.us_1.t4(this.ws_1);
+            } else {
+              this.us_1.s4(this.ws_1, tmp0_let);
+            }
+
+            ;
+            this.ci_1 = 1;
+            continue $sm;
+          case 3:
+            throw this.fi_1;
+          case 4:
+            return Unit_getInstance();
+        }
+      } catch ($p) {
+        if (this.di_1 === 3) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  merge$slambda.prototype.qr = function ($this$sequence, completion) {
+    var i = new merge$slambda(this.rs_1, this.ss_1, completion);
+    i.ts_1 = $this$sequence;
+    return i;
+  };
+  function merge$slambda_0($iterables, $comparator, resultContinuation) {
+    var i = new merge$slambda($iterables, $comparator, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.pr($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function indexed$lambda(it, i) {
+    return Companion_getInstance_4().zq(i, it);
+  }
+  function Companion_3() {
+    Companion_instance_3 = this;
+  }
+  Companion_3.prototype.ys = function (index, value) {
+    return new LongIndexedImpl(index, value);
+  };
+  var Companion_instance_3;
+  function Companion_getInstance_5() {
+    if (Companion_instance_3 == null)
+      new Companion_3();
+    return Companion_instance_3;
+  }
+  function LongIndexed() {
+  }
+  function Companion_4() {
+    Companion_instance_4 = this;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.text.toRegex' call
+    tmp$ret$0 = Regex_init_$Create$('[0-9]+');
+    tmp.at_1 = tmp$ret$0;
+  }
+  var Companion_instance_4;
+  function Companion_getInstance_6() {
+    if (Companion_instance_4 == null)
+      new Companion_4();
+    return Companion_instance_4;
+  }
+  function _get_stringRepresentation__xuqjt9(_this__u8e3s4, $this) {
+    return $this.bt_1.iq(_this__u8e3s4, NumberTypeTester$_get_stringRepresentation_$lambda_7w0qtg(_this__u8e3s4));
+  }
+  function NumberTypeTester$_get_stringRepresentation_$lambda_7w0qtg($this_stringRepresentation) {
+    return function () {
+      return toString($this_stringRepresentation);
+    };
+  }
+  function NumberTypeTester() {
+    Companion_getInstance_6();
+    this.bt_1 = Companion_getInstance_1().gq(8);
+  }
+  NumberTypeTester.prototype.ct = function (_this__u8e3s4) {
+    return Companion_getInstance_6().at_1.ef(_get_stringRepresentation__xuqjt9(_this__u8e3s4, this));
+  };
+  NumberTypeTester.prototype.dt = function (_this__u8e3s4) {
+    return Companion_getInstance().parse(_get_stringRepresentation__xuqjt9(_this__u8e3s4, this));
+  };
+  NumberTypeTester.prototype.et = function (_this__u8e3s4) {
+    var tmp = Companion_getInstance_0();
+    var tmp_0 = _get_stringRepresentation__xuqjt9(_this__u8e3s4, this);
+    return tmp.sj(tmp_0, null, 2, null);
+  };
+  function Companion_5() {
+    Companion_instance_5 = this;
+  }
+  Companion_5.prototype.ft = function (value) {
+    return new Some(value);
+  };
+  Companion_5.prototype.pq = function (value) {
+    var tmp;
+    if (value == null) {
+      tmp = this.oq();
+    } else {
+      tmp = this.ft(value);
+    }
+    return tmp;
+  };
+  Companion_5.prototype.oq = function () {
+    return None_getInstance();
+  };
+  var Companion_instance_5;
+  function Companion_getInstance_7() {
+    if (Companion_instance_5 == null)
+      new Companion_5();
+    return Companion_instance_5;
+  }
+  function Some(value) {
+    Optional.call(this);
+    this.jq_1 = value;
+  }
+  Some.prototype.b1 = function () {
+    return this.jq_1;
+  };
+  Some.prototype.gt = function () {
+    return true;
+  };
+  Some.prototype.ht = function (function_0) {
+    return new Some(function_0(this.jq_1));
+  };
+  Some.prototype.toString = function () {
+    return 'Some(' + this.jq_1 + ')';
+  };
+  Some.prototype.hashCode = function () {
+    return this.jq_1 == null ? 0 : hashCode(this.jq_1);
+  };
+  Some.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Some))
+      return false;
+    var tmp0_other_with_cast = other instanceof Some ? other : THROW_CCE();
+    if (!equals(this.jq_1, tmp0_other_with_cast.jq_1))
+      return false;
+    return true;
+  };
+  function None() {
+    None_instance = this;
+    Optional.call(this);
+  }
+  None.prototype.b1 = function () {
+    return null;
+  };
+  None.prototype.gt = function () {
+    return false;
+  };
+  None.prototype.jt = function (function_0) {
+    return None_getInstance();
+  };
+  None.prototype.ht = function (function_0) {
+    return this.jt(function_0);
+  };
+  None.prototype.toString = function () {
+    return 'None';
+  };
+  var None_instance;
+  function None_getInstance() {
+    if (None_instance == null)
+      new None();
+    return None_instance;
+  }
+  function Optional() {
+    Companion_getInstance_7();
+  }
+  Optional.prototype.it = function () {
+    return !this.gt();
+  };
+  function Taggable() {
+  }
+  function setTags(_this__u8e3s4, tags) {
+    var tmp = _this__u8e3s4.resetTags(tags);
+    return isInterface(tmp, Taggable) ? tmp : THROW_CCE();
+  }
+  function setTag(_this__u8e3s4, key, value) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    var tmp0_also = toMutableMap(_this__u8e3s4.kt());
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.utils.setTag.<anonymous>' call
+    // Inline function 'kotlin.collections.set' call
+    tmp0_also.w3(key, value);
+    tmp$ret$0 = tmp0_also;
+    return setTags(_this__u8e3s4, tmp$ret$0);
+  }
+  function Companion_6() {
+    Companion_instance_6 = this;
+  }
+  Companion_6.prototype.xq = function (source) {
+    var tmp;
+    if (source.m()) {
+      tmp = new LazyCursor(source);
+    } else {
+      tmp = EmptyCursor_getInstance();
+    }
+    return tmp;
+  };
+  var Companion_instance_6;
+  function Companion_getInstance_8() {
+    if (Companion_instance_6 == null)
+      new Companion_6();
+    return Companion_instance_6;
+  }
+  function AbstractCursor$iterator$1(this$0) {
+    this.lt_1 = this$0;
+  }
+  AbstractCursor$iterator$1.prototype.m = function () {
+    return !this.lt_1.wq();
+  };
+  AbstractCursor$iterator$1.prototype.p = function () {
+    var result = this.lt_1.uq();
+    this.lt_1 = this.lt_1.tq();
+    return ensureNotNull(result);
+  };
+  function AbstractCursor() {
+    Companion_getInstance_8();
+  }
+  AbstractCursor.prototype.toString = function () {
+    return this.wq() ? '[]' : !this.vq() ? '[' + this.uq() + ']' : '[' + this.uq() + ', ...]';
+  };
+  AbstractCursor.prototype.j = function () {
+    return new AbstractCursor$iterator$1(this);
+  };
+  AbstractCursor.prototype.iterator = function () {
+    return this.j();
+  };
+  AbstractCursor.prototype.mt = function () {
+    return false;
+  };
+  AbstractCursor.prototype.ht = function (mapper) {
+    return new MapperCursor(this, mapper);
+  };
+  AbstractCursor.prototype.map = function (mapper) {
+    return this.ht(mapper);
+  };
+  function CachedImpl(generator) {
+    this.nt_1 = generator;
+    this.ot_1 = Companion_getInstance_7().oq();
+  }
+  CachedImpl.prototype.lq = function () {
+    return this.ot_1.gt();
+  };
+  CachedImpl.prototype.pt = function () {
+    return this.ot_1.it();
+  };
+  CachedImpl.prototype.b1 = function () {
+    this.qt();
+    return ensureNotNull(this.ot_1.b1());
+  };
+  CachedImpl.prototype.qt = function () {
+    if (this.pt()) {
+      this.ot_1 = Companion_getInstance_7().ft(this.nt_1());
+    }
+  };
+  CachedImpl.prototype.mq = function () {
+    this.ot_1 = Companion_getInstance_7().oq();
+  };
+  CachedImpl.prototype.toString = function () {
+    return 'CachedImpl(generator=' + this.nt_1 + ')';
+  };
+  CachedImpl.prototype.hashCode = function () {
+    return hashCode(this.nt_1);
+  };
+  CachedImpl.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CachedImpl))
+      return false;
+    var tmp0_other_with_cast = other instanceof CachedImpl ? other : THROW_CCE();
+    if (!equals(this.nt_1, tmp0_other_with_cast.nt_1))
+      return false;
+    return true;
+  };
+  function ConjunctionCursor$next$delegate$lambda(this$0) {
+    return function () {
+      return this$0.rt_1.vq() ? new ConjunctionCursor(this$0.rt_1.tq(), this$0.st_1) : this$0.st_1.mt() ? this$0.st_1.tq() : this$0.st_1;
+    };
+  }
+  function ConjunctionCursor(first, second) {
+    AbstractCursor.call(this);
+    this.rt_1 = first;
+    this.st_1 = second;
+    var tmp = this;
+    tmp.tt_1 = lazy(ConjunctionCursor$next$delegate$lambda(this));
+  }
+  ConjunctionCursor.prototype.wq = function () {
+    return this.rt_1.wq() ? this.st_1.wq() : false;
+  };
+  ConjunctionCursor.prototype.tq = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = next$factory();
+    tmp$ret$0 = this.tt_1.b1();
+    return tmp$ret$0;
+  };
+  ConjunctionCursor.prototype.uq = function () {
+    return this.rt_1.vq() ? this.rt_1.uq() : this.st_1.uq();
+  };
+  ConjunctionCursor.prototype.vq = function () {
+    return this.rt_1.vq() ? true : this.st_1.vq();
+  };
+  ConjunctionCursor.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null ? true : !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (other instanceof ConjunctionCursor)
+      other;
+    else
+      THROW_CCE();
+    if (!equals(this.rt_1, other.rt_1))
+      return false;
+    if (!equals(this.st_1, other.st_1))
+      return false;
+    return true;
+  };
+  ConjunctionCursor.prototype.hashCode = function () {
+    var result = hashCode(this.rt_1);
+    result = imul(31, result) + hashCode(this.st_1) | 0;
+    return result;
+  };
+  function next$factory() {
+    return getPropertyCallableRef('next', 1, KProperty1, function (receiver) {
+      return receiver.tq();
+    }, null);
+  }
+  function EmptyCursor() {
+    EmptyCursor_instance = this;
+    AbstractCursor.call(this);
+  }
+  EmptyCursor.prototype.tq = function () {
+    throw NoSuchElementException_init_$Create$();
+  };
+  EmptyCursor.prototype.uq = function () {
+    return null;
+  };
+  EmptyCursor.prototype.vq = function () {
+    return false;
+  };
+  EmptyCursor.prototype.wq = function () {
+    return true;
+  };
+  EmptyCursor.prototype.toString = function () {
+    return AbstractCursor.prototype.toString.call(this);
+  };
+  EmptyCursor.prototype.jt = function (mapper) {
+    return this;
+  };
+  EmptyCursor.prototype.map = function (mapper) {
+    return this.jt(mapper);
+  };
+  EmptyCursor.prototype.ht = function (mapper) {
+    return this.jt(mapper);
+  };
+  var EmptyCursor_instance;
+  function EmptyCursor_getInstance() {
+    if (EmptyCursor_instance == null)
+      new EmptyCursor();
+    return EmptyCursor_instance;
+  }
+  function IntIndexedImpl(index, value) {
+    this.ut_1 = index;
+    this.vt_1 = value;
+  }
+  IntIndexedImpl.prototype.yq = function () {
+    return this.ut_1;
+  };
+  IntIndexedImpl.prototype.b1 = function () {
+    return this.vt_1;
+  };
+  IntIndexedImpl.prototype.n3 = function () {
+    return this.ut_1;
+  };
+  IntIndexedImpl.prototype.o3 = function () {
+    return this.vt_1;
+  };
+  IntIndexedImpl.prototype.toString = function () {
+    return 'IntIndexedImpl(index=' + this.ut_1 + ', value=' + this.vt_1 + ')';
+  };
+  IntIndexedImpl.prototype.hashCode = function () {
+    var result = this.ut_1;
+    result = imul(result, 31) + (this.vt_1 == null ? 0 : hashCode(this.vt_1)) | 0;
+    return result;
+  };
+  IntIndexedImpl.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof IntIndexedImpl))
+      return false;
+    var tmp0_other_with_cast = other instanceof IntIndexedImpl ? other : THROW_CCE();
+    if (!(this.ut_1 === tmp0_other_with_cast.ut_1))
+      return false;
+    if (!equals(this.vt_1, tmp0_other_with_cast.vt_1))
+      return false;
+    return true;
+  };
+  IntIndexedImpl.prototype.aa = function (other) {
+    return this.ar((!(other == null) ? isInterface(other, IntIndexed) : false) ? other : THROW_CCE());
+  };
+  function _get_wrapped__s2ip8($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = wrapped$factory();
+    tmp$ret$0 = $this.xt_1.b1();
+    return tmp$ret$0;
+  }
+  function LazyCursor$wrapped$delegate$lambda(this$0) {
+    return function () {
+      return new NonLastCursor(this$0.wt_1);
+    };
+  }
+  function LazyCursor(delegate) {
+    AbstractCursor.call(this);
+    this.wt_1 = delegate;
+    var tmp = this;
+    tmp.xt_1 = lazy(LazyCursor$wrapped$delegate$lambda(this));
+  }
+  LazyCursor.prototype.mt = function () {
+    return true;
+  };
+  LazyCursor.prototype.tq = function () {
+    return _get_wrapped__s2ip8(this).tq();
+  };
+  LazyCursor.prototype.uq = function () {
+    return _get_wrapped__s2ip8(this).uq();
+  };
+  LazyCursor.prototype.vq = function () {
+    return true;
+  };
+  LazyCursor.prototype.wq = function () {
+    return false;
+  };
+  LazyCursor.prototype.toString = function () {
+    return AbstractCursor.prototype.toString.call(this);
+  };
+  LazyCursor.prototype.j = function () {
+    return _get_wrapped__s2ip8(this).j();
+  };
+  LazyCursor.prototype.iterator = function () {
+    return this.j();
+  };
+  LazyCursor.prototype.hashCode = function () {
+    return hashCode(this.wt_1);
+  };
+  LazyCursor.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof LazyCursor))
+      return false;
+    var tmp0_other_with_cast = other instanceof LazyCursor ? other : THROW_CCE();
+    if (!equals(this.wt_1, tmp0_other_with_cast.wt_1))
+      return false;
+    return true;
+  };
+  function wrapped$factory() {
+    return getPropertyCallableRef('wrapped', 1, KProperty1, function (receiver) {
+      return _get_wrapped__s2ip8(receiver);
+    }, null);
+  }
+  function LongIndexedImpl(index, value) {
+    this.yt_1 = index;
+    this.zt_1 = value;
+  }
+  LongIndexedImpl.prototype.yq = function () {
+    return this.yt_1;
+  };
+  LongIndexedImpl.prototype.b1 = function () {
+    return this.zt_1;
+  };
+  LongIndexedImpl.prototype.zs = function (other) {
+    return this.yt_1.ch(other.yq()).rh();
+  };
+  LongIndexedImpl.prototype.aa = function (other) {
+    return this.zs((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  LongIndexedImpl.prototype.toString = function () {
+    return 'LongIndexedImpl(index=' + toString(this.yt_1) + ', value=' + this.zt_1 + ')';
+  };
+  LongIndexedImpl.prototype.hashCode = function () {
+    var result = this.yt_1.hashCode();
+    result = imul(result, 31) + (this.zt_1 == null ? 0 : hashCode(this.zt_1)) | 0;
+    return result;
+  };
+  LongIndexedImpl.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof LongIndexedImpl))
+      return false;
+    var tmp0_other_with_cast = other instanceof LongIndexedImpl ? other : THROW_CCE();
+    if (!this.yt_1.equals(tmp0_other_with_cast.yt_1))
+      return false;
+    if (!equals(this.zt_1, tmp0_other_with_cast.zt_1))
+      return false;
+    return true;
+  };
+  function MapperCursor$current$delegate$lambda(this$0) {
+    return function () {
+      return this$0.bu_1(ensureNotNull(this$0.au_1.uq()));
+    };
+  }
+  function MapperCursor(wrapped, mapper) {
+    AbstractCursor.call(this);
+    this.au_1 = wrapped;
+    this.bu_1 = mapper;
+    var tmp = this;
+    tmp.cu_1 = lazy(MapperCursor$current$delegate$lambda(this));
+  }
+  MapperCursor.prototype.tq = function () {
+    return this.au_1.tq().ht(this.bu_1);
+  };
+  MapperCursor.prototype.uq = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = current$factory();
+    tmp$ret$0 = this.cu_1.b1();
+    return tmp$ret$0;
+  };
+  MapperCursor.prototype.vq = function () {
+    return true;
+  };
+  MapperCursor.prototype.wq = function () {
+    return false;
+  };
+  MapperCursor.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null ? true : !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (other instanceof MapperCursor)
+      other;
+    else
+      THROW_CCE();
+    if (!equals(this.au_1, other.au_1))
+      return false;
+    if (!equals(this.bu_1, other.bu_1))
+      return false;
+    return true;
+  };
+  MapperCursor.prototype.hashCode = function () {
+    var result = hashCode(this.au_1);
+    result = imul(31, result) + hashCode(this.bu_1) | 0;
+    return result;
+  };
+  MapperCursor.prototype.du = function (mapper) {
+    return new ValueCursor(mapper(this.uq()), this.tq().ht(mapper));
+  };
+  MapperCursor.prototype.map = function (mapper) {
+    return this.du(mapper);
+  };
+  MapperCursor.prototype.ht = function (mapper) {
+    return this.du(mapper);
+  };
+  function current$factory() {
+    return getPropertyCallableRef('current', 1, KProperty1, function (receiver) {
+      return receiver.uq();
+    }, null);
+  }
+  function NonLastCursor$next$delegate$lambda($source, this$0) {
+    return function () {
+      var tmp$ret$0;
+      // Inline function 'kotlin.also' call
+      var tmp0_also = Companion_getInstance_8().xq($source);
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'it.unibo.tuprolog.utils.impl.NonLastCursor.next$delegate.<anonymous>.<anonymous>' call
+      this$0.eu_1 = null;
+      tmp$ret$0 = tmp0_also;
+      return tmp$ret$0;
+    };
+  }
+  function NonLastCursor(source) {
+    AbstractCursor.call(this);
+    this.eu_1 = source;
+    var tmp = this;
+    tmp.fu_1 = lazy(NonLastCursor$next$delegate$lambda(source, this));
+    this.gu_1 = source.p();
+  }
+  NonLastCursor.prototype.tq = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = next$factory_0();
+    tmp$ret$0 = this.fu_1.b1();
+    return tmp$ret$0;
+  };
+  NonLastCursor.prototype.uq = function () {
+    return this.gu_1;
+  };
+  NonLastCursor.prototype.vq = function () {
+    return true;
+  };
+  NonLastCursor.prototype.wq = function () {
+    return false;
+  };
+  NonLastCursor.prototype.toString = function () {
+    return AbstractCursor.prototype.toString.call(this);
+  };
+  function next$factory_0() {
+    return getPropertyCallableRef('next', 1, KProperty1, function (receiver) {
+      return receiver.tq();
+    }, null);
+  }
+  function removeLeastRecent($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.iterator' call
+    var tmp0_iterator = $this.iu_1;
+    tmp$ret$0 = tmp0_iterator.z().j();
+    var entry = tmp$ret$0.p();
+    $this.iu_1.x3(entry.a1());
+    var tmp = Companion_getInstance_7();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.toPair' call
+    tmp$ret$1 = new Pair(entry.a1(), entry.b1());
+    return tmp.ft(tmp$ret$1);
+  }
+  function removeLeastRecentIfNecessary($this) {
+    var tmp;
+    if ($this.iu_1.o() >= $this.hu_1) {
+      tmp = removeLeastRecent($this);
+    } else {
+      return Companion_getInstance_7().oq();
+    }
+    return tmp;
+  }
+  function SimpleLRUCache$toSequence$lambda(it) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.toPair' call
+    tmp$ret$0 = new Pair(it.a1(), it.b1());
+    return tmp$ret$0;
+  }
+  function SimpleLRUCache$toString$lambda(it) {
+    return '' + it.g4_1 + ' = ' + it.h4_1;
+  }
+  function SimpleLRUCache(capacity) {
+    this.hu_1 = capacity;
+    // Inline function 'kotlin.require' call
+    var tmp0_require = this.hu_1 > 0;
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp0_require) {
+      var tmp$ret$0;
+      // Inline function 'kotlin.require.<anonymous>' call
+      tmp$ret$0 = 'Failed requirement.';
+      var message = tmp$ret$0;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    this.iu_1 = LinkedHashMap_init_$Create$();
+  }
+  SimpleLRUCache.prototype.hq = function (key, value) {
+    var evicted = removeLeastRecentIfNecessary(this);
+    // Inline function 'kotlin.collections.set' call
+    var tmp0_set = this.iu_1;
+    tmp0_set.w3(key, value);
+    return evicted;
+  };
+  SimpleLRUCache.prototype.a3 = function (key) {
+    var tmp;
+    if (this.iu_1.u2(key)) {
+      tmp = Companion_getInstance_7().pq(this.iu_1.a3(key));
+    } else {
+      tmp = Companion_getInstance_7().oq();
+    }
+    return tmp;
+  };
+  SimpleLRUCache.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null ? true : !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (other instanceof SimpleLRUCache)
+      other;
+    else
+      THROW_CCE();
+    if (!(this.hu_1 === other.hu_1))
+      return false;
+    if (!this.iu_1.equals(other.iu_1))
+      return false;
+    return true;
+  };
+  SimpleLRUCache.prototype.hashCode = function () {
+    var result = this.hu_1;
+    result = imul(31, result) + this.iu_1.hashCode() | 0;
+    return result;
+  };
+  SimpleLRUCache.prototype.ju = function () {
+    var tmp = asSequence(this.iu_1.z());
+    return buffered(map(tmp, SimpleLRUCache$toSequence$lambda));
+  };
+  SimpleLRUCache.prototype.toString = function () {
+    var tmp = this.ju();
+    var tmp_0 = map(tmp, SimpleLRUCache$toString$lambda);
+    return 'SimpleLRUCache(' + joinToString$default(tmp_0, ', ', null, null, 0, null, null, 62, null) + ')';
+  };
+  function ValueCursor(current, next) {
+    AbstractCursor.call(this);
+    this.ku_1 = current;
+    this.lu_1 = next;
+  }
+  ValueCursor.prototype.uq = function () {
+    return this.ku_1;
+  };
+  ValueCursor.prototype.tq = function () {
+    return this.lu_1;
+  };
+  ValueCursor.prototype.vq = function () {
+    return true;
+  };
+  ValueCursor.prototype.wq = function () {
+    return false;
+  };
+  function dequeOf(items) {
+    return toMutableList(items);
+  }
+  function dequeOf_0(items) {
+    return mutableListOf(items.slice());
+  }
+  function dequeOf_1(items) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.also' call
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    tmp$ret$0 = ArrayList_init_$Create$_0();
+    var tmp0_also = tmp$ret$0;
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.utils.dequeOf.<anonymous>' call
+    addAll(tmp0_also, items);
+    tmp$ret$1 = tmp0_also;
+    return tmp$ret$1;
+  }
+  function takeFirst(_this__u8e3s4) {
+    if (_this__u8e3s4.d())
+      return null;
+    var first = _this__u8e3s4.n(0);
+    _this__u8e3s4.t4(0);
+    return first;
+  }
+  function addFirst(_this__u8e3s4, item) {
+    _this__u8e3s4.ua(0, item);
+  }
+  function addFirst_0(_this__u8e3s4, items) {
+    var i = _this__u8e3s4.bb();
+    var tmp0_iterator = items.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      i.va(item);
+    }
+  }
+  function forceCast(_this__u8e3s4) {
+    var it = _this__u8e3s4;
+    return it;
+  }
+  //region block: post-declaration
+  AbstractCursor.prototype.asIterable = asIterable_1;
+  AbstractCursor.prototype.asSequence = asSequence_0;
+  CachedImpl.prototype.nq = ifValid;
+  ConjunctionCursor.prototype.asIterable = asIterable_1;
+  ConjunctionCursor.prototype.asSequence = asSequence_0;
+  EmptyCursor.prototype.asIterable = asIterable_1;
+  EmptyCursor.prototype.asSequence = asSequence_0;
+  IntIndexedImpl.prototype.ar = compareTo;
+  LazyCursor.prototype.asIterable = asIterable_1;
+  LazyCursor.prototype.asSequence = asSequence_0;
+  MapperCursor.prototype.asIterable = asIterable_1;
+  MapperCursor.prototype.asSequence = asSequence_0;
+  NonLastCursor.prototype.asIterable = asIterable_1;
+  NonLastCursor.prototype.asSequence = asSequence_0;
+  SimpleLRUCache.prototype.iq = getOrSet;
+  ValueCursor.prototype.asIterable = asIterable_1;
+  ValueCursor.prototype.asSequence = asSequence_0;
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_getInstance_1;
+  _.$_$.b = Companion_getInstance_2;
+  _.$_$.c = Companion_getInstance_3;
+  _.$_$.d = Companion_getInstance_5;
+  _.$_$.e = Companion_getInstance_7;
+  _.$_$.f = castTo;
+  _.$_$.g = Castable;
+  _.$_$.h = compareTo_0;
+  _.$_$.i = LongIndexed;
+  _.$_$.j = NumberTypeTester;
+  _.$_$.k = Some;
+  _.$_$.l = containsTag;
+  _.$_$.m = getTag;
+  _.$_$.n = Taggable;
+  _.$_$.o = addFirst_0;
+  _.$_$.p = addFirst;
+  _.$_$.q = buffered;
+  _.$_$.r = cached;
+  _.$_$.s = cursor;
+  _.$_$.t = cursor_0;
+  _.$_$.u = cursor_1;
+  _.$_$.v = dequeOf;
+  _.$_$.w = dequeOf_1;
+  _.$_$.x = dequeOf_0;
+  _.$_$.y = dropLast;
+  _.$_$.z = forceCast;
+  _.$_$.a1 = insertAt;
+  _.$_$.b1 = itemWiseEquals;
+  _.$_$.c1 = itemWiseEquals_1;
+  _.$_$.d1 = itemWiseHashCode;
+  _.$_$.e1 = itemWiseHashCode_1;
+  _.$_$.f1 = itemWiseHashCode_0;
+  _.$_$.g1 = mergeSequences;
+  _.$_$.h1 = plus;
+  _.$_$.i1 = setTags;
+  _.$_$.j1 = setTag;
+  _.$_$.k1 = takeFirst;
+  //endregion
+  return _;
+}(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'), require('./kt-math.js')));
+
+//# sourceMappingURL=2p-utils.js.map