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

package/2p-theory.js

@@ -0,0 +1,4902 @@
+(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_utils, kotlin_it_unibo_tuprolog_unify) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var asIterable = kotlin_kotlin.$_$.h8;
+  var any = kotlin_kotlin.$_$.g8;
+  var asSequence = kotlin_kotlin.$_$.g3;
+  var Unit_getInstance = kotlin_kotlin.$_$.r2;
+  var getKClassFromExpression = kotlin_kotlin.$_$.b;
+  var joinToString$default = kotlin_kotlin.$_$.e;
+  var classMeta = kotlin_kotlin.$_$.m6;
+  var setMetadataFor = kotlin_kotlin.$_$.j7;
+  var toList = kotlin_kotlin.$_$.p9;
+  var none = kotlin_kotlin.$_$.e9;
+  var emptyList = kotlin_kotlin.$_$.s3;
+  var asIterable_0 = kotlin_kotlin.$_$.b3;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.c1;
+  var itemWiseEquals = kotlin_it_unibo_tuprolog_utils.$_$.c1;
+  var getKClass = kotlin_kotlin.$_$.c;
+  var itemWiseHashCode = kotlin_it_unibo_tuprolog_utils.$_$.d1;
+  var itemWiseHashCode_0 = kotlin_it_unibo_tuprolog_utils.$_$.e1;
+  var objectMeta = kotlin_kotlin.$_$.i7;
+  var interfaceMeta = kotlin_kotlin.$_$.u6;
+  var first = kotlin_kotlin.$_$.x3;
+  var hashCode = kotlin_kotlin.$_$.t6;
+  var THROW_CCE = kotlin_kotlin.$_$.sb;
+  var equals = kotlin_kotlin.$_$.o6;
+  var toString = kotlin_kotlin.$_$.n7;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.p1;
+  var asReversed = kotlin_kotlin.$_$.d3;
+  var isInterface = kotlin_kotlin.$_$.y6;
+  var lazy = kotlin_kotlin.$_$.xb;
+  var KProperty1 = kotlin_kotlin.$_$.d8;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.r6;
+  var CoroutineImpl = kotlin_kotlin.$_$.c6;
+  var SequenceScope = kotlin_kotlin.$_$.e8;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.b6;
+  var sequence = kotlin_kotlin.$_$.j9;
+  var listOf = kotlin_kotlin.$_$.i4;
+  var mergeSequences = kotlin_it_unibo_tuprolog_utils.$_$.g1;
+  var sequenceOf = kotlin_kotlin.$_$.i9;
+  var flatten = kotlin_kotlin.$_$.v8;
+  var compareTo = kotlin_it_unibo_tuprolog_utils.$_$.h;
+  var LongIndexed = kotlin_it_unibo_tuprolog_utils.$_$.i;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_utils.$_$.d;
+  var copyToArray = kotlin_kotlin.$_$.p3;
+  var plus = kotlin_kotlin.$_$.b5;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.c1;
+  var minOrNull = kotlin_kotlin.$_$.m4;
+  var ensureNotNull = kotlin_kotlin.$_$.vb;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.f1;
+  var map = kotlin_kotlin.$_$.c9;
+  var sum = kotlin_kotlin.$_$.k9;
+  var Collection = kotlin_kotlin.$_$.t2;
+  var dequeOf = kotlin_it_unibo_tuprolog_utils.$_$.x;
+  var addFirst = kotlin_it_unibo_tuprolog_utils.$_$.p;
+  var filter = kotlin_kotlin.$_$.r8;
+  var emptySequence = kotlin_kotlin.$_$.n8;
+  var buffered = kotlin_it_unibo_tuprolog_utils.$_$.q;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j3;
+  var dequeOf_0 = kotlin_it_unibo_tuprolog_utils.$_$.v;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_utils.$_$.b;
+  var firstOrNull = kotlin_kotlin.$_$.s8;
+  var NotImplementedError = kotlin_kotlin.$_$.nb;
+  var take = kotlin_kotlin.$_$.m9;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.s1;
+  var Long = kotlin_kotlin.$_$.mb;
+  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.c2;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.b1;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.i1;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.d1;
+  var numberRangeToNumber = kotlin_kotlin.$_$.e7;
+  var plus_0 = kotlin_kotlin.$_$.g9;
+  var getTag = kotlin_it_unibo_tuprolog_utils.$_$.m;
+  var containsTag = kotlin_it_unibo_tuprolog_utils.$_$.l;
+  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var first_0 = kotlin_kotlin.$_$.y3;
+  var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_unify.$_$.a;
+  var filterNotNull = kotlin_kotlin.$_$.p8;
+  var Taggable = kotlin_it_unibo_tuprolog_utils.$_$.n;
+  var filterNot = kotlin_kotlin.$_$.q8;
+  var asSequence_0 = kotlin_kotlin.$_$.h3;
+  var toLong = kotlin_kotlin.$_$.l7;
+  var emptyMap = kotlin_kotlin.$_$.t3;
+  var toList_0 = kotlin_kotlin.$_$.n5;
+  var listOf_0 = kotlin_kotlin.$_$.h4;
+  var none_0 = kotlin_kotlin.$_$.v4;
+  var dequeOf_1 = kotlin_it_unibo_tuprolog_utils.$_$.w;
+  var Pair = kotlin_kotlin.$_$.qb;
+  var flatMap = kotlin_kotlin.$_$.u8;
+  var toMutableList = kotlin_kotlin.$_$.u5;
+  var toMutableList_0 = kotlin_kotlin.$_$.q9;
+  var addFirst_0 = kotlin_it_unibo_tuprolog_utils.$_$.o;
+  var addAll = kotlin_kotlin.$_$.y2;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(AbstractClauseCollection, 'AbstractClauseCollection', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractMutableReteClauseCollection, 'AbstractMutableReteClauseCollection', classMeta, AbstractClauseCollection, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractReteClauseCollection, 'AbstractReteClauseCollection', classMeta, AbstractClauseCollection, undefined, undefined, undefined, []);
+  setMetadataFor(Companion, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function get(clause) {
+    return this.getFifoOrdered(clause);
+  }
+  function add(clause) {
+    return this.addLast(clause);
+  }
+  function add_0(clause) {
+    return this.v1l(clause);
+  }
+  function retrieve(clause) {
+    return this.retrieveFirst(clause);
+  }
+  function retrieve_0(clause) {
+    return this.z1l(clause);
+  }
+  setMetadataFor(ClauseQueue, 'ClauseQueue', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_0, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(MutableClauseQueue, 'MutableClauseQueue', interfaceMeta, undefined, [ClauseQueue], undefined, undefined, []);
+  setMetadataFor(RetrieveResult, 'RetrieveResult', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Success, 'Success', classMeta, RetrieveResult, undefined, undefined, undefined, []);
+  setMetadataFor(Failure, 'Failure', classMeta, RetrieveResult, undefined, undefined, undefined, []);
+  setMetadataFor(MutableReteClauseQueue, 'MutableReteClauseQueue', classMeta, AbstractMutableReteClauseCollection, [MutableClauseQueue, AbstractMutableReteClauseCollection], undefined, undefined, []);
+  setMetadataFor(ReteClauseQueue, 'ReteClauseQueue', classMeta, AbstractReteClauseCollection, [ClauseQueue, AbstractReteClauseCollection], undefined, undefined, []);
+  setMetadataFor(AbstractReteNode$removeAllLazily$slambda, 'AbstractReteNode$removeAllLazily$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(AbstractReteNode, 'AbstractReteNode', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_1, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Utils$firstArguments$slambda, 'Utils$firstArguments$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(Utils, 'Utils', objectMeta, undefined, undefined, undefined, undefined, []);
+  function get_innerClause() {
+    return this.b1();
+  }
+  function plus_1(traversed) {
+    return Companion_getInstance_10().z1o(this.yq(), this.p1n(), plus(this.v1o(), traversed));
+  }
+  setMetadataFor(IndexedClause, 'IndexedClause', interfaceMeta, undefined, [LongIndexed], undefined, undefined, []);
+  setMetadataFor(IndexedClause$Companion$wrap$1, undefined, classMeta, undefined, [IndexedClause], undefined, undefined, []);
+  setMetadataFor(Companion_2, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(SituatedIndexedClause, 'SituatedIndexedClause', interfaceMeta, undefined, [IndexedClause], undefined, undefined, []);
+  setMetadataFor(SituatedIndexedClause$Companion$of$1, undefined, classMeta, undefined, [SituatedIndexedClause], undefined, undefined, []);
+  setMetadataFor(Companion_3, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractIndexingLeaf, 'AbstractIndexingLeaf', classMeta, AbstractReteNode, undefined, undefined, undefined, []);
+  setMetadataFor(AtomIndex, 'AtomIndex', classMeta, AbstractIndexingLeaf, undefined, undefined, undefined, []);
+  setMetadataFor(CompoundIndex, 'CompoundIndex', classMeta, AbstractReteNode, undefined, undefined, undefined, []);
+  setMetadataFor(DirectiveIndex$getCache$1$1, undefined, classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(DirectiveIndex, 'DirectiveIndex', classMeta, AbstractReteNode, undefined, undefined, undefined, []);
+  setMetadataFor(NumericIndex, 'NumericIndex', classMeta, AbstractIndexingLeaf, undefined, undefined, undefined, []);
+  setMetadataFor(VariableIndex, 'VariableIndex', classMeta, AbstractIndexingLeaf, undefined, undefined, undefined, []);
+  setMetadataFor(ArityNode, 'ArityNode', classMeta, AbstractReteNode, undefined, undefined, undefined, []);
+  setMetadataFor(FamilyArityReteNode, 'FamilyArityReteNode', classMeta, ArityNode, undefined, undefined, undefined, []);
+  setMetadataFor(FamilyArityIndexingNode, 'FamilyArityIndexingNode', classMeta, FamilyArityReteNode, undefined, undefined, undefined, []);
+  setMetadataFor(FunctorNode, 'FunctorNode', classMeta, AbstractReteNode, undefined, undefined, undefined, []);
+  setMetadataFor(FunctorIndexingNode, 'FunctorIndexingNode', classMeta, FunctorNode, undefined, undefined, undefined, []);
+  setMetadataFor(RootNode, 'RootNode', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(RuleNode, 'RuleNode', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(TopLevelFunctorReteNode, 'TopLevelFunctorReteNode', classMeta, FunctorNode, undefined, undefined, undefined, []);
+  setMetadataFor(ZeroArityReteNode, 'ZeroArityReteNode', classMeta, ArityNode, undefined, undefined, undefined, []);
+  function get_isMutable() {
+    return false;
+  }
+  function get_rules() {
+    var tmp = asSequence(this.t1l());
+    return asIterable(filterNotNull(map(tmp, Theory$_get_rules_$lambda_c39n1s)));
+  }
+  function get_directives() {
+    var tmp = asSequence(this.t1l());
+    return asIterable(filterNotNull(map(tmp, Theory$_get_directives_$lambda_zbsn17)));
+  }
+  function plus_2(clause) {
+    return this.assertZ(clause);
+  }
+  function assertAFact(struct) {
+    return this.assertA(Companion_getInstance_5().of(struct));
+  }
+  function assertZFact(struct) {
+    return this.assertZ(Companion_getInstance_5().of(struct));
+  }
+  function retractByHead(head) {
+    return this.retract(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  }
+  function retractAllByHead(head) {
+    return this.retractAll(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  }
+  setMetadataFor(Theory, 'Theory', interfaceMeta, undefined, [Taggable], undefined, undefined, []);
+  setMetadataFor(AbstractTheory, 'AbstractTheory', classMeta, undefined, [Theory], undefined, undefined, []);
+  setMetadataFor(Companion_4, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function get_isMutable_0() {
+    return true;
+  }
+  function toMutableTheory() {
+    return this;
+  }
+  function assertAFact_0(struct) {
+    return this.p1s(Companion_getInstance_5().of(struct));
+  }
+  function assertZFact_0(struct) {
+    return this.t1s(Companion_getInstance_5().of(struct));
+  }
+  function retractByHead_0(head) {
+    return this.e1t(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  }
+  function retractAllByHead_0(head) {
+    return this.c1m(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  }
+  setMetadataFor(MutableTheory, 'MutableTheory', interfaceMeta, undefined, [Theory], undefined, undefined, []);
+  setMetadataFor(RetractResult, 'RetractResult', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Success_0, 'Success', classMeta, RetractResult, undefined, undefined, undefined, []);
+  setMetadataFor(Failure_0, 'Failure', classMeta, RetractResult, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_5, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(TheoryUtils, 'TheoryUtils', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(_no_name_provided__qut3iv, undefined, classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractIndexedTheory, 'AbstractIndexedTheory', classMeta, AbstractTheory, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractListedTheory, 'AbstractListedTheory', classMeta, AbstractTheory, undefined, undefined, undefined, []);
+  setMetadataFor(IndexedTheory, 'IndexedTheory', classMeta, AbstractIndexedTheory, undefined, undefined, undefined, []);
+  setMetadataFor(ListedTheory, 'ListedTheory', classMeta, AbstractListedTheory, undefined, undefined, undefined, []);
+  setMetadataFor(MutableIndexedTheory, 'MutableIndexedTheory', classMeta, AbstractIndexedTheory, [AbstractIndexedTheory, MutableTheory], undefined, undefined, []);
+  setMetadataFor(MutableListedTheory, 'MutableListedTheory', classMeta, AbstractListedTheory, [AbstractListedTheory, MutableTheory], undefined, undefined, []);
+  //endregion
+  function AbstractClauseCollection(rete) {
+    this.j1l_1 = rete;
+  }
+  AbstractClauseCollection.prototype.k1l = function () {
+    return this.j1l_1.k1l();
+  };
+  AbstractClauseCollection.prototype.o = function () {
+    return this.j1l_1.o();
+  };
+  AbstractClauseCollection.prototype.l1l = function () {
+    return asIterable(this.j1l_1.m1l());
+  };
+  AbstractClauseCollection.prototype.n1l = function () {
+    return asIterable(this.j1l_1.n1l());
+  };
+  AbstractClauseCollection.prototype.d = function () {
+    return this.j1l_1.o1l();
+  };
+  AbstractClauseCollection.prototype.isEmpty = function () {
+    return this.d();
+  };
+  AbstractClauseCollection.prototype.p1l = function () {
+    return !this.d();
+  };
+  AbstractClauseCollection.prototype.isNonEmpty = function () {
+    return this.p1l();
+  };
+  AbstractClauseCollection.prototype.q1l = function (element) {
+    return any(this.j1l_1.r1l(element));
+  };
+  AbstractClauseCollection.prototype.contains = function (element) {
+    return this.q1l(element);
+  };
+  AbstractClauseCollection.prototype.s1l = function (elements) {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var tmp0_all = asSequence(elements);
+      var tmp0_iterator = tmp0_all.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.AbstractClauseCollection.containsAll.<anonymous>' call
+        tmp$ret$0 = this.q1l(element);
+        if (!tmp$ret$0) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    return tmp$ret$1;
+  };
+  AbstractClauseCollection.prototype.containsAll = function (elements) {
+    return this.s1l(elements);
+  };
+  AbstractClauseCollection.prototype.j = function () {
+    return this.j1l_1.t1l().j();
+  };
+  AbstractClauseCollection.prototype.toString = function () {
+    var tmp = getKClassFromExpression(this).kd();
+    return '' + tmp + '(' + joinToString$default(this, ', ', null, null, 0, null, null, 62, null) + ')';
+  };
+  function AbstractMutableReteClauseCollection(rete) {
+    AbstractClauseCollection.call(this, rete);
+  }
+  AbstractMutableReteClauseCollection.prototype.v1l = function (clause) {
+    this.j1l_1.w1l(clause);
+    return this.x1l();
+  };
+  AbstractMutableReteClauseCollection.prototype.add = function (clause) {
+    return this.v1l(clause);
+  };
+  AbstractMutableReteClauseCollection.prototype.y1l = function (clauses) {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'it.unibo.tuprolog.collections.AbstractMutableReteClauseCollection.addAll.<anonymous>' call
+      this.j1l_1.w1l(element);
+    }
+    return this.x1l();
+  };
+  AbstractMutableReteClauseCollection.prototype.addAll = function (clauses) {
+    return this.y1l(clauses);
+  };
+  AbstractMutableReteClauseCollection.prototype.z1l = function (clause) {
+    var retracted = this.j1l_1.a1m(clause);
+    return none(retracted) ? new Failure(this.x1l()) : new Success(this.x1l(), toList(retracted));
+  };
+  AbstractMutableReteClauseCollection.prototype.retrieve = function (clause) {
+    return this.z1l(clause);
+  };
+  AbstractMutableReteClauseCollection.prototype.b1m = function (clause) {
+    var retracted = this.j1l_1.c1m(clause);
+    return none(retracted) ? new Failure(this.x1l()) : new Success(this.x1l(), toList(retracted));
+  };
+  AbstractMutableReteClauseCollection.prototype.retrieveAll = function (clause) {
+    return this.b1m(clause);
+  };
+  function AbstractReteClauseCollection(rete) {
+    AbstractClauseCollection.call(this, rete);
+  }
+  AbstractReteClauseCollection.prototype.v1l = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.j1l_1.f1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.add.<anonymous>' call
+    tmp0_apply.w1l(TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = tmp0_apply;
+    return this.e1m(tmp$ret$0);
+  };
+  AbstractReteClauseCollection.prototype.add = function (clause) {
+    return this.v1l(clause);
+  };
+  AbstractReteClauseCollection.prototype.y1l = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.j1l_1.f1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.addAll.<anonymous>' call
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.addAll.<anonymous>.<anonymous>' call
+      tmp0_apply.w1l(TheoryUtils_getInstance().g1m(element));
+    }
+    tmp$ret$0 = tmp0_apply;
+    return this.e1m(tmp$ret$0);
+  };
+  AbstractReteClauseCollection.prototype.addAll = function (clauses) {
+    return this.y1l(clauses);
+  };
+  AbstractReteClauseCollection.prototype.z1l = function (clause) {
+    var newTheory = this.j1l_1.f1m();
+    var retracted = newTheory.a1m(clause);
+    return none(retracted) ? new Failure(this.x1l()) : new Success(this.e1m(newTheory), toList(retracted));
+  };
+  AbstractReteClauseCollection.prototype.retrieve = function (clause) {
+    return this.z1l(clause);
+  };
+  AbstractReteClauseCollection.prototype.b1m = function (clause) {
+    var newTheory = this.j1l_1.f1m();
+    var retracted = newTheory.c1m(clause);
+    return none(retracted) ? new Failure(this.x1l()) : new Success(this.e1m(newTheory), toList(retracted));
+  };
+  AbstractReteClauseCollection.prototype.retrieveAll = function (clause) {
+    return this.b1m(clause);
+  };
+  function Companion() {
+    Companion_instance = this;
+  }
+  Companion.prototype.empty = function (unificator) {
+    return this.ofIterable(unificator, emptyList());
+  };
+  Companion.prototype.of = function (unificator, clause) {
+    return this.ofIterable(unificator, asIterable_0(clause));
+  };
+  Companion.prototype.ofScopes = function (unificator, clause) {
+    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$(clause.length);
+    var indexedObject = clause;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.Companion.of.<anonymous>' call
+      tmp$ret$0 = Companion_getInstance().emptyWithFunction(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.ofIterable(unificator, tmp$ret$2);
+  };
+  Companion.prototype.ofSequence = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable(clauses));
+  };
+  Companion.prototype.ofIterable = function (unificator, clauses) {
+    return ReteClauseQueue_init_$Create$(unificator, clauses);
+  };
+  Companion.prototype.areEquals = function (queue1, queue2) {
+    return itemWiseEquals(queue1, queue2);
+  };
+  Companion.prototype.computeHashCode = function (queue) {
+    return itemWiseHashCode_0([getKClass(ClauseQueue), itemWiseHashCode(queue)]);
+  };
+  var Companion_instance;
+  function Companion_getInstance_7() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function ClauseQueue() {
+    Companion_getInstance_7();
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+  }
+  Companion_0.prototype.empty = function (unificator) {
+    return this.ofIterable(unificator, emptyList());
+  };
+  Companion_0.prototype.of = function (unificator, clause) {
+    return this.ofIterable(unificator, asIterable_0(clause));
+  };
+  Companion_0.prototype.ofScopes = function (unificator, clause) {
+    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$(clause.length);
+    var indexedObject = clause;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.Companion.of.<anonymous>' call
+      tmp$ret$0 = Companion_getInstance().emptyWithFunction(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.ofIterable(unificator, tmp$ret$2);
+  };
+  Companion_0.prototype.ofSequence = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable(clauses));
+  };
+  Companion_0.prototype.ofIterable = function (unificator, clauses) {
+    return MutableReteClauseQueue_init_$Create$(unificator, clauses);
+  };
+  Companion_0.prototype.areEquals = function (queue1, queue2) {
+    return Companion_getInstance_7().areEquals(queue1, queue2);
+  };
+  Companion_0.prototype.computeHashCode = function (queue) {
+    return itemWiseHashCode_0([getKClass(MutableClauseQueue), itemWiseHashCode(queue)]);
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_8() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function MutableClauseQueue() {
+    Companion_getInstance_8();
+  }
+  function Success(collection, clauses) {
+    RetrieveResult.call(this);
+    this.k1m_1 = collection;
+    this.l1m_1 = clauses;
+  }
+  Success.prototype.m1m = function () {
+    return this.k1m_1;
+  };
+  Success.prototype.t1l = function () {
+    return this.l1m_1;
+  };
+  Success.prototype.q12 = function () {
+    return true;
+  };
+  Success.prototype.n1m = function () {
+    return first(this.l1m_1);
+  };
+  Success.prototype.toString = function () {
+    return 'Success(collection=' + this.k1m_1 + ', clauses=' + this.l1m_1 + ')';
+  };
+  Success.prototype.hashCode = function () {
+    var result = hashCode(this.k1m_1);
+    result = imul(result, 31) + hashCode(this.l1m_1) | 0;
+    return result;
+  };
+  Success.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Success))
+      return false;
+    var tmp0_other_with_cast = other instanceof Success ? other : THROW_CCE();
+    if (!equals(this.k1m_1, tmp0_other_with_cast.k1m_1))
+      return false;
+    if (!equals(this.l1m_1, tmp0_other_with_cast.l1m_1))
+      return false;
+    return true;
+  };
+  function Failure(collection) {
+    RetrieveResult.call(this);
+    this.p1m_1 = collection;
+  }
+  Failure.prototype.m1m = function () {
+    return this.p1m_1;
+  };
+  Failure.prototype.o1m = function () {
+    return true;
+  };
+  Failure.prototype.t1l = function () {
+    return null;
+  };
+  Failure.prototype.n1m = function () {
+    return null;
+  };
+  Failure.prototype.toString = function () {
+    return 'Failure(collection=' + this.p1m_1 + ')';
+  };
+  Failure.prototype.hashCode = function () {
+    return hashCode(this.p1m_1);
+  };
+  Failure.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Failure))
+      return false;
+    var tmp0_other_with_cast = other instanceof Failure ? other : THROW_CCE();
+    if (!equals(this.p1m_1, tmp0_other_with_cast.p1m_1))
+      return false;
+    return true;
+  };
+  function RetrieveResult() {
+  }
+  RetrieveResult.prototype.q12 = function () {
+    return false;
+  };
+  RetrieveResult.prototype.o1m = function () {
+    return false;
+  };
+  Object.defineProperty(RetrieveResult.prototype, 'collection', {
+    configurable: true,
+    get: function () {
+      return this.m1m();
+    }
+  });
+  Object.defineProperty(RetrieveResult.prototype, 'clauses', {
+    configurable: true,
+    get: function () {
+      return this.t1l();
+    }
+  });
+  Object.defineProperty(RetrieveResult.prototype, 'firstClause', {
+    configurable: true,
+    get: function () {
+      return this.n1m();
+    }
+  });
+  function MutableReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    MutableReteClauseQueue.call($this, Companion_getInstance_9().q1m(unificator, clauses));
+    TheoryUtils_getInstance().r1m(clauses);
+    return $this;
+  }
+  function MutableReteClauseQueue_init_$Create$(unificator, clauses) {
+    return MutableReteClauseQueue_init_$Init$(unificator, clauses, Object.create(MutableReteClauseQueue.prototype));
+  }
+  function MutableReteClauseQueue(rete) {
+    AbstractMutableReteClauseCollection.call(this, rete);
+    // Inline function 'kotlin.require' call
+    var tmp0_require = rete.s1m();
+    // 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));
+    }
+  }
+  MutableReteClauseQueue.prototype.u1m = function (clause) {
+    return this.j1l_1.r1l(clause);
+  };
+  MutableReteClauseQueue.prototype.getFifoOrdered = function (clause) {
+    return this.u1m(clause);
+  };
+  MutableReteClauseQueue.prototype.v1m = function (clause) {
+    return asSequence(asReversed(toList(this.u1m(clause))));
+  };
+  MutableReteClauseQueue.prototype.getLifoOrdered = function (clause) {
+    return this.v1m(clause);
+  };
+  MutableReteClauseQueue.prototype.h1m = function (clause) {
+    this.j1l_1.w1m(clause);
+    return this;
+  };
+  MutableReteClauseQueue.prototype.addFirst = function (clause) {
+    return this.h1m(clause);
+  };
+  MutableReteClauseQueue.prototype.i1m = function (clause) {
+    this.j1l_1.w1l(clause);
+    return this;
+  };
+  MutableReteClauseQueue.prototype.addLast = function (clause) {
+    return this.i1m(clause);
+  };
+  MutableReteClauseQueue.prototype.j1m = function (clause) {
+    var retracted = this.j1l_1.a1m(clause);
+    return none(retracted) ? new Failure(this) : new Success(this, toList(retracted));
+  };
+  MutableReteClauseQueue.prototype.retrieveFirst = function (clause) {
+    return this.j1m(clause);
+  };
+  MutableReteClauseQueue.prototype.equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, MutableClauseQueue) : false) {
+      tmp = Companion_getInstance_8().areEquals(this, other);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  MutableReteClauseQueue.prototype.hashCode = function () {
+    return Companion_getInstance_8().computeHashCode(this);
+  };
+  MutableReteClauseQueue.prototype.x1l = function () {
+    return this;
+  };
+  function _get_hashCodeCache__ny3r0q($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = hashCodeCache$factory();
+    tmp$ret$0 = $this.y1m_1.b1();
+    return tmp$ret$0;
+  }
+  function ReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    ReteClauseQueue.call($this, Companion_getInstance_9().q1m(unificator, clauses));
+    TheoryUtils_getInstance().r1m(clauses);
+    return $this;
+  }
+  function ReteClauseQueue_init_$Create$(unificator, clauses) {
+    return ReteClauseQueue_init_$Init$(unificator, clauses, Object.create(ReteClauseQueue.prototype));
+  }
+  function ReteClauseQueue$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return Companion_getInstance_7().computeHashCode(this$0);
+    };
+  }
+  function ReteClauseQueue(rete) {
+    AbstractReteClauseCollection.call(this, rete);
+    var tmp = this;
+    tmp.y1m_1 = lazy(ReteClauseQueue$hashCodeCache$delegate$lambda(this));
+    // Inline function 'kotlin.require' call
+    var tmp0_require = rete.s1m();
+    // 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));
+    }
+  }
+  ReteClauseQueue.prototype.h1m = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.j1l_1.f1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.impl.ReteClauseQueue.addFirst.<anonymous>' call
+    tmp0_apply.w1m(TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = tmp0_apply;
+    return new ReteClauseQueue(tmp$ret$0);
+  };
+  ReteClauseQueue.prototype.addFirst = function (clause) {
+    return this.h1m(clause);
+  };
+  ReteClauseQueue.prototype.i1m = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.j1l_1.f1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.impl.ReteClauseQueue.addLast.<anonymous>' call
+    tmp0_apply.w1l(TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = tmp0_apply;
+    return new ReteClauseQueue(tmp$ret$0);
+  };
+  ReteClauseQueue.prototype.addLast = function (clause) {
+    return this.i1m(clause);
+  };
+  ReteClauseQueue.prototype.u1m = function (clause) {
+    return this.j1l_1.r1l(clause);
+  };
+  ReteClauseQueue.prototype.getFifoOrdered = function (clause) {
+    return this.u1m(clause);
+  };
+  ReteClauseQueue.prototype.v1m = function (clause) {
+    return asSequence(asReversed(toList(this.u1m(clause))));
+  };
+  ReteClauseQueue.prototype.getLifoOrdered = function (clause) {
+    return this.v1m(clause);
+  };
+  ReteClauseQueue.prototype.v1l = function (clause) {
+    return this.i1m(clause);
+  };
+  ReteClauseQueue.prototype.add = function (clause) {
+    return this.v1l(clause);
+  };
+  ReteClauseQueue.prototype.z1l = function (clause) {
+    return AbstractReteClauseCollection.prototype.z1l.call(this, clause);
+  };
+  ReteClauseQueue.prototype.retrieve = function (clause) {
+    return this.z1l(clause);
+  };
+  ReteClauseQueue.prototype.j1m = function (clause) {
+    return AbstractReteClauseCollection.prototype.z1l.call(this, clause);
+  };
+  ReteClauseQueue.prototype.retrieveFirst = function (clause) {
+    return this.j1m(clause);
+  };
+  ReteClauseQueue.prototype.e1m = function (rete) {
+    return new ReteClauseQueue(rete);
+  };
+  ReteClauseQueue.prototype.equals = function (other) {
+    var tmp;
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, ClauseQueue) : false) {
+      tmp_0 = !(!(other == null) ? isInterface(other, MutableClauseQueue) : false);
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = Companion_getInstance_7().areEquals(this, other);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  ReteClauseQueue.prototype.hashCode = function () {
+    return _get_hashCodeCache__ny3r0q(this);
+  };
+  ReteClauseQueue.prototype.x1l = function () {
+    return this;
+  };
+  function hashCodeCache$factory() {
+    return getPropertyCallableRef('hashCodeCache', 1, KProperty1, function (receiver) {
+      return _get_hashCodeCache__ny3r0q(receiver);
+    }, null);
+  }
+  function AbstractReteNode$removeAllLazily$slambda($source, this$0, $clause, resultContinuation) {
+    this.h1n_1 = $source;
+    this.i1n_1 = this$0;
+    this.j1n_1 = $clause;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  AbstractReteNode$removeAllLazily$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();
+  };
+  AbstractReteNode$removeAllLazily$slambda.prototype.wi = function (p1, $cont) {
+    return this.pr(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  AbstractReteNode$removeAllLazily$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.l1n_1 = this.h1n_1.j();
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.l1n_1.m()) {
+              this.ci_1 = 4;
+              continue $sm;
+            }
+
+            this.m1n_1 = this.l1n_1.p();
+            if (this.i1n_1.k1l().match(this.m1n_1.p1n(), this.j1n_1)) {
+              this.m1n_1.n1n();
+              this.l1n_1.u4();
+              this.ci_1 = 2;
+              suspendResult = this.k1n_1.z4(this.m1n_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);
+  };
+  AbstractReteNode$removeAllLazily$slambda.prototype.qr = function ($this$sequence, completion) {
+    var i = new AbstractReteNode$removeAllLazily$slambda(this.h1n_1, this.i1n_1, this.j1n_1, completion);
+    i.k1n_1 = $this$sequence;
+    return i;
+  };
+  function AbstractReteNode$removeAllLazily$slambda_0($source, this$0, $clause, resultContinuation) {
+    var i = new AbstractReteNode$removeAllLazily$slambda($source, this$0, $clause, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.pr($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function AbstractReteNode(unificator) {
+    this.o1n_1 = unificator;
+  }
+  AbstractReteNode.prototype.k1l = function () {
+    return this.o1n_1;
+  };
+  AbstractReteNode.prototype.q1n = function (source, clause) {
+    return sequence(AbstractReteNode$removeAllLazily$slambda_0(source, this, clause, null));
+  };
+  function Companion_1() {
+    Companion_instance_1 = this;
+  }
+  Companion_1.prototype.q1m = function (unificator, clauses) {
+    return new RootNode(unificator, clauses, true);
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_9() {
+    if (Companion_instance_1 == null)
+      new Companion_1();
+    return Companion_instance_1;
+  }
+  function firstArguments(_this__u8e3s4, $this) {
+    return sequence(Utils$firstArguments$slambda_0(_this__u8e3s4, null));
+  }
+  function Utils$firstArguments$slambda($this_firstArguments, resultContinuation) {
+    this.c1o_1 = $this_firstArguments;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  Utils$firstArguments$slambda.prototype.f1o = function ($this$sequence, $cont) {
+    var tmp = this.g1o($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  Utils$firstArguments$slambda.prototype.wi = function (p1, $cont) {
+    return this.f1o(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  Utils$firstArguments$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.e1o_1 = this.c1o_1;
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.e1o_1.lw()) {
+              this.ci_1 = 3;
+              continue $sm;
+            }
+
+            this.ci_1 = 2;
+            suspendResult = this.d1o_1.z4(this.e1o_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.e1o_1 = this.e1o_1.castToStruct().getArgAt(0);
+            this.ci_1 = 1;
+            continue $sm;
+          case 3:
+            this.ci_1 = 4;
+            suspendResult = this.d1o_1.z4(this.e1o_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            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);
+  };
+  Utils$firstArguments$slambda.prototype.g1o = function ($this$sequence, completion) {
+    var i = new Utils$firstArguments$slambda(this.c1o_1, completion);
+    i.d1o_1 = $this$sequence;
+    return i;
+  };
+  function Utils$firstArguments$slambda_0($this_firstArguments, resultContinuation) {
+    var i = new Utils$firstArguments$slambda($this_firstArguments, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.f1o($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function SituatedIndexedClause$compareTo$ref() {
+    var l = function (p0, p1) {
+      return p0.zs(p1);
+    };
+    l.callableName = 'compareTo';
+    return l;
+  }
+  function Utils() {
+    Utils_instance = this;
+  }
+  Utils.prototype.h1o = function (_this__u8e3s4, nestingLevel) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.Utils.arityOfNestedFirstArgument.<anonymous>' call
+    tmp$ret$0 = tmp0_let.castToStruct().zv();
+    tmp$ret$1 = tmp$ret$0;
+    return tmp$ret$1;
+  };
+  Utils.prototype.i1o = function (_this__u8e3s4, nestingLevel) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.Utils.functorOfNestedFirstArgument.<anonymous>' call
+    tmp$ret$0 = tmp0_let.castToStruct().fw();
+    tmp$ret$1 = tmp$ret$0;
+    return tmp$ret$1;
+  };
+  Utils.prototype.j1o = function (_this__u8e3s4, nestingLevel) {
+    return takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel);
+  };
+  Utils.prototype.k1o = function (args) {
+    return this.l1o(listOf(args.slice()));
+  };
+  Utils.prototype.m1o = function (sequence) {
+    return this.l1o(asIterable(sequence));
+  };
+  Utils.prototype.l1o = function (iterable) {
+    return mergeSequences(iterable, SituatedIndexedClause$compareTo$ref());
+  };
+  Utils.prototype.n1o = function (args) {
+    return this.o1o(sequenceOf(args.slice()));
+  };
+  Utils.prototype.o1o = function (sequence) {
+    return flatten(sequence);
+  };
+  Utils.prototype.p1o = function (iterable) {
+    return this.o1o(asSequence(iterable));
+  };
+  Utils.prototype.q1o = function (args) {
+    return this.r1o(sequenceOf(args.slice()));
+  };
+  Utils.prototype.r1o = function (sequence) {
+    return flatten(sequence);
+  };
+  Utils.prototype.s1o = function (a, b) {
+    return (a == null ? b == null : false) ? null : a == null ? b : b == null ? a : a.zs(b) < 0 ? a : b;
+  };
+  var Utils_instance;
+  function Utils_getInstance() {
+    if (Utils_instance == null)
+      new Utils();
+    return Utils_instance;
+  }
+  function IndexedClause$Companion$wrap$1($traversed, $indexedClause) {
+    this.u1o_1 = $indexedClause;
+    this.t1o_1 = listOf($traversed.slice());
+  }
+  IndexedClause$Companion$wrap$1.prototype.yq = function () {
+    return this.u1o_1.yq();
+  };
+  IndexedClause$Companion$wrap$1.prototype.b1 = function () {
+    return this.u1o_1.b1();
+  };
+  IndexedClause$Companion$wrap$1.prototype.v1o = function () {
+    return this.t1o_1;
+  };
+  IndexedClause$Companion$wrap$1.prototype.n1n = function () {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_forEach = this.t1o_1;
+    var tmp0_iterator = tmp0_forEach.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.clause.<no name provided>.invalidateAllCaches.<anonymous>' call
+      element.t1n();
+    }
+  };
+  IndexedClause$Companion$wrap$1.prototype.aa = function (other) {
+    return this.zs((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_2() {
+    Companion_instance_2 = this;
+  }
+  Companion_2.prototype.x1o = function (indexedClause, traversed) {
+    return new IndexedClause$Companion$wrap$1(traversed, indexedClause);
+  };
+  Companion_2.prototype.y1o = function (index, clause, traversed) {
+    return this.x1o(Companion_getInstance_0().ys(index, clause), traversed.slice());
+  };
+  Companion_2.prototype.z1o = function (index, clause, traversed) {
+    var tmp = Companion_getInstance_0().ys(index, clause);
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.toTypedArray' call
+    tmp$ret$0 = copyToArray(traversed);
+    return this.x1o(tmp, tmp$ret$0.slice());
+  };
+  var Companion_instance_2;
+  function Companion_getInstance_10() {
+    if (Companion_instance_2 == null)
+      new Companion_2();
+    return Companion_instance_2;
+  }
+  function IndexedClause() {
+  }
+  function SituatedIndexedClause$Companion$of$1($indexed, $index) {
+    this.a1p_1 = $indexed;
+    this.b1p_1 = $index;
+  }
+  SituatedIndexedClause$Companion$of$1.prototype.yq = function () {
+    return this.a1p_1.yq();
+  };
+  SituatedIndexedClause$Companion$of$1.prototype.b1 = function () {
+    return this.a1p_1.b1();
+  };
+  SituatedIndexedClause$Companion$of$1.prototype.c1p = function () {
+    this.b1p_1.d1p(this);
+    this.n1n();
+  };
+  SituatedIndexedClause$Companion$of$1.prototype.v1o = function () {
+    return this.a1p_1.v1o();
+  };
+  SituatedIndexedClause$Companion$of$1.prototype.n1n = function () {
+    this.a1p_1.n1n();
+  };
+  SituatedIndexedClause$Companion$of$1.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(!(other == null) ? isInterface(other, SituatedIndexedClause) : false))
+      return false;
+    if (!this.yq().equals(other.yq()))
+      return false;
+    return true;
+  };
+  SituatedIndexedClause$Companion$of$1.prototype.aa = function (other) {
+    return this.zs((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_3() {
+    Companion_instance_3 = this;
+  }
+  Companion_3.prototype.e1p = function (indexed, index) {
+    return new SituatedIndexedClause$Companion$of$1(indexed, index);
+  };
+  var Companion_instance_3;
+  function Companion_getInstance_11() {
+    if (Companion_instance_3 == null)
+      new Companion_3();
+    return Companion_instance_3;
+  }
+  function SituatedIndexedClause() {
+  }
+  function AbstractIndexingLeaf(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  AbstractIndexingLeaf.prototype.t1n = function () {
+  };
+  function extractFirst($this, clause) {
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.mapNotNull' call
+    var tmp0_mapNotNull = $this.o1p_1.c3();
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.mapNotNullTo' call
+    var tmp0_mapNotNullTo = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = tmp0_mapNotNull.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.extractFirst.<anonymous>' call
+      tmp$ret$0 = extractFirst_0($this, clause, element);
+      var tmp0_safe_receiver = tmp$ret$0;
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        var tmp$ret$1;
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlin.contracts.contract' call
+        tmp0_mapNotNullTo.g(tmp0_safe_receiver);
+        tmp$ret$1 = Unit_getInstance();
+      }
+    }
+    tmp$ret$2 = tmp0_mapNotNullTo;
+    tmp$ret$3 = tmp$ret$2;
+    return minOrNull(tmp$ret$3);
+  }
+  function extractFirst_0($this, clause, index) {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index_0 = 0;
+      var tmp0_iterator = index.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.extractFirst.<anonymous>' call
+        tmp$ret$0 = $this.k1l().match(item.p1n(), clause);
+        if (tmp$ret$0) {
+          tmp$ret$1 = index_0;
+          break $l$block;
+        }
+        var tmp1 = index_0;
+        index_0 = tmp1 + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    var actualIndex = tmp$ret$1;
+    return actualIndex === -1 ? null : index.n(actualIndex);
+  }
+  function nestedFirstArgument(_this__u8e3s4, $this) {
+    return Utils_getInstance().j1o(ensureNotNull(_this__u8e3s4.ly()), $this.n1p_1 + 1 | 0);
+  }
+  function asInnerAtom(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4, $this).castToAtom();
+  }
+  function asInnerAtom_0(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4.p1n(), $this).castToAtom();
+  }
+  function asInnerAtom_1(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4.p1n(), $this).castToAtom();
+  }
+  function AtomIndex$_get_size_$lambda_ygjfwe(it) {
+    return it.o();
+  }
+  function AtomIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function AtomIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.q1n(it, $clause);
+    };
+  }
+  function AtomIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function AtomIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function AtomIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.m1p_1 = ordered;
+    this.n1p_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.o1p_1 = tmp$ret$0;
+  }
+  AtomIndex.prototype.o = function () {
+    var tmp = asSequence(this.o1p_1.c3());
+    return sum(map(tmp, AtomIndex$_get_size_$lambda_ygjfwe));
+  };
+  AtomIndex.prototype.o1l = function () {
+    var tmp;
+    if (this.o1p_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.o1p_1.c3();
+        var tmp_0;
+        if (isInterface(tmp0_all, Collection)) {
+          tmp_0 = tmp0_all.d();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_all.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.d();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  AtomIndex.prototype.r1n = function (clause) {
+    if (this.m1p_1) {
+      var tmp$ret$2;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = asInnerAtom_1(clause, this);
+      // Inline function 'kotlin.contracts.contract' call
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = this.o1p_1;
+      var value = tmp0_getOrPut.a3(tmp0_let);
+      var tmp;
+      if (value == null) {
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.assertA.<anonymous>.<anonymous>' call
+        tmp$ret$0 = dequeOf([]);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.w3(tmp0_let, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      tmp$ret$1 = tmp;
+      addFirst(tmp$ret$1, Companion_getInstance_11().e1p(clause.w1o(this), this));
+      tmp$ret$2 = Unit_getInstance();
+    } else {
+      this.s1n(clause);
+    }
+  };
+  AtomIndex.prototype.s1n = function (clause) {
+    var tmp$ret$3;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = asInnerAtom_1(clause, this);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.assertZ.<anonymous>' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.o1p_1;
+    var value = tmp0_getOrPut.a3(tmp0_let);
+    var tmp;
+    if (value == null) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.assertZ.<anonymous>.<anonymous>' call
+      tmp$ret$0 = dequeOf([]);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.w3(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$2 = tmp$ret$1.g(Companion_getInstance_11().e1p(clause.w1o(this), this));
+    tmp$ret$3 = tmp$ret$2;
+  };
+  AtomIndex.prototype.g1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).aw()) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = this.o1p_1.a3(asInnerAtom(clause, this));
+      // Inline function 'kotlin.contracts.contract' call
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.getFirstIndexed.<anonymous>' call
+      var tmp_0;
+      if (tmp0_let == null) {
+        tmp_0 = null;
+      } else {
+        tmp_0 = extractFirst_0(this, clause, tmp0_let);
+      }
+      tmp$ret$0 = tmp_0;
+      tmp$ret$1 = tmp$ret$0;
+      tmp = tmp$ret$1;
+    } else {
+      tmp = extractFirst(this, clause);
+    }
+    return tmp;
+  };
+  AtomIndex.prototype.h1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).aw()) {
+      var tmp0_safe_receiver = this.o1p_1.a3(asInnerAtom(clause, this));
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : asSequence(tmp0_safe_receiver);
+      var tmp_0;
+      if (tmp1_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        tmp_0 = filter(tmp1_safe_receiver, AtomIndex$getIndexed$lambda(this, clause));
+      }
+      var tmp2_elvis_lhs = tmp_0;
+      tmp = tmp2_elvis_lhs == null ? emptySequence() : tmp2_elvis_lhs;
+    } else {
+      tmp = this.j1p(clause);
+    }
+    return tmp;
+  };
+  AtomIndex.prototype.d1p = function (indexed) {
+    ensureNotNull(this.o1p_1.a3(asInnerAtom_0(indexed, this))).ia(indexed);
+  };
+  AtomIndex.prototype.i1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).aw()) {
+      var partialIndex = this.o1p_1.a3(asInnerAtom(clause, this));
+      tmp = partialIndex == null ? emptySequence() : this.q1n(partialIndex, clause);
+    } else {
+      var tmp_0 = Utils_getInstance();
+      var tmp_1 = asSequence(this.o1p_1.c3());
+      tmp = tmp_0.m1o(map(tmp_1, AtomIndex$retractAllIndexed$lambda(this, clause)));
+    }
+    return buffered(tmp);
+  };
+  AtomIndex.prototype.k1p = function () {
+    var tmp = Utils_getInstance();
+    var tmp_0 = asSequence(this.o1p_1.c3());
+    return tmp.m1o(map(tmp_0, AtomIndex$getCache$lambda));
+  };
+  AtomIndex.prototype.j1p = function (clause) {
+    var tmp = this.k1p();
+    return filter(tmp, AtomIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function nestedFunctor(_this__u8e3s4, $this) {
+    return Utils_getInstance().i1o(ensureNotNull(_this__u8e3s4.ly()), $this.r1p_1);
+  }
+  function nestedFunctor_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().i1o(ensureNotNull(_this__u8e3s4.p1n().ly()), $this.r1p_1);
+  }
+  function isGlobal(_this__u8e3s4, $this) {
+    return Utils_getInstance().j1o(ensureNotNull(_this__u8e3s4.ly()), $this.r1p_1).bx();
+  }
+  function regenerateCache($this) {
+    var tmp;
+    if ($this.q1p_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = $this.s1p_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.k1p();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.s1p_1.c3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.k1p();
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.p1o(tmp$ret$5);
+    }
+    return dequeOf_0(tmp);
+  }
+  function CompoundIndex$regenerateCache$ref($boundThis) {
+    var l = function () {
+      return regenerateCache($boundThis);
+    };
+    l.callableName = 'regenerateCache';
+    return l;
+  }
+  function CompoundIndex$_get_size_$lambda_91vt0k(it) {
+    return it.o();
+  }
+  function CompoundIndex(unificator, ordered, nestingLevel) {
+    AbstractReteNode.call(this, unificator);
+    this.q1p_1 = ordered;
+    this.r1p_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.s1p_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.t1p_1 = tmp_1.kq(CompoundIndex$regenerateCache$ref(this));
+  }
+  CompoundIndex.prototype.o = function () {
+    var tmp = asSequence(this.s1p_1.c3());
+    return sum(map(tmp, CompoundIndex$_get_size_$lambda_91vt0k));
+  };
+  CompoundIndex.prototype.o1l = function () {
+    var tmp;
+    if (this.s1p_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.s1p_1.c3();
+        var tmp_0;
+        if (isInterface(tmp0_all, Collection)) {
+          tmp_0 = tmp0_all.d();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_all.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.o1l();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  CompoundIndex.prototype.r1n = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = nestedFunctor_0(clause, this);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp;
+    if (this.q1p_1) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = this.s1p_1;
+      var value = tmp0_getOrPut.a3(tmp0_let);
+      var tmp_0;
+      if (value == null) {
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.assertA.<anonymous>.<anonymous>' call
+        tmp$ret$0 = new FunctorIndexingNode(this.k1l(), this.q1p_1, this.r1p_1);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.w3(tmp0_let, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp$ret$1 = tmp_0;
+      tmp$ret$1.r1n(clause.w1o(this));
+      tmp = Unit_getInstance();
+    } else {
+      this.s1n(clause);
+      tmp = Unit_getInstance();
+    }
+    tmp$ret$2 = tmp;
+    return tmp$ret$2;
+  };
+  CompoundIndex.prototype.s1n = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = nestedFunctor_0(clause, this);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.s1p_1;
+    var value = tmp0_getOrPut.a3(tmp0_let);
+    var tmp;
+    if (value == null) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.assertZ.<anonymous>.<anonymous>' call
+      tmp$ret$0 = new FunctorIndexingNode(this.k1l(), this.q1p_1, this.r1p_1);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.w3(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.s1n(clause.w1o(this));
+    tmp$ret$2 = Unit_getInstance();
+    return tmp$ret$2;
+  };
+  CompoundIndex.prototype.k1p = function () {
+    return asSequence(this.t1p_1.b1());
+  };
+  CompoundIndex.prototype.g1p = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$3;
+      // Inline function 'kotlin.collections.mapNotNull' call
+      var tmp0_mapNotNull = this.s1p_1.c3();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.mapNotNullTo' call
+      var tmp0_mapNotNullTo = ArrayList_init_$Create$_0();
+      // Inline function 'kotlin.collections.forEach' call
+      var tmp0_iterator = tmp0_mapNotNull.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.p();
+        // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.getFirstIndexed.<anonymous>' call
+        tmp$ret$0 = element.g1p(clause);
+        var tmp0_safe_receiver = tmp$ret$0;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          var tmp$ret$1;
+          // Inline function 'kotlin.let' call
+          // Inline function 'kotlin.contracts.contract' call
+          tmp0_mapNotNullTo.g(tmp0_safe_receiver);
+          tmp$ret$1 = Unit_getInstance();
+        }
+      }
+      tmp$ret$2 = tmp0_mapNotNullTo;
+      tmp$ret$3 = tmp$ret$2;
+      tmp = firstOrNull(tmp_0.m1o(sequenceOf([asSequence(tmp$ret$3)])));
+    } else {
+      var tmp0_safe_receiver_0 = this.s1p_1.a3(nestedFunctor(clause, this));
+      tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.g1p(clause);
+    }
+    return tmp;
+  };
+  CompoundIndex.prototype.h1p = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = this.s1p_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.getIndexed.<anonymous>' call
+        tmp$ret$0 = item.j1p(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp0_safe_receiver = this.s1p_1.a3(nestedFunctor(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.h1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  CompoundIndex.prototype.i1p = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = this.s1p_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.retractAllIndexed.<anonymous>' call
+        tmp$ret$0 = item.i1p(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp0_safe_receiver = this.s1p_1.a3(nestedFunctor(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.i1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  CompoundIndex.prototype.j1p = function (clause) {
+    var tmp;
+    if (this.q1p_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = this.s1p_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$0 = item.j1p(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = this.s1p_1.c3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$3 = item_0.j1p(clause);
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.p1o(tmp$ret$5);
+    }
+    return tmp;
+  };
+  CompoundIndex.prototype.t1n = function () {
+    this.t1p_1.mq();
+  };
+  function DirectiveIndex$retractFirst$lambda(it) {
+    return it.p1n();
+  }
+  function DirectiveIndex$retractAll$lambda(it) {
+    return it.p1n();
+  }
+  function DirectiveIndex$getCache$lambda(it) {
+    var tmp = Companion_getInstance_11();
+    return tmp.e1p(it, new DirectiveIndex$getCache$1$1());
+  }
+  function DirectiveIndex$getCache$1$1() {
+  }
+  DirectiveIndex$getCache$1$1.prototype.d1p = function (indexed) {
+    // Inline function 'kotlin.TODO' call
+    var tmp0_TODO = 'Directives are adapted as a SituatedIndexedClause, but they are not actually stored with this type. Given their particular semantic, try retracting directly with a proper query, or opening a pull request implementing this indexing class as a proper typed data structure';
+    throw new NotImplementedError('An operation is not implemented: ' + tmp0_TODO);
+  };
+  function DirectiveIndex(unificator, ordered) {
+    AbstractReteNode.call(this, unificator);
+    this.v1p_1 = ordered;
+    this.w1p_1 = dequeOf([]);
+  }
+  DirectiveIndex.prototype.o = function () {
+    return this.w1p_1.o();
+  };
+  DirectiveIndex.prototype.o1l = function () {
+    return this.w1p_1.d();
+  };
+  DirectiveIndex.prototype.r1l = function (clause) {
+    var tmp$ret$5;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_filter = this.w1p_1;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp0_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.DirectiveIndex.get.<anonymous>' call
+      tmp$ret$0 = this.k1l().match(element.p1n(), clause);
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    var tmp1_map = tmp$ret$2;
+    var tmp$ret$4;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+    var tmp0_iterator_0 = tmp1_map.j();
+    while (tmp0_iterator_0.m()) {
+      var item = tmp0_iterator_0.p();
+      var tmp$ret$3;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.DirectiveIndex.get.<anonymous>' call
+      tmp$ret$3 = item.p1n();
+      tmp0_mapTo.g(tmp$ret$3);
+    }
+    tmp$ret$4 = tmp0_mapTo;
+    tmp$ret$5 = tmp$ret$4;
+    return asSequence(tmp$ret$5);
+  };
+  DirectiveIndex.prototype.r1n = function (clause) {
+    if (this.v1p_1) {
+      addFirst(this.w1p_1, clause.w1o(this));
+    } else {
+      this.s1n(clause);
+    }
+  };
+  DirectiveIndex.prototype.s1n = function (clause) {
+    this.w1p_1.g(clause.w1o(this));
+  };
+  DirectiveIndex.prototype.a1m = function (clause) {
+    var tmp = this.q1n(this.w1p_1, clause);
+    return buffered(take(map(tmp, DirectiveIndex$retractFirst$lambda), 1));
+  };
+  DirectiveIndex.prototype.c1m = function (clause) {
+    var tmp = this.q1n(this.w1p_1, clause);
+    return buffered(map(tmp, DirectiveIndex$retractAll$lambda));
+  };
+  DirectiveIndex.prototype.k1p = function () {
+    var tmp = asSequence(this.w1p_1);
+    return map(tmp, DirectiveIndex$getCache$lambda);
+  };
+  DirectiveIndex.prototype.t1n = function () {
+  };
+  function extractFirst_1($this, clause) {
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.mapNotNull' call
+    var tmp0_mapNotNull = $this.a1q_1.c3();
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.mapNotNullTo' call
+    var tmp0_mapNotNullTo = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = tmp0_mapNotNull.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.extractFirst.<anonymous>' call
+      tmp$ret$0 = extractFirst_2($this, clause, element);
+      var tmp0_safe_receiver = tmp$ret$0;
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        var tmp$ret$1;
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlin.contracts.contract' call
+        tmp0_mapNotNullTo.g(tmp0_safe_receiver);
+        tmp$ret$1 = Unit_getInstance();
+      }
+    }
+    tmp$ret$2 = tmp0_mapNotNullTo;
+    tmp$ret$3 = tmp$ret$2;
+    return minOrNull(tmp$ret$3);
+  }
+  function extractFirst_2($this, clause, index) {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index_0 = 0;
+      var tmp0_iterator = index.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.extractFirst.<anonymous>' call
+        tmp$ret$0 = $this.k1l().match(item.p1n(), clause);
+        if (tmp$ret$0) {
+          tmp$ret$1 = index_0;
+          break $l$block;
+        }
+        var tmp1 = index_0;
+        index_0 = tmp1 + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    var actualIndex = tmp$ret$1;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.n(actualIndex);
+    }
+    return tmp;
+  }
+  function nestedFirstArgument_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().j1o(ensureNotNull(_this__u8e3s4.ly()), $this.z1p_1 + 1 | 0);
+  }
+  function asInnerNumeric(_this__u8e3s4, $this) {
+    return nestedFirstArgument_0(_this__u8e3s4, $this).castToNumeric();
+  }
+  function asInnerNumeric_0(_this__u8e3s4, $this) {
+    return nestedFirstArgument_0(_this__u8e3s4.p1n(), $this).castToNumeric();
+  }
+  function asInnerNumeric_1(_this__u8e3s4, $this) {
+    return nestedFirstArgument_0(_this__u8e3s4.p1n(), $this).castToNumeric();
+  }
+  function NumericIndex$_get_size_$lambda_exo30i(it) {
+    return it.o();
+  }
+  function NumericIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function NumericIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.q1n(it, $clause);
+    };
+  }
+  function NumericIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function NumericIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function NumericIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.y1p_1 = ordered;
+    this.z1p_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.a1q_1 = tmp$ret$0;
+  }
+  NumericIndex.prototype.o = function () {
+    var tmp = asSequence(this.a1q_1.c3());
+    return sum(map(tmp, NumericIndex$_get_size_$lambda_exo30i));
+  };
+  NumericIndex.prototype.o1l = function () {
+    var tmp;
+    if (this.a1q_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.a1q_1.c3();
+        var tmp_0;
+        if (isInterface(tmp0_all, Collection)) {
+          tmp_0 = tmp0_all.d();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_all.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.d();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  NumericIndex.prototype.r1n = function (clause) {
+    if (this.y1p_1) {
+      var tmp$ret$2;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = asInnerNumeric_1(clause, this);
+      // Inline function 'kotlin.contracts.contract' call
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = this.a1q_1;
+      var value = tmp0_getOrPut.a3(tmp0_let);
+      var tmp;
+      if (value == null) {
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.assertA.<anonymous>.<anonymous>' call
+        tmp$ret$0 = dequeOf([]);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.w3(tmp0_let, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      tmp$ret$1 = tmp;
+      addFirst(tmp$ret$1, Companion_getInstance_11().e1p(clause.w1o(this), this));
+      tmp$ret$2 = Unit_getInstance();
+    } else {
+      this.s1n(clause);
+    }
+  };
+  NumericIndex.prototype.s1n = function (clause) {
+    var tmp$ret$3;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = asInnerNumeric_1(clause, this);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.assertZ.<anonymous>' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.a1q_1;
+    var value = tmp0_getOrPut.a3(tmp0_let);
+    var tmp;
+    if (value == null) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.assertZ.<anonymous>.<anonymous>' call
+      tmp$ret$0 = dequeOf([]);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.w3(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$2 = tmp$ret$1.g(Companion_getInstance_11().e1p(clause.w1o(this), this));
+    tmp$ret$3 = tmp$ret$2;
+  };
+  NumericIndex.prototype.g1p = function (clause) {
+    if (nestedFirstArgument_0(clause, this).fx()) {
+      var tmp$ret$0;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = this.a1q_1.a3(asInnerNumeric(clause, this));
+      // Inline function 'kotlin.contracts.contract' call
+      return tmp0_let == null ? null : extractFirst_2(this, clause, tmp0_let);
+    } else {
+      return extractFirst_1(this, clause);
+    }
+  };
+  NumericIndex.prototype.h1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(clause, this).fx()) {
+      var tmp0_safe_receiver = this.a1q_1.a3(asInnerNumeric(clause, this));
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : asSequence(tmp0_safe_receiver);
+      var tmp_0;
+      if (tmp1_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        tmp_0 = filter(tmp1_safe_receiver, NumericIndex$getIndexed$lambda(this, clause));
+      }
+      var tmp2_elvis_lhs = tmp_0;
+      tmp = tmp2_elvis_lhs == null ? emptySequence() : tmp2_elvis_lhs;
+    } else {
+      tmp = this.j1p(clause);
+    }
+    return tmp;
+  };
+  NumericIndex.prototype.d1p = function (indexed) {
+    ensureNotNull(this.a1q_1.a3(asInnerNumeric_0(indexed, this))).ia(indexed);
+  };
+  NumericIndex.prototype.i1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(clause, this).fx()) {
+      var partialIndex = this.a1q_1.a3(asInnerNumeric(clause, this));
+      tmp = partialIndex == null ? emptySequence() : buffered(this.q1n(partialIndex, clause));
+    } else {
+      var tmp_0 = Utils_getInstance();
+      var tmp_1 = asSequence(this.a1q_1.c3());
+      tmp = buffered(tmp_0.m1o(map(tmp_1, NumericIndex$retractAllIndexed$lambda(this, clause))));
+    }
+    return tmp;
+  };
+  NumericIndex.prototype.k1p = function () {
+    var tmp = Utils_getInstance();
+    var tmp_0 = asSequence(this.a1q_1.c3());
+    return tmp.m1o(map(tmp_0, NumericIndex$getCache$lambda));
+  };
+  NumericIndex.prototype.j1p = function (clause) {
+    var tmp = this.k1p();
+    return filter(tmp, NumericIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function extractFirst_3($this, clause, index) {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index_0 = 0;
+      var tmp0_iterator = index.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.VariableIndex.extractFirst.<anonymous>' call
+        tmp$ret$0 = $this.k1l().match(item.p1n(), clause);
+        if (tmp$ret$0) {
+          tmp$ret$1 = index_0;
+          break $l$block;
+        }
+        var tmp1 = index_0;
+        index_0 = tmp1 + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    var actualIndex = tmp$ret$1;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.n(actualIndex);
+    }
+    return tmp;
+  }
+  function VariableIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function VariableIndex(unificator, ordered) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.c1q_1 = ordered;
+    this.d1q_1 = dequeOf([]);
+  }
+  VariableIndex.prototype.o = function () {
+    return this.d1q_1.o();
+  };
+  VariableIndex.prototype.o1l = function () {
+    return this.d1q_1.d();
+  };
+  VariableIndex.prototype.r1n = function (clause) {
+    var tmp;
+    if (this.c1q_1) {
+      addFirst(this.d1q_1, Companion_getInstance_11().e1p(clause.w1o(this), this));
+      tmp = Unit_getInstance();
+    } else {
+      this.s1n(clause);
+      tmp = Unit_getInstance();
+    }
+    return tmp;
+  };
+  VariableIndex.prototype.s1n = function (clause) {
+    this.d1q_1.g(Companion_getInstance_11().e1p(clause.w1o(this), this));
+  };
+  VariableIndex.prototype.k1p = function () {
+    return asSequence(this.d1q_1);
+  };
+  VariableIndex.prototype.g1p = function (clause) {
+    return extractFirst_3(this, clause, this.d1q_1);
+  };
+  VariableIndex.prototype.h1p = function (clause) {
+    return this.j1p(clause);
+  };
+  VariableIndex.prototype.d1p = function (indexed) {
+    this.d1q_1.ia(indexed);
+  };
+  VariableIndex.prototype.i1p = function (clause) {
+    return buffered(this.q1n(this.d1q_1, clause));
+  };
+  VariableIndex.prototype.j1p = function (clause) {
+    var tmp = asSequence(this.d1q_1);
+    return filter(tmp, VariableIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function ArityNode(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  function FamilyArityIndexingNode(unificator, ordered, nestingLevel) {
+    FamilyArityReteNode.call(this, unificator, ordered, nestingLevel);
+    this.m1q_1 = ordered;
+  }
+  FamilyArityIndexingNode.prototype.g1p = function (clause) {
+    return this.m1q_1 ? this.w1q(clause) : this.v1q(clause);
+  };
+  FamilyArityIndexingNode.prototype.h1p = function (clause) {
+    return this.m1q_1 ? this.y1q(clause) : this.x1q(clause);
+  };
+  FamilyArityIndexingNode.prototype.i1p = function (clause) {
+    var tmp;
+    if (this.m1q_1) {
+      tmp = this.a1r(clause);
+    } else {
+      tmp = this.z1q(clause);
+    }
+    return tmp;
+  };
+  FamilyArityIndexingNode.prototype.j1p = function (clause) {
+    var tmp;
+    if (this.m1q_1) {
+      tmp = Utils_getInstance().k1o([this.r1q_1.j1p(clause), this.q1q_1.j1p(clause), this.s1q_1.j1p(clause), this.t1q_1.j1p(clause)]);
+    } else {
+      tmp = Utils_getInstance().n1o([this.r1q_1.j1p(clause), this.q1q_1.j1p(clause), this.s1q_1.j1p(clause), this.t1q_1.j1p(clause)]);
+    }
+    return tmp;
+  };
+  function retractAllOrdered($this, clause) {
+    var tmp = $this.a1r(clause);
+    return map(tmp, FamilyArityReteNode$retractAllOrdered$lambda);
+  }
+  function getOrdered($this, clause) {
+    var tmp = $this.y1q(clause);
+    return map(tmp, FamilyArityReteNode$getOrdered$lambda);
+  }
+  function retractAllUnordered($this, clause) {
+    var tmp = $this.z1q(clause);
+    return map(tmp, FamilyArityReteNode$retractAllUnordered$lambda);
+  }
+  function getUnordered($this, clause) {
+    var tmp = $this.x1q(clause);
+    return map(tmp, FamilyArityReteNode$getUnordered$lambda);
+  }
+  function regenerateCache_0($this) {
+    var tmp;
+    if ($this.o1q_1) {
+      tmp = Utils_getInstance().k1o([$this.r1q_1.k1p(), $this.q1q_1.k1p(), $this.s1q_1.k1p(), $this.t1q_1.k1p()]);
+    } else {
+      tmp = Utils_getInstance().n1o([$this.r1q_1.k1p(), $this.q1q_1.k1p(), $this.s1q_1.k1p(), $this.t1q_1.k1p()]);
+    }
+    return dequeOf_0(tmp);
+  }
+  function nestedFirstArgument_1(_this__u8e3s4, $this) {
+    return Utils_getInstance().j1o(ensureNotNull(_this__u8e3s4.ly()), $this.p1q_1 + 1 | 0);
+  }
+  function assertByFirstParameter($this, clause) {
+    var innerFirst = nestedFirstArgument_1(clause.p1n(), $this);
+    return innerFirst.fx() ? $this.q1q_1 : innerFirst.aw() ? $this.r1q_1 : innerFirst.bx() ? $this.s1q_1 : $this.t1q_1;
+  }
+  function isGlobal_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().j1o(ensureNotNull(_this__u8e3s4.ly()), $this.p1q_1 + 1 | 0).bx();
+  }
+  function FamilyArityReteNode$regenerateCache$ref($boundThis) {
+    var l = function () {
+      return regenerateCache_0($boundThis);
+    };
+    l.callableName = 'regenerateCache';
+    return l;
+  }
+  function FamilyArityReteNode$_get_size_$lambda_sxz8zo(it) {
+    return it.o();
+  }
+  function FamilyArityReteNode$get$lambda(it) {
+    return it.p1n();
+  }
+  function FamilyArityReteNode$get$lambda_0(it) {
+    return it.p1n();
+  }
+  function FamilyArityReteNode$retractAllOrdered$lambda(it) {
+    return it.p1n();
+  }
+  function FamilyArityReteNode$getOrdered$lambda(it) {
+    return it.p1n();
+  }
+  function FamilyArityReteNode$retractAllUnordered$lambda(it) {
+    return it.p1n();
+  }
+  function FamilyArityReteNode$getUnordered$lambda(it) {
+    return it.p1n();
+  }
+  function FamilyArityReteNode(unificator, ordered, nestingLevel) {
+    ArityNode.call(this, unificator);
+    this.o1q_1 = ordered;
+    this.p1q_1 = nestingLevel;
+    this.q1q_1 = new NumericIndex(unificator, this.o1q_1, this.p1q_1);
+    this.r1q_1 = new AtomIndex(unificator, this.o1q_1, this.p1q_1);
+    this.s1q_1 = new VariableIndex(unificator, this.o1q_1);
+    this.t1q_1 = new CompoundIndex(unificator, this.o1q_1, this.p1q_1 + 1 | 0);
+    var tmp = this;
+    var tmp_0 = Companion_getInstance_1();
+    tmp.u1q_1 = tmp_0.kq(FamilyArityReteNode$regenerateCache$ref(this));
+  }
+  FamilyArityReteNode.prototype.a1m = function (clause) {
+    var tmp;
+    if (this.o1q_1) {
+      tmp = this.w1q(clause);
+    } else {
+      tmp = this.v1q(clause);
+    }
+    var result = tmp;
+    var tmp_0;
+    if (result == null) {
+      tmp_0 = emptySequence();
+    } else {
+      result.c1p();
+      this.t1n();
+      tmp_0 = sequenceOf([result.p1n()]);
+    }
+    return tmp_0;
+  };
+  FamilyArityReteNode.prototype.o = function () {
+    var tmp = sequenceOf([this.q1q_1, this.r1q_1, this.s1q_1, this.t1q_1]);
+    return sum(map(tmp, FamilyArityReteNode$_get_size_$lambda_sxz8zo));
+  };
+  FamilyArityReteNode.prototype.o1l = function () {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var tmp0_all = sequenceOf([this.q1q_1, this.r1q_1, this.s1q_1, this.t1q_1]);
+      var tmp0_iterator = tmp0_all.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FamilyArityReteNode.<get-isEmpty>.<anonymous>' call
+        tmp$ret$0 = element.o1l();
+        if (!tmp$ret$0) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    return tmp$ret$1;
+  };
+  FamilyArityReteNode.prototype.r1l = function (clause) {
+    var tmp;
+    if (isGlobal_0(clause, this)) {
+      var tmp_0;
+      if (this.o1q_1) {
+        var tmp_1 = Utils_getInstance().k1o([this.r1q_1.j1p(clause), this.s1q_1.j1p(clause), this.q1q_1.j1p(clause), this.t1q_1.j1p(clause)]);
+        tmp_0 = map(tmp_1, FamilyArityReteNode$get$lambda);
+      } else {
+        var tmp_2 = Utils_getInstance().n1o([this.r1q_1.j1p(clause), this.s1q_1.j1p(clause), this.q1q_1.j1p(clause), this.t1q_1.j1p(clause)]);
+        tmp_0 = map(tmp_2, FamilyArityReteNode$get$lambda_0);
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = this.o1q_1 ? getOrdered(this, clause) : getUnordered(this, clause);
+    }
+    return tmp;
+  };
+  FamilyArityReteNode.prototype.r1n = function (clause) {
+    return assertByFirstParameter(this, clause).r1n(clause.w1o(this));
+  };
+  FamilyArityReteNode.prototype.s1n = function (clause) {
+    return assertByFirstParameter(this, clause).s1n(clause.w1o(this));
+  };
+  FamilyArityReteNode.prototype.c1m = function (clause) {
+    var tmp;
+    if (this.o1q_1) {
+      tmp = retractAllOrdered(this, clause);
+    } else {
+      tmp = retractAllUnordered(this, clause);
+    }
+    return tmp;
+  };
+  FamilyArityReteNode.prototype.k1p = function () {
+    return asSequence(this.u1q_1.b1());
+  };
+  FamilyArityReteNode.prototype.a1r = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.fx()) {
+      tmp = Utils_getInstance().k1o([this.s1q_1.i1p(clause), this.q1q_1.i1p(clause)]);
+    } else if (innerFirst.aw()) {
+      tmp = Utils_getInstance().k1o([this.s1q_1.i1p(clause), this.r1q_1.i1p(clause)]);
+    } else if (innerFirst.bx()) {
+      tmp = Utils_getInstance().k1o([this.s1q_1.i1p(clause), this.q1q_1.i1p(clause), this.r1q_1.i1p(clause), this.t1q_1.i1p(clause)]);
+    } else {
+      tmp = Utils_getInstance().k1o([this.s1q_1.i1p(clause), this.t1q_1.i1p(clause)]);
+    }
+    return tmp;
+  };
+  FamilyArityReteNode.prototype.z1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.fx() ? Utils_getInstance().n1o([this.s1q_1.i1p(clause), this.q1q_1.i1p(clause)]) : innerFirst.aw() ? Utils_getInstance().n1o([this.s1q_1.i1p(clause), this.r1q_1.i1p(clause)]) : innerFirst.bx() ? Utils_getInstance().n1o([this.s1q_1.i1p(clause), this.q1q_1.i1p(clause), this.r1q_1.i1p(clause), this.t1q_1.i1p(clause)]) : Utils_getInstance().n1o([this.s1q_1.i1p(clause), this.t1q_1.i1p(clause)]);
+  };
+  FamilyArityReteNode.prototype.y1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.fx() ? Utils_getInstance().k1o([this.s1q_1.h1p(clause), this.q1q_1.h1p(clause)]) : innerFirst.aw() ? Utils_getInstance().k1o([this.s1q_1.h1p(clause), this.r1q_1.h1p(clause)]) : innerFirst.bx() ? Utils_getInstance().k1o([this.s1q_1.h1p(clause), this.q1q_1.h1p(clause), this.r1q_1.h1p(clause), this.t1q_1.h1p(clause)]) : Utils_getInstance().k1o([this.s1q_1.h1p(clause), this.t1q_1.h1p(clause)]);
+  };
+  FamilyArityReteNode.prototype.x1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.fx() ? Utils_getInstance().n1o([this.s1q_1.h1p(clause), this.q1q_1.h1p(clause)]) : innerFirst.aw() ? Utils_getInstance().n1o([this.s1q_1.h1p(clause), this.r1q_1.h1p(clause)]) : innerFirst.bx() ? Utils_getInstance().n1o([this.s1q_1.h1p(clause), this.q1q_1.h1p(clause), this.r1q_1.h1p(clause), this.t1q_1.h1p(clause)]) : Utils_getInstance().n1o([this.s1q_1.h1p(clause), this.t1q_1.h1p(clause)]);
+  };
+  FamilyArityReteNode.prototype.v1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.fx()) {
+      var tmp0_elvis_lhs = this.s1q_1.g1p(clause);
+      tmp = tmp0_elvis_lhs == null ? this.q1q_1.g1p(clause) : tmp0_elvis_lhs;
+    } else if (innerFirst.aw()) {
+      var tmp1_elvis_lhs = this.s1q_1.g1p(clause);
+      tmp = tmp1_elvis_lhs == null ? this.r1q_1.g1p(clause) : tmp1_elvis_lhs;
+    } else if (innerFirst.bx()) {
+      var tmp2_elvis_lhs = this.s1q_1.g1p(clause);
+      var tmp3_elvis_lhs = tmp2_elvis_lhs == null ? this.q1q_1.g1p(clause) : tmp2_elvis_lhs;
+      var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? this.r1q_1.g1p(clause) : tmp3_elvis_lhs;
+      tmp = tmp4_elvis_lhs == null ? this.t1q_1.g1p(clause) : tmp4_elvis_lhs;
+    } else {
+      var tmp5_elvis_lhs = this.s1q_1.g1p(clause);
+      tmp = tmp5_elvis_lhs == null ? this.t1q_1.g1p(clause) : tmp5_elvis_lhs;
+    }
+    return tmp;
+  };
+  FamilyArityReteNode.prototype.w1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.fx()) {
+      tmp = Utils_getInstance().s1o(this.q1q_1.g1p(clause), this.s1q_1.g1p(clause));
+    } else if (innerFirst.aw()) {
+      tmp = Utils_getInstance().s1o(this.r1q_1.g1p(clause), this.s1q_1.g1p(clause));
+    } else if (innerFirst.bx()) {
+      tmp = Utils_getInstance().s1o(Utils_getInstance().s1o(this.q1q_1.g1p(clause), this.r1q_1.g1p(clause)), Utils_getInstance().s1o(this.s1q_1.g1p(clause), this.t1q_1.g1p(clause)));
+    } else {
+      tmp = Utils_getInstance().s1o(this.s1q_1.g1p(clause), this.t1q_1.g1p(clause));
+    }
+    return tmp;
+  };
+  FamilyArityReteNode.prototype.t1n = function () {
+    this.u1q_1.mq();
+  };
+  function isGlobal_1(_this__u8e3s4, $this) {
+    return _this__u8e3s4.nw() ? Utils_getInstance().j1o(_this__u8e3s4.castToRule().ly(), $this.d1r_1).bx() : false;
+  }
+  function nestedArity(_this__u8e3s4, $this) {
+    var tmp0_safe_receiver = _this__u8e3s4.asRule();
+    var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.ly();
+    var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : Utils_getInstance().h1o(tmp1_safe_receiver, $this.d1r_1);
+    var tmp;
+    if (tmp2_elvis_lhs == null) {
+      throw IllegalStateException_init_$Create$('The nestedArity method cannot be invoked on non-rule clauses');
+    } else {
+      tmp = tmp2_elvis_lhs;
+    }
+    return tmp;
+  }
+  function nestedArity_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().h1o(ensureNotNull(_this__u8e3s4.p1n().ly()), $this.d1r_1);
+  }
+  function regenerateCache_1($this) {
+    var tmp;
+    if ($this.c1r_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = $this.e1r_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.k1p();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.e1r_1.c3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.k1p();
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.p1o(tmp$ret$5);
+    }
+    return dequeOf_0(tmp);
+  }
+  function FunctorIndexingNode$regenerateCache$ref($boundThis) {
+    var l = function () {
+      return regenerateCache_1($boundThis);
+    };
+    l.callableName = 'regenerateCache';
+    return l;
+  }
+  function FunctorIndexingNode$_get_size_$lambda_vcufvm(it) {
+    return it.o();
+  }
+  function FunctorIndexingNode$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function FunctorIndexingNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.c1r_1 = ordered;
+    this.d1r_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.e1r_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.f1r_1 = tmp_1.kq(FunctorIndexingNode$regenerateCache$ref(this));
+  }
+  FunctorIndexingNode.prototype.o = function () {
+    var tmp = asSequence(this.e1r_1.c3());
+    return sum(map(tmp, FunctorIndexingNode$_get_size_$lambda_vcufvm));
+  };
+  FunctorIndexingNode.prototype.o1l = function () {
+    var tmp;
+    if (this.e1r_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.e1r_1.c3();
+        var tmp_0;
+        if (isInterface(tmp0_all, Collection)) {
+          tmp_0 = tmp0_all.d();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_all.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.o1l();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  FunctorIndexingNode.prototype.r1n = function (clause) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.e1r_1;
+    var tmp1_getOrPut = nestedArity_0(clause, this);
+    var value = tmp0_getOrPut.a3(tmp1_getOrPut);
+    var tmp;
+    if (value == null) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.assertA.<anonymous>' call
+      tmp$ret$0 = new FamilyArityIndexingNode(this.k1l(), this.c1r_1, this.d1r_1);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.w3(tmp1_getOrPut, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.r1n(clause.w1o(this));
+  };
+  FunctorIndexingNode.prototype.s1n = function (clause) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.e1r_1;
+    var tmp1_getOrPut = nestedArity_0(clause, this);
+    var value = tmp0_getOrPut.a3(tmp1_getOrPut);
+    var tmp;
+    if (value == null) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.assertZ.<anonymous>' call
+      tmp$ret$0 = new FamilyArityIndexingNode(this.k1l(), this.c1r_1, this.d1r_1);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.w3(tmp1_getOrPut, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.s1n(clause.w1o(this));
+  };
+  FunctorIndexingNode.prototype.k1p = function () {
+    return asSequence(this.f1r_1.b1());
+  };
+  FunctorIndexingNode.prototype.g1p = function (clause) {
+    var tmp;
+    if (isGlobal_1(clause, this)) {
+      var tmp$ret$4;
+      $l$block: {
+        // Inline function 'kotlin.sequences.firstOrNull' call
+        var tmp_0 = Utils_getInstance();
+        var tmp$ret$2;
+        // Inline function 'kotlin.collections.map' call
+        var tmp0_map = this.e1r_1.c3();
+        var tmp$ret$1;
+        // Inline function 'kotlin.collections.mapTo' call
+        var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+        var tmp0_iterator = tmp0_map.j();
+        while (tmp0_iterator.m()) {
+          var item = tmp0_iterator.p();
+          var tmp$ret$0;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getFirstIndexed.<anonymous>' call
+          tmp$ret$0 = item.j1p(clause);
+          tmp0_mapTo.g(tmp$ret$0);
+        }
+        tmp$ret$1 = tmp0_mapTo;
+        tmp$ret$2 = tmp$ret$1;
+        var tmp1_firstOrNull = tmp_0.l1o(tmp$ret$2);
+        var tmp0_iterator_0 = tmp1_firstOrNull.j();
+        while (tmp0_iterator_0.m()) {
+          var element = tmp0_iterator_0.p();
+          var tmp$ret$3;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getFirstIndexed.<anonymous>' call
+          tmp$ret$3 = this.k1l().match(element.p1n(), clause);
+          if (tmp$ret$3) {
+            tmp$ret$4 = element;
+            break $l$block;
+          }
+        }
+        tmp$ret$4 = null;
+      }
+      tmp = tmp$ret$4;
+    } else {
+      var tmp0_safe_receiver = this.e1r_1.a3(nestedArity(clause, this));
+      tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.g1p(clause);
+    }
+    return tmp;
+  };
+  FunctorIndexingNode.prototype.h1p = function (clause) {
+    var tmp;
+    if (isGlobal_1(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = this.e1r_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getIndexed.<anonymous>' call
+        tmp$ret$0 = item.j1p(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp0_safe_receiver = this.e1r_1.a3(nestedArity(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.h1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  FunctorIndexingNode.prototype.i1p = function (clause) {
+    var tmp;
+    if (isGlobal_1(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = this.e1r_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.retractAllIndexed.<anonymous>' call
+        tmp$ret$0 = item.j1p(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      var tmp_1 = tmp_0.l1o(tmp$ret$2);
+      var partialResult = toList(filter(tmp_1, FunctorIndexingNode$retractAllIndexed$lambda(this, clause)));
+      var tmp$ret$3;
+      // Inline function 'kotlin.collections.isNotEmpty' call
+      tmp$ret$3 = !partialResult.d();
+      if (tmp$ret$3) {
+        this.t1n();
+        // Inline function 'kotlin.collections.forEach' call
+        var tmp0_iterator_0 = partialResult.j();
+        while (tmp0_iterator_0.m()) {
+          var element = tmp0_iterator_0.p();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.retractAllIndexed.<anonymous>' call
+          element.c1p();
+        }
+      }
+      tmp = asSequence(partialResult);
+    } else {
+      var tmp0_safe_receiver = this.e1r_1.a3(nestedArity(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.i1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  FunctorIndexingNode.prototype.j1p = function (clause) {
+    var tmp;
+    if (this.c1r_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = this.e1r_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$0 = item.j1p(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = this.e1r_1.c3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$3 = item_0.j1p(clause);
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.p1o(tmp$ret$5);
+    }
+    return tmp;
+  };
+  FunctorIndexingNode.prototype.t1n = function () {
+    this.f1r_1.mq();
+  };
+  function FunctorNode(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  function assignHigherIndex($this, clause) {
+    var tmp = Companion_getInstance_10();
+    var tmp0_this = $this;
+    tmp0_this.m1r_1 = tmp0_this.m1r_1.gh();
+    return tmp.y1o(tmp0_this.m1r_1, clause, [$this]);
+  }
+  function assignLowerIndex($this, clause) {
+    var tmp = Companion_getInstance_10();
+    var tmp0_this = $this;
+    tmp0_this.l1r_1 = tmp0_this.l1r_1.hh();
+    return tmp.y1o(tmp0_this.l1r_1, clause, [$this]);
+  }
+  function regenerateCache_2($this) {
+    var tmp;
+    if ($this.h1r_1) {
+      var tmp_0 = Utils_getInstance().k1o([$this.k1r_1.k1p(), $this.j1r_1.k1p()]);
+      tmp = map(tmp_0, RootNode$regenerateCache$lambda);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp_2 = $this.k1r_1.k1p();
+      var tmp_3 = map(tmp_2, RootNode$regenerateCache$lambda_0);
+      var tmp_4 = $this.j1r_1.k1p();
+      tmp = tmp_1.q1o([tmp_3, map(tmp_4, RootNode$regenerateCache$lambda_1)]);
+    }
+    return dequeOf_0(tmp);
+  }
+  function RootNode$regenerateCache$ref($boundThis) {
+    var l = function () {
+      return regenerateCache_2($boundThis);
+    };
+    l.callableName = 'regenerateCache';
+    return l;
+  }
+  function RootNode$_get_directives_$lambda_9lfp1g(it) {
+    return it.b1().castToDirective();
+  }
+  function RootNode$_get_rules_$lambda_py6utr(it) {
+    return it.b1().castToRule();
+  }
+  function RootNode$assertA$lambda($clause) {
+    return function (it) {
+      addFirst(it, $clause);
+      return Unit_getInstance();
+    };
+  }
+  function RootNode$assertZ$lambda($clause) {
+    return function (it) {
+      return it.g($clause);
+    };
+  }
+  function RootNode$regenerateCache$lambda(it) {
+    return it.p1n();
+  }
+  function RootNode$regenerateCache$lambda_0(it) {
+    return it.p1n();
+  }
+  function RootNode$regenerateCache$lambda_1(it) {
+    return it.p1n();
+  }
+  function RootNode(unificator, clauses, isOrdered) {
+    this.g1r_1 = unificator;
+    this.h1r_1 = isOrdered;
+    var tmp = this;
+    var tmp_0 = Companion_getInstance_1();
+    tmp.i1r_1 = tmp_0.kq(RootNode$regenerateCache$ref(this));
+    this.j1r_1 = new RuleNode(this.g1r_1, this.h1r_1);
+    this.k1r_1 = new DirectiveIndex(this.g1r_1, this.h1r_1);
+    this.l1r_1 = new Long(0, 0);
+    this.m1r_1 = new Long(0, 0);
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RootNode.<anonymous>' call
+      this.w1l(element);
+    }
+  }
+  RootNode.prototype.k1l = function () {
+    return this.g1r_1;
+  };
+  RootNode.prototype.s1m = function () {
+    return this.h1r_1;
+  };
+  RootNode.prototype.o = function () {
+    return this.k1r_1.o() + this.j1r_1.o() | 0;
+  };
+  RootNode.prototype.o1l = function () {
+    return this.k1r_1.o1l() ? this.j1r_1.o1l() : false;
+  };
+  RootNode.prototype.t1l = function () {
+    return asSequence(this.i1r_1.b1());
+  };
+  RootNode.prototype.m1l = function () {
+    var tmp = this.k1r_1.k1p();
+    return map(tmp, RootNode$_get_directives_$lambda_9lfp1g);
+  };
+  RootNode.prototype.n1l = function () {
+    var tmp = this.j1r_1.k1p();
+    return map(tmp, RootNode$_get_rules_$lambda_py6utr);
+  };
+  RootNode.prototype.r1l = function (clause) {
+    return clause.ow() ? this.k1r_1.r1l(clause) : this.j1r_1.r1l(clause);
+  };
+  RootNode.prototype.a1m = function (clause) {
+    var tmp;
+    if (clause.ow()) {
+      tmp = this.k1r_1.a1m(clause);
+    } else {
+      tmp = this.j1r_1.a1m(clause);
+    }
+    return tmp;
+  };
+  RootNode.prototype.c1m = function (clause) {
+    var tmp;
+    if (clause.ow()) {
+      tmp = this.k1r_1.c1m(clause);
+    } else {
+      tmp = this.j1r_1.c1m(clause);
+    }
+    return tmp;
+  };
+  RootNode.prototype.f1m = function () {
+    return new RootNode(this.g1r_1, asIterable(this.t1l()), this.h1r_1);
+  };
+  RootNode.prototype.w1m = function (clause) {
+    var indexed = assignLowerIndex(this, clause);
+    if (this.h1r_1) {
+      this.i1r_1.nq(RootNode$assertA$lambda(clause));
+      if (clause.ow()) {
+        this.k1r_1.r1n(indexed);
+      } else {
+        this.j1r_1.r1n(indexed);
+      }
+    } else {
+      throw UnsupportedOperationException_init_$Create$('An unordered ReteTree cannot perform the assertA operation.');
+    }
+  };
+  RootNode.prototype.w1l = function (clause) {
+    var indexed = assignHigherIndex(this, clause);
+    this.i1r_1.nq(RootNode$assertZ$lambda(clause));
+    if (clause.ow()) {
+      this.k1r_1.s1n(indexed);
+    } else {
+      this.j1r_1.s1n(indexed);
+    }
+  };
+  RootNode.prototype.t1n = function () {
+    this.i1r_1.mq();
+  };
+  function nestedFunctor_1(_this__u8e3s4, $this) {
+    return Utils_getInstance().i1o(ensureNotNull(_this__u8e3s4.ly()), 0);
+  }
+  function nestedFunctor_2(_this__u8e3s4, $this) {
+    return nestedFunctor_1(_this__u8e3s4.p1n(), $this);
+  }
+  function regenerateCache_3($this) {
+    var tmp;
+    if ($this.o1r_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = $this.p1r_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.k1p();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.p1r_1.c3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.k1p();
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.p1o(tmp$ret$5);
+    }
+    return dequeOf_0(tmp);
+  }
+  function RuleNode$regenerateCache$ref($boundThis) {
+    var l = function () {
+      return regenerateCache_3($boundThis);
+    };
+    l.callableName = 'regenerateCache';
+    return l;
+  }
+  function RuleNode$_get_size_$lambda_xjenvf(it) {
+    return it.o();
+  }
+  function RuleNode(unificator, ordered) {
+    this.n1r_1 = unificator;
+    this.o1r_1 = ordered;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.p1r_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.q1r_1 = tmp_1.kq(RuleNode$regenerateCache$ref(this));
+  }
+  RuleNode.prototype.r1l = function (clause) {
+    var tmp0_safe_receiver = this.p1r_1.a3(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.r1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  RuleNode.prototype.r1n = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = nestedFunctor_2(clause, this);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp;
+    if (this.o1r_1) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = this.p1r_1;
+      var value = tmp0_getOrPut.a3(tmp0_let);
+      var tmp_0;
+      if (value == null) {
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.assertA.<anonymous>.<anonymous>' call
+        tmp$ret$0 = new TopLevelFunctorReteNode(this.n1r_1, this.o1r_1, 0);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.w3(tmp0_let, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp$ret$1 = tmp_0;
+      tmp$ret$1.r1n(clause.w1o(this));
+      tmp = Unit_getInstance();
+    } else {
+      this.s1n(clause);
+      tmp = Unit_getInstance();
+    }
+    tmp$ret$2 = tmp;
+  };
+  RuleNode.prototype.s1n = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = nestedFunctor_2(clause, this);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.p1r_1;
+    var value = tmp0_getOrPut.a3(tmp0_let);
+    var tmp;
+    if (value == null) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.assertZ.<anonymous>.<anonymous>' call
+      tmp$ret$0 = new TopLevelFunctorReteNode(this.n1r_1, this.o1r_1, 0);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.w3(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.s1n(clause.w1o(this));
+    tmp$ret$2 = Unit_getInstance();
+  };
+  RuleNode.prototype.a1m = function (clause) {
+    var tmp0_safe_receiver = this.p1r_1.a3(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a1m(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  RuleNode.prototype.o = function () {
+    var tmp = asSequence(this.p1r_1.c3());
+    return sum(map(tmp, RuleNode$_get_size_$lambda_xjenvf));
+  };
+  RuleNode.prototype.o1l = function () {
+    var tmp;
+    if (this.p1r_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.p1r_1.c3();
+        var tmp_0;
+        if (isInterface(tmp0_all, Collection)) {
+          tmp_0 = tmp0_all.d();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_all.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.o1l();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  RuleNode.prototype.c1m = function (clause) {
+    var tmp0_safe_receiver = this.p1r_1.a3(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1m(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  RuleNode.prototype.k1p = function () {
+    return asSequence(this.q1r_1.b1());
+  };
+  RuleNode.prototype.t1n = function () {
+    this.q1r_1.mq();
+  };
+  function selectArity($this, clause) {
+    return $this.u1r_1.a3(Utils_getInstance().h1o(ensureNotNull(clause.ly()), $this.t1r_1));
+  }
+  function chooseAssertionBranch($this, clause, op) {
+    var tmp$ret$5;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = Utils_getInstance().h1o(ensureNotNull(clause.p1n().ly()), $this.t1r_1);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$4;
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.chooseAssertionBranch.<anonymous>' call
+    var tmp0_subject = tmp0_let;
+    var tmp;
+    if (tmp0_subject === 0) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = $this.u1r_1;
+      var value = tmp0_getOrPut.a3(tmp0_let);
+      var tmp_0;
+      if (value == null) {
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.chooseAssertionBranch.<anonymous>.<anonymous>' call
+        tmp$ret$0 = new ZeroArityReteNode($this.k1l(), $this.s1r_1);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.w3(tmp0_let, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp$ret$1 = tmp_0;
+      tmp = tmp$ret$1;
+    } else {
+      var tmp$ret$3;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp1_getOrPut = $this.u1r_1;
+      var value_0 = tmp1_getOrPut.a3(tmp0_let);
+      var tmp_1;
+      if (value_0 == null) {
+        var tmp$ret$2;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.chooseAssertionBranch.<anonymous>.<anonymous>' call
+        tmp$ret$2 = new FamilyArityReteNode($this.k1l(), $this.s1r_1, $this.t1r_1);
+        var answer_0 = tmp$ret$2;
+        tmp1_getOrPut.w3(tmp0_let, answer_0);
+        tmp_1 = answer_0;
+      } else {
+        tmp_1 = value_0;
+      }
+      tmp$ret$3 = tmp_1;
+      tmp = tmp$ret$3;
+    }
+    tmp$ret$4 = tmp;
+    tmp$ret$5 = tmp$ret$4;
+    op(tmp$ret$5, clause);
+  }
+  function regenerateCache_4($this) {
+    var tmp;
+    if ($this.s1r_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = $this.u1r_1.c3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+      var tmp0_iterator = tmp0_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.k1p();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.l1o(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.u1r_1.c3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.k1p();
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.p1o(tmp$ret$5);
+    }
+    return dequeOf_0(tmp);
+  }
+  function TopLevelFunctorReteNode$regenerateCache$ref($boundThis) {
+    var l = function () {
+      return regenerateCache_4($boundThis);
+    };
+    l.callableName = 'regenerateCache';
+    return l;
+  }
+  function TopLevelFunctorReteNode$_get_size_$lambda_6i36rr(it) {
+    return it.o();
+  }
+  function ReteNode$assertA$ref() {
+    var l = function (p0, p1) {
+      p0.r1n(p1);
+      return Unit_getInstance();
+    };
+    l.callableName = 'assertA';
+    return l;
+  }
+  function ReteNode$assertZ$ref() {
+    var l = function (p0, p1) {
+      p0.s1n(p1);
+      return Unit_getInstance();
+    };
+    l.callableName = 'assertZ';
+    return l;
+  }
+  function TopLevelFunctorReteNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.s1r_1 = ordered;
+    this.t1r_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.u1r_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.v1r_1 = tmp_1.kq(TopLevelFunctorReteNode$regenerateCache$ref(this));
+  }
+  TopLevelFunctorReteNode.prototype.o = function () {
+    var tmp = asSequence(this.u1r_1.c3());
+    return sum(map(tmp, TopLevelFunctorReteNode$_get_size_$lambda_6i36rr));
+  };
+  TopLevelFunctorReteNode.prototype.o1l = function () {
+    var tmp;
+    if (this.u1r_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.u1r_1.c3();
+        var tmp_0;
+        if (isInterface(tmp0_all, Collection)) {
+          tmp_0 = tmp0_all.d();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_all.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.o1l();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  TopLevelFunctorReteNode.prototype.r1l = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.r1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  TopLevelFunctorReteNode.prototype.r1n = function (clause) {
+    var tmp = clause.w1o(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertA$ref());
+  };
+  TopLevelFunctorReteNode.prototype.s1n = function (clause) {
+    var tmp = clause.w1o(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertZ$ref());
+  };
+  TopLevelFunctorReteNode.prototype.a1m = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a1m(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  TopLevelFunctorReteNode.prototype.c1m = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1m(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  TopLevelFunctorReteNode.prototype.k1p = function () {
+    return asSequence(this.v1r_1.b1());
+  };
+  TopLevelFunctorReteNode.prototype.t1n = function () {
+    this.v1r_1.mq();
+  };
+  function ZeroArityReteNode$retractFirst$lambda(it) {
+    return it.p1n();
+  }
+  function ZeroArityReteNode$get$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.k1l().match(it.p1n(), $clause);
+    };
+  }
+  function ZeroArityReteNode$get$lambda_0(it) {
+    return it.p1n();
+  }
+  function ZeroArityReteNode$retractAll$lambda(it) {
+    return it.p1n();
+  }
+  function ZeroArityReteNode(unificator, ordered) {
+    ArityNode.call(this, unificator);
+    this.x1r_1 = ordered;
+    this.y1r_1 = dequeOf([]);
+  }
+  ZeroArityReteNode.prototype.a1m = function (clause) {
+    var tmp = this.q1n(this.y1r_1, clause);
+    return buffered(take(map(tmp, ZeroArityReteNode$retractFirst$lambda), 1));
+  };
+  ZeroArityReteNode.prototype.o = function () {
+    return this.y1r_1.o();
+  };
+  ZeroArityReteNode.prototype.o1l = function () {
+    return this.y1r_1.d();
+  };
+  ZeroArityReteNode.prototype.r1l = function (clause) {
+    var tmp = asSequence(this.y1r_1);
+    var tmp_0 = filter(tmp, ZeroArityReteNode$get$lambda(this, clause));
+    return map(tmp_0, ZeroArityReteNode$get$lambda_0);
+  };
+  ZeroArityReteNode.prototype.r1n = function (clause) {
+    if (this.x1r_1) {
+      addFirst(this.y1r_1, Companion_getInstance_11().e1p(clause.w1o(this), this));
+    } else {
+      this.s1n(clause);
+    }
+  };
+  ZeroArityReteNode.prototype.s1n = function (clause) {
+    this.y1r_1.g(Companion_getInstance_11().e1p(clause.w1o(this), this));
+  };
+  ZeroArityReteNode.prototype.c1m = function (clause) {
+    var tmp = this.q1n(this.y1r_1, clause);
+    return buffered(map(tmp, ZeroArityReteNode$retractAll$lambda));
+  };
+  ZeroArityReteNode.prototype.k1p = function () {
+    return asSequence(this.y1r_1);
+  };
+  ZeroArityReteNode.prototype.t1n = function () {
+  };
+  ZeroArityReteNode.prototype.d1p = function (indexed) {
+    this.y1r_1.ia(indexed);
+  };
+  function AbstractTheory$get$lambda(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory$get$lambda_0(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory(tags) {
+    this.z1r_1 = tags;
+  }
+  AbstractTheory.prototype.kt = function () {
+    return this.z1r_1;
+  };
+  AbstractTheory.prototype.a1s = function () {
+    return this;
+  };
+  AbstractTheory.prototype.toImmutableTheory = function () {
+    return this.a1s();
+  };
+  AbstractTheory.prototype.b1s = function (clause) {
+    return plus_2.call(this, TheoryUtils_getInstance().g1m(clause));
+  };
+  AbstractTheory.prototype.plus = function (clause) {
+    return this.b1s(clause);
+  };
+  AbstractTheory.prototype.q1l = function (clause) {
+    return any(this.get(clause));
+  };
+  AbstractTheory.prototype.contains = function (clause) {
+    return this.q1l(clause);
+  };
+  AbstractTheory.prototype.c1s = function (head) {
+    return this.q1l(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  };
+  AbstractTheory.prototype.containsHead = function (head) {
+    return this.c1s(head);
+  };
+  AbstractTheory.prototype.d1s = function (indicator) {
+    return any(this.e1s(indicator));
+  };
+  AbstractTheory.prototype.containsIndicator = function (indicator) {
+    return this.d1s(indicator);
+  };
+  AbstractTheory.prototype.f1s = function (head) {
+    var tmp = this.get(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+    return map(tmp, AbstractTheory$get$lambda);
+  };
+  AbstractTheory.prototype.getByHead = function (head) {
+    return this.f1s(head);
+  };
+  AbstractTheory.prototype.e1s = function (indicator) {
+    // Inline function 'kotlin.require' call
+    var tmp0_require = indicator.vy();
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp0_require) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.AbstractTheory.get.<anonymous>' call
+      tmp$ret$0 = 'The provided indicator is not well formed: ' + indicator;
+      var message = tmp$ret$0;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    var tmp = Companion_getInstance_2();
+    var tmp_0 = Companion_getInstance_4();
+    var tmp_1 = ensureNotNull(indicator.q10());
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.map' call
+    var tmp1_map = numberRangeToNumber(1, ensureNotNull(indicator.r10()));
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+    var inductionVariable = tmp1_map.o8_1;
+    var last = tmp1_map.p8_1;
+    if (inductionVariable <= last)
+      do {
+        var item = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp$ret$1;
+        // Inline function 'it.unibo.tuprolog.theory.AbstractTheory.get.<anonymous>' call
+        tmp$ret$1 = Companion_getInstance_3().anonymous();
+        tmp0_mapTo.g(tmp$ret$1);
+      }
+       while (!(item === last));
+    tmp$ret$2 = tmp0_mapTo;
+    tmp$ret$3 = tmp$ret$2;
+    var tmp_2 = this.get(tmp.of(tmp_0.ofList(tmp_1, tmp$ret$3), [Companion_getInstance_3().anonymous()]));
+    return map(tmp_2, AbstractTheory$get$lambda_0);
+  };
+  AbstractTheory.prototype.getByIndicator = function (indicator) {
+    return this.e1s(indicator);
+  };
+  AbstractTheory.prototype.g1s = function (indicator) {
+    // Inline function 'kotlin.require' call
+    var tmp0_require = indicator.vy();
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp0_require) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.AbstractTheory.abolish.<anonymous>' call
+      tmp$ret$0 = 'The provided indicator is not well formed: ' + indicator;
+      var message = tmp$ret$0;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return this.retractAllByHead(Companion_getInstance_4().template(ensureNotNull(indicator.q10()), ensureNotNull(indicator.r10()))).h1s();
+  };
+  AbstractTheory.prototype.abolish = function (indicator) {
+    return this.g1s(indicator);
+  };
+  AbstractTheory.prototype.toString = function () {
+    var tmp = getKClassFromExpression(this).kd();
+    var tmp_0 = this.t1l();
+    return '' + tmp + '{ ' + joinToString$default(tmp_0, '. ', null, null, 0, null, null, 62, null) + ' }';
+  };
+  AbstractTheory.prototype.i1s = function (asPrologText) {
+    var tmp;
+    if (asPrologText) {
+      var tmp_0 = this.t1l();
+      tmp = joinToString$default(tmp_0, '.\n', '', '.\n', 0, null, null, 56, null);
+    } else {
+      tmp = this.toString();
+    }
+    return tmp;
+  };
+  AbstractTheory.prototype.toStringAsProlog = function (asPrologText) {
+    return this.i1s(asPrologText);
+  };
+  AbstractTheory.prototype.j = function () {
+    return this.t1l().j();
+  };
+  AbstractTheory.prototype.equals = function (other) {
+    if (other == null)
+      return false;
+    if (!(!(other == null) ? isInterface(other, Theory) : false))
+      return false;
+    return this.j1s(other, true);
+  };
+  AbstractTheory.prototype.j1s = function (other, useVarCompleteName) {
+    if (this === other)
+      return true;
+    var i = this.t1l().j();
+    var j = other.t1l().j();
+    while (i.m() ? j.m() : false) {
+      if (!i.p().equalsUsingVarCompleteNames(j.p(), useVarCompleteName)) {
+        return false;
+      }
+    }
+    return i.m() === j.m();
+  };
+  AbstractTheory.prototype.equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.j1s(other, useVarCompleteName);
+  };
+  AbstractTheory.prototype.hashCode = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_hashCode = getKClass(AbstractTheory).kd();
+    var tmp0_safe_receiver = tmp0_hashCode;
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+    tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    var base = tmp$ret$0;
+    var result = base ^ (base >>> 32 | 0);
+    var tmp0_iterator = this.t1l().j();
+    while (tmp0_iterator.m()) {
+      var clause = tmp0_iterator.p();
+      result = imul(31, result) + clause.hashCode() | 0;
+    }
+    return result;
+  };
+  AbstractTheory.prototype.o = function () {
+    var i = new Long(0, 0);
+    var iter = this.j();
+    while (iter.m()) {
+      iter.p();
+      var tmp0 = i;
+      i = tmp0.gh();
+    }
+    return i;
+  };
+  AbstractTheory.prototype.o1l = function () {
+    return !this.k1s();
+  };
+  AbstractTheory.prototype.k1s = function () {
+    return this.j().m();
+  };
+  AbstractTheory.prototype.l1s = function (unificator) {
+    var tmp;
+    if (!equals(unificator, this.k1l())) {
+      var tmp_0 = asSequence(this.t1l());
+      tmp = this.m1s(tmp_0, null, unificator, 2, null);
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  AbstractTheory.prototype.setUnificator = function (unificator) {
+    return this.l1s(unificator);
+  };
+  AbstractTheory.prototype.n1s = function (theory) {
+    var tmp;
+    if (theory.k1s()) {
+      var tmp_0 = plus_0(asSequence(this.t1l()), TheoryUtils_getInstance().o1s(asSequence(theory.t1l())));
+      tmp = this.m1s(tmp_0, null, null, 6, null);
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  AbstractTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  AbstractTheory.prototype.p1s = function (clause) {
+    var tmp = plus_0(TheoryUtils_getInstance().q1s([clause]), asSequence(this.t1l()));
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  AbstractTheory.prototype.assertA = function (clause) {
+    return this.p1s(clause);
+  };
+  AbstractTheory.prototype.r1s = function (clauses) {
+    var tmp = plus_0(TheoryUtils_getInstance().o1s(asSequence(clauses)), asSequence(this.t1l()));
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  AbstractTheory.prototype.assertAIterable = function (clauses) {
+    return this.r1s(clauses);
+  };
+  AbstractTheory.prototype.s1s = function (clauses) {
+    var tmp = plus_0(TheoryUtils_getInstance().o1s(clauses), asSequence(this.t1l()));
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  AbstractTheory.prototype.assertASequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  AbstractTheory.prototype.t1s = function (clause) {
+    var tmp = plus_0(asSequence(this.t1l()), TheoryUtils_getInstance().o1s(sequenceOf([clause])));
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  AbstractTheory.prototype.assertZ = function (clause) {
+    return this.t1s(clause);
+  };
+  AbstractTheory.prototype.u1s = function (clauses) {
+    var tmp = plus_0(asSequence(this.t1l()), asSequence(TheoryUtils_getInstance().r1m(clauses)));
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  AbstractTheory.prototype.assertZIterable = function (clauses) {
+    return this.u1s(clauses);
+  };
+  AbstractTheory.prototype.v1s = function (clauses) {
+    var tmp = plus_0(asSequence(this.t1l()), TheoryUtils_getInstance().o1s(clauses));
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  AbstractTheory.prototype.assertZSequence = function (clauses) {
+    return this.v1s(clauses);
+  };
+  AbstractTheory.prototype.m1s = function (clauses, tags, unificator, $mask0, $handler) {
+    if (!(($mask0 & 2) === 0))
+      tags = this.kt();
+    if (!(($mask0 & 4) === 0))
+      unificator = this.k1l();
+    return $handler == null ? this.w1s(clauses, tags, unificator) : $handler(clauses, tags, unificator);
+  };
+  AbstractTheory.prototype.x1s = function (clauses) {
+    return this.y1s(asIterable(clauses));
+  };
+  AbstractTheory.prototype.retractSequence = function (clauses) {
+    return this.x1s(clauses);
+  };
+  AbstractTheory.prototype.z1s = function () {
+    return this;
+  };
+  AbstractTheory.prototype.clone = function () {
+    return this.z1s();
+  };
+  function Companion_4() {
+    Companion_instance_4 = this;
+  }
+  Companion_4.prototype.empty = function (unificator) {
+    return this.indexedOfIterable(unificator, emptyList());
+  };
+  Companion_4.prototype.of = function (unificator, clause) {
+    return this.indexedOf(unificator, clause.slice());
+  };
+  Companion_4.prototype.ofIterable = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, clauses);
+  };
+  Companion_4.prototype.ofSequence = function (unificator, clauses) {
+    return this.indexedOfSequence(unificator, clauses);
+  };
+  Companion_4.prototype.ofScopes = function (unificator, clauses) {
+    return this.indexedOfScopes(unificator, clauses.slice());
+  };
+  Companion_4.prototype.emptyIndexed = function (unificator) {
+    return this.indexedOfIterable(unificator, emptyList());
+  };
+  Companion_4.prototype.indexedOf = function (unificator, clause) {
+    return this.indexedOfIterable(unificator, asIterable_0(clause));
+  };
+  Companion_4.prototype.indexedOfScopes = function (unificator, clauses) {
+    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$(clauses.length);
+    var indexedObject = clauses;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.indexedOf.<anonymous>' call
+      tmp$ret$0 = Companion_getInstance().emptyWithFunction(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.indexedOfIterable(unificator, tmp$ret$2);
+  };
+  Companion_4.prototype.indexedOfSequence = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, asIterable(clauses));
+  };
+  Companion_4.prototype.indexedOfIterable = function (unificator, clauses) {
+    return MutableIndexedTheory_init_$Create$(unificator, clauses, null, 4, null);
+  };
+  Companion_4.prototype.emptyListed = function (unificator) {
+    return this.listedOfSequence(unificator, emptySequence());
+  };
+  Companion_4.prototype.listedOf = function (unificator, clause) {
+    return this.listedOfIterable(unificator, asIterable_0(clause));
+  };
+  Companion_4.prototype.listedOfScopes = function (unificator, clause) {
+    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$(clause.length);
+    var indexedObject = clause;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.listedOf.<anonymous>' call
+      tmp$ret$0 = Companion_getInstance().emptyWithFunction(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.listedOfIterable(unificator, tmp$ret$2);
+  };
+  Companion_4.prototype.listedOfSequence = function (unificator, clauses) {
+    return this.listedOfIterable(unificator, asIterable(clauses));
+  };
+  Companion_4.prototype.listedOfIterable = function (unificator, clauses) {
+    return MutableListedTheory_init_$Create$(unificator, clauses, null, 4, null);
+  };
+  var Companion_instance_4;
+  function Companion_getInstance_12() {
+    if (Companion_instance_4 == null)
+      new Companion_4();
+    return Companion_instance_4;
+  }
+  function MutableTheory() {
+  }
+  function Success_0(theory, clauses) {
+    RetractResult.call(this);
+    this.h1t_1 = theory;
+    this.i1t_1 = clauses;
+  }
+  Success_0.prototype.h1s = function () {
+    return this.h1t_1;
+  };
+  Success_0.prototype.t1l = function () {
+    return this.i1t_1;
+  };
+  Success_0.prototype.n1m = function () {
+    return first_0(this.i1t_1);
+  };
+  Success_0.prototype.toString = function () {
+    return 'Success(theory=' + this.h1t_1 + ', clauses=' + this.i1t_1 + ')';
+  };
+  Success_0.prototype.hashCode = function () {
+    var result = hashCode(this.h1t_1);
+    result = imul(result, 31) + hashCode(this.i1t_1) | 0;
+    return result;
+  };
+  Success_0.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Success_0))
+      return false;
+    var tmp0_other_with_cast = other instanceof Success_0 ? other : THROW_CCE();
+    if (!equals(this.h1t_1, tmp0_other_with_cast.h1t_1))
+      return false;
+    if (!equals(this.i1t_1, tmp0_other_with_cast.i1t_1))
+      return false;
+    return true;
+  };
+  function Failure_0(theory) {
+    RetractResult.call(this);
+    this.j1t_1 = theory;
+  }
+  Failure_0.prototype.h1s = function () {
+    return this.j1t_1;
+  };
+  Failure_0.prototype.t1l = function () {
+    return null;
+  };
+  Failure_0.prototype.n1m = function () {
+    return null;
+  };
+  Failure_0.prototype.toString = function () {
+    return 'Failure(theory=' + this.j1t_1 + ')';
+  };
+  Failure_0.prototype.hashCode = function () {
+    return hashCode(this.j1t_1);
+  };
+  Failure_0.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Failure_0))
+      return false;
+    var tmp0_other_with_cast = other instanceof Failure_0 ? other : THROW_CCE();
+    if (!equals(this.j1t_1, tmp0_other_with_cast.j1t_1))
+      return false;
+    return true;
+  };
+  function RetractResult() {
+  }
+  Object.defineProperty(RetractResult.prototype, 'theory', {
+    configurable: true,
+    get: function () {
+      return this.h1s();
+    }
+  });
+  Object.defineProperty(RetractResult.prototype, 'clauses', {
+    configurable: true,
+    get: function () {
+      return this.t1l();
+    }
+  });
+  Object.defineProperty(RetractResult.prototype, 'firstClause', {
+    configurable: true,
+    get: function () {
+      return this.n1m();
+    }
+  });
+  function Companion_5() {
+    Companion_instance_5 = this;
+  }
+  Companion_5.prototype.empty = function (unificator) {
+    return this.indexedOfSequence(unificator, emptySequence());
+  };
+  Companion_5.prototype.emptyWithDefaultUnificator = function () {
+    return this.empty(Companion_getInstance_6().h1l());
+  };
+  Companion_5.prototype.of = function (unificator, clause) {
+    return this.indexedOf(unificator, clause.slice());
+  };
+  Companion_5.prototype.ofWithDefaultUnificator = function (clause) {
+    return this.indexedOf(Companion_getInstance_6().h1l(), clause.slice());
+  };
+  Companion_5.prototype.ofIterable = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, clauses);
+  };
+  Companion_5.prototype.ofIterableWithDefaultUnificator = function (clauses) {
+    return this.indexedOfIterable(Companion_getInstance_6().h1l(), clauses);
+  };
+  Companion_5.prototype.ofSequence = function (unificator, clauses) {
+    return this.indexedOfSequence(unificator, clauses);
+  };
+  Companion_5.prototype.ofSequenceWithDefaultUnificator = function (clauses) {
+    return this.indexedOfSequence(Companion_getInstance_6().h1l(), clauses);
+  };
+  Companion_5.prototype.ofScopes = function (unificator, clauses) {
+    return this.indexedOfScopes(unificator, clauses.slice());
+  };
+  Companion_5.prototype.ofScopesWithDefaultUnificator = function (clauses) {
+    return this.indexedOfScopes(Companion_getInstance_6().h1l(), clauses.slice());
+  };
+  Companion_5.prototype.emptyIndexed = function (unificator) {
+    return this.indexedOfIterable(unificator, emptyList());
+  };
+  Companion_5.prototype.indexedOf = function (unificator, clause) {
+    return this.indexedOfIterable(unificator, asIterable_0(clause));
+  };
+  Companion_5.prototype.indexedOfScopes = function (unificator, clauses) {
+    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$(clauses.length);
+    var indexedObject = clauses;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.indexedOf.<anonymous>' call
+      tmp$ret$0 = Companion_getInstance().emptyWithFunction(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.indexedOfIterable(unificator, tmp$ret$2);
+  };
+  Companion_5.prototype.indexedOfSequence = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, asIterable(clauses));
+  };
+  Companion_5.prototype.indexedOfIterable = function (unificator, clauses) {
+    return IndexedTheory_init_$Create$(unificator, clauses, null, 4, null);
+  };
+  Companion_5.prototype.emptyListed = function (unificator) {
+    return this.listedOfSequence(unificator, emptySequence());
+  };
+  Companion_5.prototype.listedOf = function (unificator, clause) {
+    return this.listedOfIterable(unificator, asIterable_0(clause));
+  };
+  Companion_5.prototype.listedOfScopes = function (unificator, clause) {
+    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$(clause.length);
+    var indexedObject = clause;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.listedOf.<anonymous>' call
+      tmp$ret$0 = Companion_getInstance().emptyWithFunction(item);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.listedOfIterable(unificator, tmp$ret$2);
+  };
+  Companion_5.prototype.listedOfSequence = function (unificator, clauses) {
+    return this.listedOfIterable(unificator, asIterable(clauses));
+  };
+  Companion_5.prototype.listedOfIterable = function (unificator, clauses) {
+    return ListedTheory_init_$Create$(unificator, clauses, null, 4, null);
+  };
+  var Companion_instance_5;
+  function Companion_getInstance_13() {
+    if (Companion_instance_5 == null)
+      new Companion_5();
+    return Companion_instance_5;
+  }
+  function Theory$_get_rules_$lambda_c39n1s(it) {
+    return it.asRule();
+  }
+  function Theory$_get_directives_$lambda_zbsn17(it) {
+    return it.asDirective();
+  }
+  function Theory() {
+  }
+  function actualCheck($this, clauses) {
+    // Inline function 'kotlin.require' call
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var tmp0_iterator = clauses.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.p();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.actualCheck.<anonymous>' call
+        tmp$ret$0 = element.vy();
+        if (!tmp$ret$0) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    var tmp0_require = tmp$ret$1;
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp0_require) {
+      var tmp$ret$2;
+      // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.actualCheck.<anonymous>' call
+      tmp$ret$2 = "ClauseDatabase can contain only well formed clauses: these aren't " + ('' + toList(filterNot(clauses, TheoryUtils$actualCheck$lambda)));
+      var message = tmp$ret$2;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  function TheoryUtils$actualCheck$lambda(it) {
+    return it.vy();
+  }
+  function TheoryUtils() {
+    TheoryUtils_instance = this;
+  }
+  TheoryUtils.prototype.g1m = function (clause) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClauseCorrect.<anonymous>' call
+    // Inline function 'kotlin.require' call
+    var tmp0_require = clause.vy();
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp0_require) {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClauseCorrect.<anonymous>.<anonymous>' call
+      tmp$ret$0 = 'ClauseDatabase can contain only well formed clauses: ' + ("this isn't " + clause);
+      var message = tmp$ret$0;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    tmp$ret$1 = clause;
+    return tmp$ret$1;
+  };
+  TheoryUtils.prototype.q1s = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    var tmp0_also = asSequence_0(clauses);
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClausesCorrect.<anonymous>' call
+    actualCheck(TheoryUtils_getInstance(), tmp0_also);
+    tmp$ret$0 = tmp0_also;
+    return tmp$ret$0;
+  };
+  TheoryUtils.prototype.r1m = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClausesCorrect.<anonymous>' call
+    actualCheck(TheoryUtils_getInstance(), asSequence(clauses));
+    tmp$ret$0 = clauses;
+    return tmp$ret$0;
+  };
+  TheoryUtils.prototype.o1s = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClausesCorrect.<anonymous>' call
+    actualCheck(TheoryUtils_getInstance(), clauses);
+    tmp$ret$0 = clauses;
+    return tmp$ret$0;
+  };
+  var TheoryUtils_instance;
+  function TheoryUtils_getInstance() {
+    if (TheoryUtils_instance == null)
+      new TheoryUtils();
+    return TheoryUtils_instance;
+  }
+  function _no_name_provided__qut3iv(this$0) {
+    this.k1t_1 = this$0;
+  }
+  _no_name_provided__qut3iv.prototype.j = function () {
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.theory.impl.AbstractIndexedTheory.<get-clauses>.<anonymous>' call
+    tmp$ret$0 = this.k1t_1.n1t().j();
+    return tmp$ret$0;
+  };
+  function AbstractIndexedTheory(queue, tags) {
+    AbstractTheory.call(this, tags);
+    this.m1t_1 = queue;
+  }
+  AbstractIndexedTheory.prototype.k1l = function () {
+    return this.n1t().k1l();
+  };
+  AbstractIndexedTheory.prototype.n1t = function () {
+    return this.m1t_1;
+  };
+  AbstractIndexedTheory.prototype.m1l = function () {
+    return this.n1t().l1l();
+  };
+  AbstractIndexedTheory.prototype.n1l = function () {
+    return this.n1t().n1l();
+  };
+  AbstractIndexedTheory.prototype.t1l = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.Iterable' call
+    tmp$ret$0 = new _no_name_provided__qut3iv(this);
+    return tmp$ret$0;
+  };
+  AbstractIndexedTheory.prototype.r1l = function (clause) {
+    return this.n1t().r1l(clause);
+  };
+  AbstractIndexedTheory.prototype.get = function (clause) {
+    return this.r1l(clause);
+  };
+  AbstractIndexedTheory.prototype.o = function () {
+    return toLong(this.n1t().o());
+  };
+  AbstractIndexedTheory.prototype.o1l = function () {
+    return this.n1t().isEmpty();
+  };
+  AbstractIndexedTheory.prototype.k1s = function () {
+    return !this.o1l();
+  };
+  function AbstractListedTheory(unificator, clauses, tags) {
+    AbstractTheory.call(this, tags);
+    this.p1t_1 = clauses;
+    this.q1t_1 = unificator;
+  }
+  AbstractListedTheory.prototype.t1l = function () {
+    return this.p1t_1;
+  };
+  AbstractListedTheory.prototype.r1t = function (_set____db54di) {
+    this.q1t_1 = _set____db54di;
+  };
+  AbstractListedTheory.prototype.k1l = function () {
+    return this.q1t_1;
+  };
+  AbstractListedTheory.prototype.r1l = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_filter = this.t1l();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp0_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.impl.AbstractListedTheory.get.<anonymous>' call
+      tmp$ret$0 = this.k1l().match(element, clause);
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    return asSequence(tmp$ret$2);
+  };
+  AbstractListedTheory.prototype.get = function (clause) {
+    return this.r1l(clause);
+  };
+  function IndexedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    IndexedTheory.call($this, Companion_getInstance_7().ofIterable(unificator, clauses), tags);
+    TheoryUtils_getInstance().r1m(clauses);
+    return $this;
+  }
+  function IndexedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, $this) {
+    if (!(($mask0 & 4) === 0))
+      tags = emptyMap();
+    IndexedTheory_init_$Init$(unificator, clauses, tags, $this);
+    return $this;
+  }
+  function IndexedTheory_init_$Create$(unificator, clauses, tags, $mask0, $marker) {
+    return IndexedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, Object.create(IndexedTheory.prototype));
+  }
+  function IndexedTheory_init_$Init$_1(unificator, clauses, tags, $this) {
+    IndexedTheory_init_$Init$(unificator, asIterable(clauses), tags, $this);
+    return $this;
+  }
+  function IndexedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return IndexedTheory_init_$Init$_1(unificator, clauses, tags, Object.create(IndexedTheory.prototype));
+  }
+  function _get_hashCodeCache__ny3r0q_0($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = hashCodeCache$factory_0();
+    tmp$ret$0 = $this.u1t_1.b1();
+    return tmp$ret$0;
+  }
+  function _get_sizeCache__6eswog($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = sizeCache$factory();
+    tmp$ret$0 = $this.v1t_1.b1();
+    return tmp$ret$0;
+  }
+  function IndexedTheory$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return AbstractIndexedTheory.prototype.hashCode.call(this$0);
+    };
+  }
+  function IndexedTheory$sizeCache$delegate$lambda(this$0) {
+    return function () {
+      return AbstractIndexedTheory.prototype.o.call(this$0);
+    };
+  }
+  function IndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    var tmp = this;
+    tmp.u1t_1 = lazy(IndexedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.v1t_1 = lazy(IndexedTheory$sizeCache$delegate$lambda(this));
+  }
+  IndexedTheory.prototype.w1s = function (clauses, tags, unificator) {
+    return IndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  IndexedTheory.prototype.e1t = function (clause) {
+    var newTheory = Companion_getInstance_7().ofIterable(this.k1l(), this.t1l());
+    var retracted = newTheory.retrieveFirst(clause);
+    return retracted.o1m() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.m1m(), this.kt()), ensureNotNull(retracted.t1l()));
+  };
+  IndexedTheory.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  IndexedTheory.prototype.n1s = function (theory) {
+    return this.o1l() ? theory.toImmutableTheory() : theory.o1l() ? this : AbstractIndexedTheory.prototype.n1s.call(this, theory);
+  };
+  IndexedTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  IndexedTheory.prototype.b1t = function () {
+    return Companion_getInstance_12().indexedOfIterable(this.k1l(), this);
+  };
+  IndexedTheory.prototype.toMutableTheory = function () {
+    return this.b1t();
+  };
+  IndexedTheory.prototype.y1s = function (clauses) {
+    var newTheory = Companion_getInstance_8().ofIterable(this.k1l(), this.t1l());
+    var removed = dequeOf([]);
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var clause = tmp0_iterator.p();
+      var result = newTheory.j1m(clause);
+      if (result.q12()) {
+        removed.t(ensureNotNull(result.t1l()));
+      }
+    }
+    var tmp;
+    if (removed.d()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(new IndexedTheory(newTheory, this.kt()), removed);
+    }
+    return tmp;
+  };
+  IndexedTheory.prototype.retractIterable = function (clauses) {
+    return this.y1s(clauses);
+  };
+  IndexedTheory.prototype.c1m = function (clause) {
+    var newTheory = Companion_getInstance_7().ofIterable(this.k1l(), this.t1l());
+    var retracted = newTheory.b1m(clause);
+    return retracted.o1m() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.m1m(), this.kt()), ensureNotNull(retracted.t1l()));
+  };
+  IndexedTheory.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  IndexedTheory.prototype.hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_0(this);
+  };
+  IndexedTheory.prototype.o = function () {
+    return _get_sizeCache__6eswog(this);
+  };
+  IndexedTheory.prototype.o12 = function (tags) {
+    return tags === this.kt() ? this : new IndexedTheory(this.n1t(), tags);
+  };
+  IndexedTheory.prototype.resetTags = function (tags) {
+    return this.o12(tags);
+  };
+  function hashCodeCache$factory_0() {
+    return getPropertyCallableRef('hashCodeCache', 1, KProperty1, function (receiver) {
+      return _get_hashCodeCache__ny3r0q_0(receiver);
+    }, null);
+  }
+  function sizeCache$factory() {
+    return getPropertyCallableRef('sizeCache', 1, KProperty1, function (receiver) {
+      return _get_sizeCache__6eswog(receiver);
+    }, null);
+  }
+  function ListedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    ListedTheory.call($this, unificator, toList_0(clauses), tags);
+    TheoryUtils_getInstance().r1m(clauses);
+    return $this;
+  }
+  function ListedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, $this) {
+    if (!(($mask0 & 4) === 0))
+      tags = emptyMap();
+    ListedTheory_init_$Init$(unificator, clauses, tags, $this);
+    return $this;
+  }
+  function ListedTheory_init_$Create$(unificator, clauses, tags, $mask0, $marker) {
+    return ListedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, Object.create(ListedTheory.prototype));
+  }
+  function ListedTheory_init_$Init$_1(unificator, clauses, tags, $this) {
+    ListedTheory.call($this, unificator, toList(clauses), tags);
+    TheoryUtils_getInstance().o1s(clauses);
+    return $this;
+  }
+  function ListedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return ListedTheory_init_$Init$_1(unificator, clauses, tags, Object.create(ListedTheory.prototype));
+  }
+  function _get_hashCodeCache__ny3r0q_1($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = hashCodeCache$factory_1();
+    tmp$ret$0 = $this.z1t_1.b1();
+    return tmp$ret$0;
+  }
+  function _get_sizeCache__6eswog_0($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = sizeCache$factory_0();
+    tmp$ret$0 = $this.a1u_1.b1();
+    return tmp$ret$0;
+  }
+  function ListedTheory$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return AbstractListedTheory.prototype.hashCode.call(this$0);
+    };
+  }
+  function ListedTheory$sizeCache$delegate$lambda(this$0) {
+    return function () {
+      return AbstractListedTheory.prototype.o.call(this$0);
+    };
+  }
+  function ListedTheory(unificator, clauses, tags) {
+    AbstractListedTheory.call(this, unificator, clauses, tags);
+    var tmp = this;
+    tmp.z1t_1 = lazy(ListedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.a1u_1 = lazy(ListedTheory$sizeCache$delegate$lambda(this));
+  }
+  ListedTheory.prototype.w1s = function (clauses, tags, unificator) {
+    return ListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  ListedTheory.prototype.e1t = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_filter = this.t1l();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp0_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+      tmp$ret$0 = this.k1l().match(element, clause);
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    var retractability = tmp$ret$2;
+    var tmp;
+    if (none_0(retractability)) {
+      tmp = new Failure_0(this);
+    } else {
+      var toBeActuallyRetracted = first(retractability);
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.filter' call
+      var tmp1_filter = this.t1l();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.filterTo' call
+      var tmp0_filterTo_0 = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = tmp1_filter.j();
+      while (tmp0_iterator_0.m()) {
+        var element_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+        tmp$ret$3 = !element_0.equals(toBeActuallyRetracted);
+        if (tmp$ret$3) {
+          tmp0_filterTo_0.g(element_0);
+        }
+      }
+      tmp$ret$4 = tmp0_filterTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      var newTheory = tmp$ret$5;
+      tmp = new Success_0(new ListedTheory(this.k1l(), newTheory, this.kt()), listOf_0(toBeActuallyRetracted));
+    }
+    return tmp;
+  };
+  ListedTheory.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  ListedTheory.prototype.b1t = function () {
+    return Companion_getInstance_12().listedOfIterable(this.k1l(), this);
+  };
+  ListedTheory.prototype.toMutableTheory = function () {
+    return this.b1t();
+  };
+  ListedTheory.prototype.y1s = function (clauses) {
+    var residual = dequeOf_1(this.t1l());
+    var removed = dequeOf([]);
+    var i = residual.j();
+    while (i.m()) {
+      var current = i.p();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.any' call
+        var tmp;
+        if (isInterface(clauses, Collection)) {
+          tmp = clauses.d();
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+        var tmp0_iterator = clauses.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+          tmp$ret$1 = this.k1l().match(element, current);
+          if (tmp$ret$1) {
+            tmp$ret$0 = true;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = false;
+      }
+      if (tmp$ret$0) {
+        i.u4();
+        removed.g(current);
+      }
+    }
+    var tmp_0;
+    if (removed.d()) {
+      tmp_0 = new Failure_0(this);
+    } else {
+      tmp_0 = new Success_0(new ListedTheory(this.k1l(), residual, this.kt()), removed);
+    }
+    return tmp_0;
+  };
+  ListedTheory.prototype.retractIterable = function (clauses) {
+    return this.y1s(clauses);
+  };
+  ListedTheory.prototype.c1m = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_filter = this.t1l();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp0_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retractAll.<anonymous>' call
+      tmp$ret$0 = this.k1l().match(element, clause);
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    var retractability = tmp$ret$2;
+    var tmp;
+    if (none_0(retractability)) {
+      tmp = new Failure_0(this);
+    } else {
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.partition' call
+      var tmp1_partition = toList_0(this.t1l());
+      var first = ArrayList_init_$Create$_0();
+      var second = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = tmp1_partition.j();
+      while (tmp0_iterator_0.m()) {
+        var element_0 = tmp0_iterator_0.p();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retractAll.<anonymous>' call
+        tmp$ret$3 = this.k1l().match(element_0, clause);
+        if (tmp$ret$3) {
+          first.g(element_0);
+        } else {
+          second.g(element_0);
+        }
+      }
+      tmp$ret$4 = new Pair(first, second);
+      var partitionedClauses = tmp$ret$4;
+      var newTheory = partitionedClauses.h4_1;
+      var toBeActuallyRetracted = partitionedClauses.g4_1;
+      tmp = new Success_0(new ListedTheory(this.k1l(), newTheory, this.kt()), toBeActuallyRetracted);
+    }
+    return tmp;
+  };
+  ListedTheory.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  ListedTheory.prototype.hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_1(this);
+  };
+  ListedTheory.prototype.o = function () {
+    return _get_sizeCache__6eswog_0(this);
+  };
+  ListedTheory.prototype.o12 = function (tags) {
+    return tags === this.kt() ? this : new ListedTheory(this.k1l(), this.t1l(), tags);
+  };
+  ListedTheory.prototype.resetTags = function (tags) {
+    return this.o12(tags);
+  };
+  ListedTheory.prototype.n1s = function (theory) {
+    return this.o1l() ? theory.toImmutableTheory() : theory.o1l() ? this : AbstractListedTheory.prototype.n1s.call(this, theory);
+  };
+  ListedTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  function hashCodeCache$factory_1() {
+    return getPropertyCallableRef('hashCodeCache', 1, KProperty1, function (receiver) {
+      return _get_hashCodeCache__ny3r0q_1(receiver);
+    }, null);
+  }
+  function sizeCache$factory_0() {
+    return getPropertyCallableRef('sizeCache', 1, KProperty1, function (receiver) {
+      return _get_sizeCache__6eswog_0(receiver);
+    }, null);
+  }
+  function MutableIndexedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    MutableIndexedTheory.call($this, Companion_getInstance_8().ofIterable(unificator, clauses), tags);
+    TheoryUtils_getInstance().r1m(clauses);
+    return $this;
+  }
+  function MutableIndexedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, $this) {
+    if (!(($mask0 & 4) === 0))
+      tags = emptyMap();
+    MutableIndexedTheory_init_$Init$(unificator, clauses, tags, $this);
+    return $this;
+  }
+  function MutableIndexedTheory_init_$Create$(unificator, clauses, tags, $mask0, $marker) {
+    return MutableIndexedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, Object.create(MutableIndexedTheory.prototype));
+  }
+  function MutableIndexedTheory_init_$Init$_1(unificator, clauses, tags, $this) {
+    MutableIndexedTheory_init_$Init$(unificator, asIterable(clauses), tags, $this);
+    return $this;
+  }
+  function MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return MutableIndexedTheory_init_$Init$_1(unificator, clauses, tags, Object.create(MutableIndexedTheory.prototype));
+  }
+  function toRetractResult(_this__u8e3s4, $this) {
+    return _this__u8e3s4.q12() ? new Success_0($this, ensureNotNull(_this__u8e3s4.t1l())) : new Failure_0($this);
+  }
+  function MutableIndexedTheory$retract$lambda(this$0) {
+    return function (it) {
+      return this$0.d1u_1.z1l(it);
+    };
+  }
+  function MutableIndexedTheory$retract$lambda_0(it) {
+    return it.q12();
+  }
+  function MutableIndexedTheory$retract$lambda_1(it) {
+    return asSequence(ensureNotNull(it.t1l()));
+  }
+  function MutableIndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    this.d1u_1 = queue;
+  }
+  MutableIndexedTheory.prototype.n1t = function () {
+    return this.d1u_1;
+  };
+  MutableIndexedTheory.prototype.l1s = function (unificator) {
+    return AbstractIndexedTheory.prototype.l1s.call(this, unificator).toMutableTheory();
+  };
+  MutableIndexedTheory.prototype.setUnificator = function (unificator) {
+    return this.l1s(unificator);
+  };
+  MutableIndexedTheory.prototype.b1t = function () {
+    return toMutableTheory.call(this);
+  };
+  MutableIndexedTheory.prototype.toMutableTheory = function () {
+    return this.b1t();
+  };
+  MutableIndexedTheory.prototype.t1l = function () {
+    return toList_0(this.d1u_1);
+  };
+  MutableIndexedTheory.prototype.j = function () {
+    return this.d1u_1.j();
+  };
+  MutableIndexedTheory.prototype.w1s = function (clauses, tags, unificator) {
+    return MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  MutableIndexedTheory.prototype.e1t = function (clause) {
+    return toRetractResult(this.d1u_1.z1l(clause), this);
+  };
+  MutableIndexedTheory.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  MutableIndexedTheory.prototype.y1s = function (clauses) {
+    var tmp = asSequence(clauses);
+    var tmp_0 = map(tmp, MutableIndexedTheory$retract$lambda(this));
+    var tmp_1 = filter(tmp_0, MutableIndexedTheory$retract$lambda_0);
+    var retracted = toList(flatMap(tmp_1, MutableIndexedTheory$retract$lambda_1));
+    return retracted.d() ? new Failure_0(this) : new Success_0(this, retracted);
+  };
+  MutableIndexedTheory.prototype.retractIterable = function (clauses) {
+    return this.y1s(clauses);
+  };
+  MutableIndexedTheory.prototype.c1m = function (clause) {
+    return toRetractResult(this.d1u_1.b1m(clause), this);
+  };
+  MutableIndexedTheory.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  MutableIndexedTheory.prototype.b1s = function (clause) {
+    return this.t1s(TheoryUtils_getInstance().g1m(clause));
+  };
+  MutableIndexedTheory.prototype.plus = function (clause) {
+    return this.b1s(clause);
+  };
+  MutableIndexedTheory.prototype.n1s = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.u1s(toList_0(theory));
+    } else {
+      tmp = this.u1s(theory);
+    }
+    return tmp;
+  };
+  MutableIndexedTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  MutableIndexedTheory.prototype.p1s = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertA.<anonymous>' call
+    this.d1u_1.h1m(TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableIndexedTheory.prototype.assertA = function (clause) {
+    return this.p1s(clause);
+  };
+  MutableIndexedTheory.prototype.r1s = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertA.<anonymous>' call
+    var tmp0_iterator = asReversed(toList_0(TheoryUtils_getInstance().r1m(clauses))).j();
+    while (tmp0_iterator.m()) {
+      var clause = tmp0_iterator.p();
+      this.d1u_1.h1m(clause);
+    }
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableIndexedTheory.prototype.assertAIterable = function (clauses) {
+    return this.r1s(clauses);
+  };
+  MutableIndexedTheory.prototype.s1s = function (clauses) {
+    return this.r1s(asIterable(clauses));
+  };
+  MutableIndexedTheory.prototype.assertASequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  MutableIndexedTheory.prototype.t1s = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertZ.<anonymous>' call
+    this.d1u_1.i1m(TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableIndexedTheory.prototype.assertZ = function (clause) {
+    return this.t1s(clause);
+  };
+  MutableIndexedTheory.prototype.u1s = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertZ.<anonymous>' call
+    this.d1u_1.y1l(TheoryUtils_getInstance().r1m(clauses));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableIndexedTheory.prototype.assertZIterable = function (clauses) {
+    return this.u1s(clauses);
+  };
+  MutableIndexedTheory.prototype.v1s = function (clauses) {
+    return this.u1s(TheoryUtils_getInstance().r1m(asIterable(clauses)));
+  };
+  MutableIndexedTheory.prototype.assertZSequence = function (clauses) {
+    return this.v1s(clauses);
+  };
+  MutableIndexedTheory.prototype.x1s = function (clauses) {
+    return this.y1s(asIterable(clauses));
+  };
+  MutableIndexedTheory.prototype.retractSequence = function (clauses) {
+    return this.x1s(clauses);
+  };
+  MutableIndexedTheory.prototype.g1s = function (indicator) {
+    return AbstractIndexedTheory.prototype.g1s.call(this, indicator).toMutableTheory();
+  };
+  MutableIndexedTheory.prototype.abolish = function (indicator) {
+    return this.g1s(indicator);
+  };
+  MutableIndexedTheory.prototype.a1s = function () {
+    return Companion_getInstance_13().indexedOfIterable(this.k1l(), this);
+  };
+  MutableIndexedTheory.prototype.toImmutableTheory = function () {
+    return this.a1s();
+  };
+  MutableIndexedTheory.prototype.o12 = function (tags) {
+    return tags === this.kt() ? this : new MutableIndexedTheory(this.d1u_1, tags);
+  };
+  MutableIndexedTheory.prototype.resetTags = function (tags) {
+    return this.o12(tags);
+  };
+  MutableIndexedTheory.prototype.z1s = function () {
+    var tmp = asSequence(this.t1l());
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  MutableIndexedTheory.prototype.clone = function () {
+    return this.z1s();
+  };
+  MutableIndexedTheory.prototype.assertAFact = function (struct) {
+    return this.c1t(struct);
+  };
+  MutableIndexedTheory.prototype.assertZFact = function (struct) {
+    return this.d1t(struct);
+  };
+  MutableIndexedTheory.prototype.retractByHead = function (head) {
+    return this.f1t(head);
+  };
+  MutableIndexedTheory.prototype.retractAllByHead = function (head) {
+    return this.g1t(head);
+  };
+  function MutableListedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    MutableListedTheory.call($this, unificator, toMutableList(clauses), tags);
+    TheoryUtils_getInstance().r1m(clauses);
+    return $this;
+  }
+  function MutableListedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, $this) {
+    if (!(($mask0 & 4) === 0))
+      tags = emptyMap();
+    MutableListedTheory_init_$Init$(unificator, clauses, tags, $this);
+    return $this;
+  }
+  function MutableListedTheory_init_$Create$(unificator, clauses, tags, $mask0, $marker) {
+    return MutableListedTheory_init_$Init$_0(unificator, clauses, tags, $mask0, $marker, Object.create(MutableListedTheory.prototype));
+  }
+  function MutableListedTheory_init_$Init$_1(unificator, clauses, tags, $this) {
+    MutableListedTheory.call($this, unificator, toMutableList_0(clauses), tags);
+    TheoryUtils_getInstance().o1s(clauses);
+    return $this;
+  }
+  function MutableListedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return MutableListedTheory_init_$Init$_1(unificator, clauses, tags, Object.create(MutableListedTheory.prototype));
+  }
+  function MutableListedTheory(unificator, clauses, tags) {
+    AbstractListedTheory.call(this, unificator, clauses, tags);
+    this.h1u_1 = clauses;
+  }
+  MutableListedTheory.prototype.t1l = function () {
+    return this.h1u_1;
+  };
+  MutableListedTheory.prototype.l1s = function (unificator) {
+    this.r1t(unificator);
+    return this;
+  };
+  MutableListedTheory.prototype.setUnificator = function (unificator) {
+    return this.l1s(unificator);
+  };
+  MutableListedTheory.prototype.b1t = function () {
+    return toMutableTheory.call(this);
+  };
+  MutableListedTheory.prototype.toMutableTheory = function () {
+    return this.b1t();
+  };
+  MutableListedTheory.prototype.w1s = function (clauses, tags, unificator) {
+    return MutableListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  MutableListedTheory.prototype.e1t = function (clause) {
+    var i = this.h1u_1.bb();
+    while (i.m()) {
+      var c = i.p();
+      if (this.k1l().match(c, clause)) {
+        i.u4();
+        return new Success_0(this, listOf_0(c));
+      }
+    }
+    return new Failure_0(this);
+  };
+  MutableListedTheory.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  MutableListedTheory.prototype.y1s = function (clauses) {
+    var i = this.h1u_1.bb();
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    tmp$ret$0 = ArrayList_init_$Create$_0();
+    var retracted = tmp$ret$0;
+    while (i.m()) {
+      var c = i.p();
+      var tmp0_iterator = clauses.j();
+      while (tmp0_iterator.m()) {
+        var clause = tmp0_iterator.p();
+        if (this.k1l().match(c, clause)) {
+          retracted.g(c);
+          i.u4();
+        }
+      }
+    }
+    var tmp;
+    if (retracted.d()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  MutableListedTheory.prototype.retractIterable = function (clauses) {
+    return this.y1s(clauses);
+  };
+  MutableListedTheory.prototype.c1m = function (clause) {
+    var i = this.h1u_1.bb();
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    tmp$ret$0 = ArrayList_init_$Create$_0();
+    var retracted = tmp$ret$0;
+    while (i.m()) {
+      var c = i.p();
+      if (this.k1l().match(c, clause)) {
+        retracted.g(c);
+        i.u4();
+      }
+    }
+    var tmp;
+    if (retracted.d()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  MutableListedTheory.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  MutableListedTheory.prototype.b1s = function (clause) {
+    return this.t1s(clause);
+  };
+  MutableListedTheory.prototype.plus = function (clause) {
+    return this.b1s(clause);
+  };
+  MutableListedTheory.prototype.n1s = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.u1s(toList_0(theory));
+    } else {
+      tmp = this.u1s(theory);
+    }
+    return tmp;
+  };
+  MutableListedTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  MutableListedTheory.prototype.p1s = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertA.<anonymous>' call
+    addFirst(this.h1u_1, TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableListedTheory.prototype.assertA = function (clause) {
+    return this.p1s(clause);
+  };
+  MutableListedTheory.prototype.r1s = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertA.<anonymous>' call
+    addFirst_0(this.h1u_1, TheoryUtils_getInstance().r1m(clauses));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableListedTheory.prototype.assertAIterable = function (clauses) {
+    return this.r1s(clauses);
+  };
+  MutableListedTheory.prototype.s1s = function (clauses) {
+    return this.r1s(asIterable(clauses));
+  };
+  MutableListedTheory.prototype.assertASequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  MutableListedTheory.prototype.t1s = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertZ.<anonymous>' call
+    this.h1u_1.g(TheoryUtils_getInstance().g1m(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableListedTheory.prototype.assertZ = function (clause) {
+    return this.t1s(clause);
+  };
+  MutableListedTheory.prototype.u1s = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertZ.<anonymous>' call
+    addAll(this.h1u_1, TheoryUtils_getInstance().r1m(clauses));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  MutableListedTheory.prototype.assertZIterable = function (clauses) {
+    return this.u1s(clauses);
+  };
+  MutableListedTheory.prototype.v1s = function (clauses) {
+    return this.u1s(asIterable(clauses));
+  };
+  MutableListedTheory.prototype.assertZSequence = function (clauses) {
+    return this.v1s(clauses);
+  };
+  MutableListedTheory.prototype.x1s = function (clauses) {
+    return this.y1s(asIterable(clauses));
+  };
+  MutableListedTheory.prototype.retractSequence = function (clauses) {
+    return this.x1s(clauses);
+  };
+  MutableListedTheory.prototype.g1s = function (indicator) {
+    return AbstractListedTheory.prototype.g1s.call(this, indicator).toMutableTheory();
+  };
+  MutableListedTheory.prototype.abolish = function (indicator) {
+    return this.g1s(indicator);
+  };
+  MutableListedTheory.prototype.a1s = function () {
+    return Companion_getInstance_13().listedOfIterable(this.k1l(), this);
+  };
+  MutableListedTheory.prototype.toImmutableTheory = function () {
+    return this.a1s();
+  };
+  MutableListedTheory.prototype.o12 = function (tags) {
+    return tags === this.kt() ? this : new MutableListedTheory(this.k1l(), this.h1u_1, tags);
+  };
+  MutableListedTheory.prototype.resetTags = function (tags) {
+    return this.o12(tags);
+  };
+  MutableListedTheory.prototype.z1s = function () {
+    var tmp = asSequence(this.h1u_1);
+    return this.m1s(tmp, null, null, 6, null);
+  };
+  MutableListedTheory.prototype.clone = function () {
+    return this.z1s();
+  };
+  MutableListedTheory.prototype.assertAFact = function (struct) {
+    return this.c1t(struct);
+  };
+  MutableListedTheory.prototype.assertZFact = function (struct) {
+    return this.d1t(struct);
+  };
+  MutableListedTheory.prototype.retractByHead = function (head) {
+    return this.f1t(head);
+  };
+  MutableListedTheory.prototype.retractAllByHead = function (head) {
+    return this.g1t(head);
+  };
+  function takeFirstAfterSkipping(_this__u8e3s4, n) {
+    var iter = _this__u8e3s4.j();
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        iter.p();
+      }
+       while (inductionVariable < n);
+    return iter.p();
+  }
+  //region block: post-declaration
+  MutableReteClauseQueue.prototype.r1l = get;
+  ReteClauseQueue.prototype.r1l = get;
+  IndexedClause$Companion$wrap$1.prototype.p1n = get_innerClause;
+  IndexedClause$Companion$wrap$1.prototype.w1o = plus_1;
+  IndexedClause$Companion$wrap$1.prototype.zs = compareTo;
+  SituatedIndexedClause$Companion$of$1.prototype.p1n = get_innerClause;
+  SituatedIndexedClause$Companion$of$1.prototype.w1o = plus_1;
+  SituatedIndexedClause$Companion$of$1.prototype.zs = compareTo;
+  AbstractTheory.prototype.a1t = get_isMutable;
+  AbstractTheory.prototype.n1l = get_rules;
+  AbstractTheory.prototype.m1l = get_directives;
+  AbstractTheory.prototype.assertAFact = assertAFact;
+  AbstractTheory.prototype.assertZFact = assertZFact;
+  AbstractTheory.prototype.retractByHead = retractByHead;
+  AbstractTheory.prototype.retractAllByHead = retractAllByHead;
+  AbstractTheory.prototype.getTag = getTag;
+  AbstractTheory.prototype.containsTag = containsTag;
+  AbstractIndexedTheory.prototype.assertAFact = assertAFact;
+  AbstractIndexedTheory.prototype.assertZFact = assertZFact;
+  AbstractIndexedTheory.prototype.retractByHead = retractByHead;
+  AbstractIndexedTheory.prototype.a1t = get_isMutable;
+  AbstractIndexedTheory.prototype.retractAllByHead = retractAllByHead;
+  AbstractIndexedTheory.prototype.getTag = getTag;
+  AbstractIndexedTheory.prototype.containsTag = containsTag;
+  AbstractListedTheory.prototype.assertAFact = assertAFact;
+  AbstractListedTheory.prototype.assertZFact = assertZFact;
+  AbstractListedTheory.prototype.retractByHead = retractByHead;
+  AbstractListedTheory.prototype.a1t = get_isMutable;
+  AbstractListedTheory.prototype.n1l = get_rules;
+  AbstractListedTheory.prototype.m1l = get_directives;
+  AbstractListedTheory.prototype.retractAllByHead = retractAllByHead;
+  AbstractListedTheory.prototype.getTag = getTag;
+  AbstractListedTheory.prototype.containsTag = containsTag;
+  IndexedTheory.prototype.assertAFact = assertAFact;
+  IndexedTheory.prototype.assertZFact = assertZFact;
+  IndexedTheory.prototype.retractByHead = retractByHead;
+  IndexedTheory.prototype.a1t = get_isMutable;
+  IndexedTheory.prototype.retractAllByHead = retractAllByHead;
+  IndexedTheory.prototype.getTag = getTag;
+  IndexedTheory.prototype.containsTag = containsTag;
+  ListedTheory.prototype.assertAFact = assertAFact;
+  ListedTheory.prototype.assertZFact = assertZFact;
+  ListedTheory.prototype.retractByHead = retractByHead;
+  ListedTheory.prototype.a1t = get_isMutable;
+  ListedTheory.prototype.n1l = get_rules;
+  ListedTheory.prototype.m1l = get_directives;
+  ListedTheory.prototype.retractAllByHead = retractAllByHead;
+  ListedTheory.prototype.getTag = getTag;
+  ListedTheory.prototype.containsTag = containsTag;
+  MutableIndexedTheory.prototype.c1t = assertAFact_0;
+  MutableIndexedTheory.prototype.d1t = assertZFact_0;
+  MutableIndexedTheory.prototype.f1t = retractByHead_0;
+  MutableIndexedTheory.prototype.a1t = get_isMutable_0;
+  MutableIndexedTheory.prototype.g1t = retractAllByHead_0;
+  MutableIndexedTheory.prototype.getTag = getTag;
+  MutableIndexedTheory.prototype.containsTag = containsTag;
+  MutableListedTheory.prototype.c1t = assertAFact_0;
+  MutableListedTheory.prototype.d1t = assertZFact_0;
+  MutableListedTheory.prototype.f1t = retractByHead_0;
+  MutableListedTheory.prototype.a1t = get_isMutable_0;
+  MutableListedTheory.prototype.n1l = get_rules;
+  MutableListedTheory.prototype.m1l = get_directives;
+  MutableListedTheory.prototype.g1t = retractAllByHead_0;
+  MutableListedTheory.prototype.getTag = getTag;
+  MutableListedTheory.prototype.containsTag = containsTag;
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_getInstance_12;
+  _.$_$.b = Companion_getInstance_13;
+  _.$_$.c = MutableTheory;
+  _.$_$.d = Failure_0;
+  _.$_$.e = Success_0;
+  _.$_$.f = Theory;
+  //endregion
+  return _;
+}(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'), require('./2p-core.js'), require('./2p-utils.js'), require('./2p-unify.js')));
+
+//# sourceMappingURL=2p-theory.js.map