@tuprolog/arg2p-core 0.7.0 → 0.7.2

package/2p-theory.js

@@ -0,0 +1,4905 @@
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib-js-ir.js', './2p-core.js', './2p-utils.js', './2p-unify.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'), require('./2p-core.js'), require('./2p-utils.js'), require('./2p-unify.js'));
+  else {
+    if (typeof this['kotlin-kotlin-stdlib-js-ir'] === 'undefined') {
+      throw new Error("Error loading module '2p-theory'. Its dependency 'kotlin-kotlin-stdlib-js-ir' was not found. Please, check whether 'kotlin-kotlin-stdlib-js-ir' is loaded prior to '2p-theory'.");
+    }
+    if (typeof this['2p-core'] === 'undefined') {
+      throw new Error("Error loading module '2p-theory'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to '2p-theory'.");
+    }
+    if (typeof this['2p-utils'] === 'undefined') {
+      throw new Error("Error loading module '2p-theory'. Its dependency '2p-utils' was not found. Please, check whether '2p-utils' is loaded prior to '2p-theory'.");
+    }
+    if (typeof this['2p-unify'] === 'undefined') {
+      throw new Error("Error loading module '2p-theory'. Its dependency '2p-unify' was not found. Please, check whether '2p-unify' is loaded prior to '2p-theory'.");
+    }
+    root['2p-theory'] = factory(typeof this['2p-theory'] === 'undefined' ? {} : this['2p-theory'], this['kotlin-kotlin-stdlib-js-ir'], this['2p-core'], this['2p-utils'], this['2p-unify']);
+  }
+}(this, 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 protoOf = kotlin_kotlin.$_$.q5;
+  var asIterable = kotlin_kotlin.$_$.n6;
+  var any = kotlin_kotlin.$_$.m6;
+  var asSequence = kotlin_kotlin.$_$.b2;
+  var Unit_getInstance = kotlin_kotlin.$_$.o1;
+  var getKClassFromExpression = kotlin_kotlin.$_$.b;
+  var joinToString = kotlin_kotlin.$_$.t2;
+  var classMeta = kotlin_kotlin.$_$.u4;
+  var VOID = kotlin_kotlin.$_$.s9;
+  var setMetadataFor = kotlin_kotlin.$_$.r5;
+  var toList = kotlin_kotlin.$_$.t7;
+  var none = kotlin_kotlin.$_$.j7;
+  var emptyList = kotlin_kotlin.$_$.l2;
+  var asIterable_0 = kotlin_kotlin.$_$.w1;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.d;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.q;
+  var itemWiseEquals = kotlin_it_unibo_tuprolog_utils.$_$.a1;
+  var getKClass = kotlin_kotlin.$_$.c;
+  var itemWiseHashCode = kotlin_it_unibo_tuprolog_utils.$_$.b1;
+  var itemWiseHashCode_0 = kotlin_it_unibo_tuprolog_utils.$_$.c1;
+  var objectMeta = kotlin_kotlin.$_$.p5;
+  var interfaceMeta = kotlin_kotlin.$_$.c5;
+  var first = kotlin_kotlin.$_$.p2;
+  var hashCode = kotlin_kotlin.$_$.b5;
+  var THROW_CCE = kotlin_kotlin.$_$.f9;
+  var equals = kotlin_kotlin.$_$.x4;
+  var defineProp = kotlin_kotlin.$_$.w4;
+  var objectCreate = kotlin_kotlin.$_$.o5;
+  var toString = kotlin_kotlin.$_$.v5;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.q;
+  var asReversed = kotlin_kotlin.$_$.y1;
+  var isInterface = kotlin_kotlin.$_$.f5;
+  var lazy = kotlin_kotlin.$_$.k9;
+  var KProperty1 = kotlin_kotlin.$_$.j6;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.z4;
+  var CoroutineImpl = kotlin_kotlin.$_$.m4;
+  var SequenceScope = kotlin_kotlin.$_$.k6;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.l4;
+  var sequence = kotlin_kotlin.$_$.n7;
+  var listOf = kotlin_kotlin.$_$.b3;
+  var mergeSequences = kotlin_it_unibo_tuprolog_utils.$_$.e1;
+  var sequenceOf = kotlin_kotlin.$_$.m7;
+  var flatten = kotlin_kotlin.$_$.a7;
+  var compareTo = kotlin_it_unibo_tuprolog_utils.$_$.g;
+  var LongIndexed = kotlin_it_unibo_tuprolog_utils.$_$.h;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_utils.$_$.d;
+  var copyToArray = kotlin_kotlin.$_$.j2;
+  var plus = kotlin_kotlin.$_$.t3;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.e;
+  var minOrNull = kotlin_kotlin.$_$.f3;
+  var ensureNotNull = kotlin_kotlin.$_$.i9;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.g;
+  var map = kotlin_kotlin.$_$.h7;
+  var sum = kotlin_kotlin.$_$.o7;
+  var Collection = kotlin_kotlin.$_$.p1;
+  var dequeOf = kotlin_it_unibo_tuprolog_utils.$_$.v;
+  var addFirst = kotlin_it_unibo_tuprolog_utils.$_$.n;
+  var filter = kotlin_kotlin.$_$.w6;
+  var emptySequence = kotlin_kotlin.$_$.t6;
+  var buffered = kotlin_it_unibo_tuprolog_utils.$_$.o;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.d2;
+  var dequeOf_0 = kotlin_it_unibo_tuprolog_utils.$_$.t;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_utils.$_$.b;
+  var firstOrNull = kotlin_kotlin.$_$.x6;
+  var NotImplementedError = kotlin_kotlin.$_$.a9;
+  var take = kotlin_kotlin.$_$.q7;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.t;
+  var Long = kotlin_kotlin.$_$.z8;
+  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.p;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.r;
+  var numberRangeToNumber = kotlin_kotlin.$_$.k5;
+  var plus_0 = kotlin_kotlin.$_$.l7;
+  var getTag = kotlin_it_unibo_tuprolog_utils.$_$.k;
+  var containsTag = kotlin_it_unibo_tuprolog_utils.$_$.j;
+  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.j;
+  var first_0 = kotlin_kotlin.$_$.q2;
+  var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_unify.$_$.a;
+  var filterNotNull = kotlin_kotlin.$_$.u6;
+  var Taggable = kotlin_it_unibo_tuprolog_utils.$_$.l;
+  var filterNot = kotlin_kotlin.$_$.v6;
+  var asSequence_0 = kotlin_kotlin.$_$.c2;
+  var toLong = kotlin_kotlin.$_$.t5;
+  var emptyMap = kotlin_kotlin.$_$.m2;
+  var toList_0 = kotlin_kotlin.$_$.b4;
+  var listOf_0 = kotlin_kotlin.$_$.a3;
+  var none_0 = kotlin_kotlin.$_$.o3;
+  var dequeOf_1 = kotlin_it_unibo_tuprolog_utils.$_$.u;
+  var Pair = kotlin_kotlin.$_$.d9;
+  var flatMap = kotlin_kotlin.$_$.z6;
+  var toMutableList = kotlin_kotlin.$_$.h4;
+  var toMutableList_0 = kotlin_kotlin.$_$.u7;
+  var addFirst_0 = kotlin_it_unibo_tuprolog_utils.$_$.m;
+  var addAll = kotlin_kotlin.$_$.t1;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(AbstractClauseCollection, 'AbstractClauseCollection', classMeta);
+  setMetadataFor(AbstractMutableReteClauseCollection, 'AbstractMutableReteClauseCollection', classMeta, AbstractClauseCollection);
+  setMetadataFor(AbstractReteClauseCollection, 'AbstractReteClauseCollection', classMeta, AbstractClauseCollection);
+  setMetadataFor(Companion, 'Companion', objectMeta);
+  function get(clause) {
+    return this.getFifoOrdered(clause);
+  }
+  setMetadataFor(ClauseQueue, 'ClauseQueue', interfaceMeta);
+  setMetadataFor(Companion_0, 'Companion', objectMeta);
+  setMetadataFor(MutableClauseQueue, 'MutableClauseQueue', interfaceMeta, VOID, [ClauseQueue]);
+  setMetadataFor(RetrieveResult, 'RetrieveResult', classMeta);
+  setMetadataFor(Success, 'Success', classMeta, RetrieveResult);
+  setMetadataFor(Failure, 'Failure', classMeta, RetrieveResult);
+  setMetadataFor(MutableReteClauseQueue, 'MutableReteClauseQueue', classMeta, AbstractMutableReteClauseCollection, [MutableClauseQueue, AbstractMutableReteClauseCollection]);
+  setMetadataFor(ReteClauseQueue, 'ReteClauseQueue', classMeta, AbstractReteClauseCollection, [ClauseQueue, AbstractReteClauseCollection]);
+  setMetadataFor(AbstractReteNode$removeAllLazily$slambda, 'AbstractReteNode$removeAllLazily$slambda', classMeta, CoroutineImpl, VOID, VOID, VOID, [1]);
+  setMetadataFor(AbstractReteNode, 'AbstractReteNode', classMeta);
+  setMetadataFor(Companion_1, 'Companion', objectMeta);
+  setMetadataFor(Utils$firstArguments$slambda, 'Utils$firstArguments$slambda', classMeta, CoroutineImpl, VOID, VOID, VOID, [1]);
+  setMetadataFor(Utils, 'Utils', objectMeta);
+  function get_innerClause() {
+    return this.p2();
+  }
+  function plus_1(traversed) {
+    return Companion_getInstance_10().u1l(this.bp(), this.k1k(), plus(this.q1l(), traversed));
+  }
+  setMetadataFor(IndexedClause, 'IndexedClause', interfaceMeta, VOID, [LongIndexed]);
+  setMetadataFor(IndexedClause$Companion$wrap$1, VOID, classMeta, VOID, [IndexedClause]);
+  setMetadataFor(Companion_2, 'Companion', objectMeta);
+  setMetadataFor(SituatedIndexedClause, 'SituatedIndexedClause', interfaceMeta, VOID, [IndexedClause]);
+  setMetadataFor(SituatedIndexedClause$Companion$of$1, VOID, classMeta, VOID, [SituatedIndexedClause]);
+  setMetadataFor(Companion_3, 'Companion', objectMeta);
+  setMetadataFor(AbstractIndexingLeaf, 'AbstractIndexingLeaf', classMeta, AbstractReteNode);
+  setMetadataFor(AtomIndex, 'AtomIndex', classMeta, AbstractIndexingLeaf);
+  setMetadataFor(CompoundIndex, 'CompoundIndex', classMeta, AbstractReteNode);
+  setMetadataFor(DirectiveIndex$getCache$1$1, VOID, classMeta);
+  setMetadataFor(DirectiveIndex, 'DirectiveIndex', classMeta, AbstractReteNode);
+  setMetadataFor(NumericIndex, 'NumericIndex', classMeta, AbstractIndexingLeaf);
+  setMetadataFor(VariableIndex, 'VariableIndex', classMeta, AbstractIndexingLeaf);
+  setMetadataFor(ArityNode, 'ArityNode', classMeta, AbstractReteNode);
+  setMetadataFor(FamilyArityReteNode, 'FamilyArityReteNode', classMeta, ArityNode);
+  setMetadataFor(FamilyArityIndexingNode, 'FamilyArityIndexingNode', classMeta, FamilyArityReteNode);
+  setMetadataFor(FunctorNode, 'FunctorNode', classMeta, AbstractReteNode);
+  setMetadataFor(FunctorIndexingNode, 'FunctorIndexingNode', classMeta, FunctorNode);
+  setMetadataFor(RootNode, 'RootNode', classMeta);
+  setMetadataFor(RuleNode, 'RuleNode', classMeta);
+  setMetadataFor(TopLevelFunctorReteNode, 'TopLevelFunctorReteNode', classMeta, FunctorNode);
+  setMetadataFor(ZeroArityReteNode, 'ZeroArityReteNode', classMeta, ArityNode);
+  function get_isMutable() {
+    return false;
+  }
+  function get_rules() {
+    var tmp = asSequence(this.o1i());
+    return asIterable(filterNotNull(map(tmp, Theory$_get_rules_$lambda_c39n1s)));
+  }
+  function get_directives() {
+    var tmp = asSequence(this.o1i());
+    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, VOID, [Taggable]);
+  setMetadataFor(AbstractTheory, 'AbstractTheory', classMeta, VOID, [Theory]);
+  setMetadataFor(Companion_4, 'Companion', objectMeta);
+  function get_isMutable_0() {
+    return true;
+  }
+  function toMutableTheory() {
+    return this;
+  }
+  function assertAFact_0(struct) {
+    return this.k1p(Companion_getInstance_5().of(struct));
+  }
+  function assertZFact_0(struct) {
+    return this.o1p(Companion_getInstance_5().of(struct));
+  }
+  function retractByHead_0(head) {
+    return this.z1p(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  }
+  function retractAllByHead_0(head) {
+    return this.x1i(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  }
+  setMetadataFor(MutableTheory, 'MutableTheory', interfaceMeta, VOID, [Theory]);
+  setMetadataFor(RetractResult, 'RetractResult', classMeta);
+  setMetadataFor(Success_0, 'Success', classMeta, RetractResult);
+  setMetadataFor(Failure_0, 'Failure', classMeta, RetractResult);
+  setMetadataFor(Companion_5, 'Companion', objectMeta);
+  setMetadataFor(TheoryUtils, 'TheoryUtils', objectMeta);
+  setMetadataFor(_no_name_provided__qut3iv, VOID, classMeta);
+  setMetadataFor(AbstractIndexedTheory, 'AbstractIndexedTheory', classMeta, AbstractTheory);
+  setMetadataFor(AbstractListedTheory, 'AbstractListedTheory', classMeta, AbstractTheory);
+  setMetadataFor(IndexedTheory, 'IndexedTheory', classMeta, AbstractIndexedTheory);
+  setMetadataFor(ListedTheory, 'ListedTheory', classMeta, AbstractListedTheory);
+  setMetadataFor(MutableIndexedTheory, 'MutableIndexedTheory', classMeta, AbstractIndexedTheory, [AbstractIndexedTheory, MutableTheory]);
+  setMetadataFor(MutableListedTheory, 'MutableListedTheory', classMeta, AbstractListedTheory, [AbstractListedTheory, MutableTheory]);
+  //endregion
+  function AbstractClauseCollection(rete) {
+    this.e1i_1 = rete;
+  }
+  protoOf(AbstractClauseCollection).f1i = function () {
+    return this.e1i_1.f1i();
+  };
+  protoOf(AbstractClauseCollection).p = function () {
+    return this.e1i_1.p();
+  };
+  protoOf(AbstractClauseCollection).g1i = function () {
+    return asIterable(this.e1i_1.h1i());
+  };
+  protoOf(AbstractClauseCollection).i1i = function () {
+    return asIterable(this.e1i_1.i1i());
+  };
+  protoOf(AbstractClauseCollection).d = function () {
+    return this.e1i_1.j1i();
+  };
+  protoOf(AbstractClauseCollection).isEmpty = function () {
+    return this.d();
+  };
+  protoOf(AbstractClauseCollection).k1i = function () {
+    return !this.d();
+  };
+  protoOf(AbstractClauseCollection).isNonEmpty = function () {
+    return this.k1i();
+  };
+  protoOf(AbstractClauseCollection).l1i = function (element) {
+    return any(this.e1i_1.m1i(element));
+  };
+  protoOf(AbstractClauseCollection).contains = function (element) {
+    return this.l1i(element);
+  };
+  protoOf(AbstractClauseCollection).n1i = 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.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.AbstractClauseCollection.containsAll.<anonymous>' call
+        tmp$ret$0 = this.l1i(element);
+        if (!tmp$ret$0) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    return tmp$ret$1;
+  };
+  protoOf(AbstractClauseCollection).containsAll = function (elements) {
+    return this.n1i(elements);
+  };
+  protoOf(AbstractClauseCollection).j = function () {
+    return this.e1i_1.o1i().j();
+  };
+  protoOf(AbstractClauseCollection).toString = function () {
+    return '' + getKClassFromExpression(this).xc() + '(' + joinToString(this, ', ') + ')';
+  };
+  function AbstractMutableReteClauseCollection(rete) {
+    AbstractClauseCollection.call(this, rete);
+  }
+  protoOf(AbstractMutableReteClauseCollection).q1i = function (clause) {
+    this.e1i_1.r1i(clause);
+    return this.s1i();
+  };
+  protoOf(AbstractMutableReteClauseCollection).add = function (clause) {
+    return this.q1i(clause);
+  };
+  protoOf(AbstractMutableReteClauseCollection).t1i = function (clauses) {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      // Inline function 'it.unibo.tuprolog.collections.AbstractMutableReteClauseCollection.addAll.<anonymous>' call
+      this.e1i_1.r1i(element);
+    }
+    return this.s1i();
+  };
+  protoOf(AbstractMutableReteClauseCollection).addAll = function (clauses) {
+    return this.t1i(clauses);
+  };
+  protoOf(AbstractMutableReteClauseCollection).u1i = function (clause) {
+    var retracted = this.e1i_1.v1i(clause);
+    return none(retracted) ? new Failure(this.s1i()) : new Success(this.s1i(), toList(retracted));
+  };
+  protoOf(AbstractMutableReteClauseCollection).retrieve = function (clause) {
+    return this.u1i(clause);
+  };
+  protoOf(AbstractMutableReteClauseCollection).w1i = function (clause) {
+    var retracted = this.e1i_1.x1i(clause);
+    return none(retracted) ? new Failure(this.s1i()) : new Success(this.s1i(), toList(retracted));
+  };
+  protoOf(AbstractMutableReteClauseCollection).retrieveAll = function (clause) {
+    return this.w1i(clause);
+  };
+  function AbstractReteClauseCollection(rete) {
+    AbstractClauseCollection.call(this, rete);
+  }
+  protoOf(AbstractReteClauseCollection).q1i = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.e1i_1.a1j();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.add.<anonymous>' call
+    tmp0_apply.r1i(TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = tmp0_apply;
+    return this.z1i(tmp$ret$0);
+  };
+  protoOf(AbstractReteClauseCollection).add = function (clause) {
+    return this.q1i(clause);
+  };
+  protoOf(AbstractReteClauseCollection).t1i = function (clauses) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.e1i_1.a1j();
+    // 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.n();
+      // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.addAll.<anonymous>.<anonymous>' call
+      tmp0_apply.r1i(TheoryUtils_getInstance().b1j(element));
+    }
+    tmp$ret$0 = tmp0_apply;
+    return this.z1i(tmp$ret$0);
+  };
+  protoOf(AbstractReteClauseCollection).addAll = function (clauses) {
+    return this.t1i(clauses);
+  };
+  protoOf(AbstractReteClauseCollection).u1i = function (clause) {
+    var newTheory = this.e1i_1.a1j();
+    var retracted = newTheory.v1i(clause);
+    return none(retracted) ? new Failure(this.s1i()) : new Success(this.z1i(newTheory), toList(retracted));
+  };
+  protoOf(AbstractReteClauseCollection).retrieve = function (clause) {
+    return this.u1i(clause);
+  };
+  protoOf(AbstractReteClauseCollection).w1i = function (clause) {
+    var newTheory = this.e1i_1.a1j();
+    var retracted = newTheory.x1i(clause);
+    return none(retracted) ? new Failure(this.s1i()) : new Success(this.z1i(newTheory), toList(retracted));
+  };
+  protoOf(AbstractReteClauseCollection).retrieveAll = function (clause) {
+    return this.w1i(clause);
+  };
+  function Companion() {
+    Companion_instance = this;
+  }
+  protoOf(Companion).empty = function (unificator) {
+    return this.ofIterable(unificator, emptyList());
+  };
+  protoOf(Companion).of = function (unificator, clause) {
+    return this.ofIterable(unificator, asIterable_0(clause));
+  };
+  protoOf(Companion).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);
+  };
+  protoOf(Companion).ofSequence = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion).ofIterable = function (unificator, clauses) {
+    return ReteClauseQueue_init_$Create$(unificator, clauses);
+  };
+  protoOf(Companion).areEquals = function (queue1, queue2) {
+    return itemWiseEquals(queue1, queue2);
+  };
+  protoOf(Companion).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() {
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+  }
+  protoOf(Companion_0).empty = function (unificator) {
+    return this.ofIterable(unificator, emptyList());
+  };
+  protoOf(Companion_0).of = function (unificator, clause) {
+    return this.ofIterable(unificator, asIterable_0(clause));
+  };
+  protoOf(Companion_0).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);
+  };
+  protoOf(Companion_0).ofSequence = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_0).ofIterable = function (unificator, clauses) {
+    return MutableReteClauseQueue_init_$Create$(unificator, clauses);
+  };
+  protoOf(Companion_0).areEquals = function (queue1, queue2) {
+    return Companion_getInstance_7().areEquals(queue1, queue2);
+  };
+  protoOf(Companion_0).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() {
+  }
+  function Success(collection, clauses) {
+    RetrieveResult.call(this);
+    this.f1j_1 = collection;
+    this.g1j_1 = clauses;
+  }
+  protoOf(Success).h1j = function () {
+    return this.f1j_1;
+  };
+  protoOf(Success).o1i = function () {
+    return this.g1j_1;
+  };
+  protoOf(Success).az = function () {
+    return true;
+  };
+  protoOf(Success).i1j = function () {
+    return first(this.g1j_1);
+  };
+  protoOf(Success).toString = function () {
+    return 'Success(collection=' + this.f1j_1 + ', clauses=' + this.g1j_1 + ')';
+  };
+  protoOf(Success).hashCode = function () {
+    var result = hashCode(this.f1j_1);
+    result = imul(result, 31) + hashCode(this.g1j_1) | 0;
+    return result;
+  };
+  protoOf(Success).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.f1j_1, tmp0_other_with_cast.f1j_1))
+      return false;
+    if (!equals(this.g1j_1, tmp0_other_with_cast.g1j_1))
+      return false;
+    return true;
+  };
+  function Failure(collection) {
+    RetrieveResult.call(this);
+    this.k1j_1 = collection;
+  }
+  protoOf(Failure).h1j = function () {
+    return this.k1j_1;
+  };
+  protoOf(Failure).j1j = function () {
+    return true;
+  };
+  protoOf(Failure).o1i = function () {
+    return null;
+  };
+  protoOf(Failure).i1j = function () {
+    return null;
+  };
+  protoOf(Failure).toString = function () {
+    return 'Failure(collection=' + this.k1j_1 + ')';
+  };
+  protoOf(Failure).hashCode = function () {
+    return hashCode(this.k1j_1);
+  };
+  protoOf(Failure).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.k1j_1, tmp0_other_with_cast.k1j_1))
+      return false;
+    return true;
+  };
+  function RetrieveResult() {
+  }
+  protoOf(RetrieveResult).az = function () {
+    return false;
+  };
+  protoOf(RetrieveResult).j1j = function () {
+    return false;
+  };
+  defineProp(protoOf(RetrieveResult), 'collection', function () {
+    return this.h1j();
+  });
+  defineProp(protoOf(RetrieveResult), 'clauses', function () {
+    return this.o1i();
+  });
+  defineProp(protoOf(RetrieveResult), 'firstClause', function () {
+    return this.i1j();
+  });
+  function MutableReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    MutableReteClauseQueue.call($this, Companion_getInstance_9().l1j(unificator, clauses));
+    TheoryUtils_getInstance().m1j(clauses);
+    return $this;
+  }
+  function MutableReteClauseQueue_init_$Create$(unificator, clauses) {
+    return MutableReteClauseQueue_init_$Init$(unificator, clauses, objectCreate(protoOf(MutableReteClauseQueue)));
+  }
+  function MutableReteClauseQueue(rete) {
+    AbstractMutableReteClauseCollection.call(this, rete);
+    // Inline function 'kotlin.require' call
+    var tmp0_require = rete.n1j();
+    // 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));
+    }
+  }
+  protoOf(MutableReteClauseQueue).p1j = function (clause) {
+    return this.e1i_1.m1i(clause);
+  };
+  protoOf(MutableReteClauseQueue).getFifoOrdered = function (clause) {
+    return this.p1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).q1j = function (clause) {
+    return asSequence(asReversed(toList(this.p1j(clause))));
+  };
+  protoOf(MutableReteClauseQueue).getLifoOrdered = function (clause) {
+    return this.q1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).c1j = function (clause) {
+    this.e1i_1.r1j(clause);
+    return this;
+  };
+  protoOf(MutableReteClauseQueue).addFirst = function (clause) {
+    return this.c1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).d1j = function (clause) {
+    this.e1i_1.r1i(clause);
+    return this;
+  };
+  protoOf(MutableReteClauseQueue).addLast = function (clause) {
+    return this.d1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).e1j = function (clause) {
+    var retracted = this.e1i_1.v1i(clause);
+    return none(retracted) ? new Failure(this) : new Success(this, toList(retracted));
+  };
+  protoOf(MutableReteClauseQueue).retrieveFirst = function (clause) {
+    return this.e1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, MutableClauseQueue) : false) {
+      tmp = Companion_getInstance_8().areEquals(this, other);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(MutableReteClauseQueue).hashCode = function () {
+    return Companion_getInstance_8().computeHashCode(this);
+  };
+  protoOf(MutableReteClauseQueue).s1i = 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.t1j_1.p2();
+    return tmp$ret$0;
+  }
+  function ReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    ReteClauseQueue.call($this, Companion_getInstance_9().l1j(unificator, clauses));
+    TheoryUtils_getInstance().m1j(clauses);
+    return $this;
+  }
+  function ReteClauseQueue_init_$Create$(unificator, clauses) {
+    return ReteClauseQueue_init_$Init$(unificator, clauses, objectCreate(protoOf(ReteClauseQueue)));
+  }
+  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.t1j_1 = lazy(ReteClauseQueue$hashCodeCache$delegate$lambda(this));
+    // Inline function 'kotlin.require' call
+    var tmp0_require = rete.n1j();
+    // 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));
+    }
+  }
+  protoOf(ReteClauseQueue).c1j = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.e1i_1.a1j();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.impl.ReteClauseQueue.addFirst.<anonymous>' call
+    tmp0_apply.r1j(TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = tmp0_apply;
+    return new ReteClauseQueue(tmp$ret$0);
+  };
+  protoOf(ReteClauseQueue).addFirst = function (clause) {
+    return this.c1j(clause);
+  };
+  protoOf(ReteClauseQueue).d1j = function (clause) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.apply' call
+    var tmp0_apply = this.e1i_1.a1j();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.impl.ReteClauseQueue.addLast.<anonymous>' call
+    tmp0_apply.r1i(TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = tmp0_apply;
+    return new ReteClauseQueue(tmp$ret$0);
+  };
+  protoOf(ReteClauseQueue).addLast = function (clause) {
+    return this.d1j(clause);
+  };
+  protoOf(ReteClauseQueue).p1j = function (clause) {
+    return this.e1i_1.m1i(clause);
+  };
+  protoOf(ReteClauseQueue).getFifoOrdered = function (clause) {
+    return this.p1j(clause);
+  };
+  protoOf(ReteClauseQueue).q1j = function (clause) {
+    return asSequence(asReversed(toList(this.p1j(clause))));
+  };
+  protoOf(ReteClauseQueue).getLifoOrdered = function (clause) {
+    return this.q1j(clause);
+  };
+  protoOf(ReteClauseQueue).q1i = function (clause) {
+    return this.d1j(clause);
+  };
+  protoOf(ReteClauseQueue).add = function (clause) {
+    return this.q1i(clause);
+  };
+  protoOf(ReteClauseQueue).u1i = function (clause) {
+    return protoOf(AbstractReteClauseCollection).u1i.call(this, clause);
+  };
+  protoOf(ReteClauseQueue).retrieve = function (clause) {
+    return this.u1i(clause);
+  };
+  protoOf(ReteClauseQueue).e1j = function (clause) {
+    return protoOf(AbstractReteClauseCollection).u1i.call(this, clause);
+  };
+  protoOf(ReteClauseQueue).retrieveFirst = function (clause) {
+    return this.e1j(clause);
+  };
+  protoOf(ReteClauseQueue).z1i = function (rete) {
+    return new ReteClauseQueue(rete);
+  };
+  protoOf(ReteClauseQueue).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;
+  };
+  protoOf(ReteClauseQueue).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q(this);
+  };
+  protoOf(ReteClauseQueue).s1i = 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.c1k_1 = $source;
+    this.d1k_1 = this$0;
+    this.e1k_1 = $clause;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(AbstractReteNode$removeAllLazily$slambda).rp = function ($this$sequence, $completion) {
+    var tmp = this.sp($this$sequence, $completion);
+    tmp.og_1 = Unit_getInstance();
+    tmp.pg_1 = null;
+    return tmp.ug();
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).gh = function (p1, $completion) {
+    return this.rp(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).ug = function () {
+    var suspendResult = this.og_1;
+    $sm: do
+      try {
+        var tmp = this.mg_1;
+        switch (tmp) {
+          case 0:
+            this.ng_1 = 5;
+            this.g1k_1 = this.c1k_1.j();
+            this.mg_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.g1k_1.m()) {
+              this.mg_1 = 4;
+              continue $sm;
+            }
+
+            this.h1k_1 = this.g1k_1.n();
+            if (this.d1k_1.f1i().match(this.h1k_1.k1k(), this.e1k_1)) {
+              this.h1k_1.i1k();
+              this.g1k_1.v4();
+              this.mg_1 = 2;
+              suspendResult = this.f1k_1.a5(this.h1k_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.mg_1 = 3;
+              continue $sm;
+            }
+
+            break;
+          case 2:
+            this.mg_1 = 3;
+            continue $sm;
+          case 3:
+            this.mg_1 = 1;
+            continue $sm;
+          case 4:
+            return Unit_getInstance();
+          case 5:
+            throw this.pg_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.ng_1 === 5) {
+          throw e;
+        } else {
+          this.mg_1 = this.ng_1;
+          this.pg_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).sp = function ($this$sequence, completion) {
+    var i = new AbstractReteNode$removeAllLazily$slambda(this.c1k_1, this.d1k_1, this.e1k_1, completion);
+    i.f1k_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, $completion) {
+      return i.rp($this$sequence, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function AbstractReteNode(unificator) {
+    this.j1k_1 = unificator;
+  }
+  protoOf(AbstractReteNode).f1i = function () {
+    return this.j1k_1;
+  };
+  protoOf(AbstractReteNode).l1k = function (source, clause) {
+    return sequence(AbstractReteNode$removeAllLazily$slambda_0(source, this, clause, null));
+  };
+  function Companion_1() {
+    Companion_instance_1 = this;
+  }
+  protoOf(Companion_1).l1j = 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.x1k_1 = $this_firstArguments;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(Utils$firstArguments$slambda).a1l = function ($this$sequence, $completion) {
+    var tmp = this.b1l($this$sequence, $completion);
+    tmp.og_1 = Unit_getInstance();
+    tmp.pg_1 = null;
+    return tmp.ug();
+  };
+  protoOf(Utils$firstArguments$slambda).gh = function (p1, $completion) {
+    return this.a1l(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(Utils$firstArguments$slambda).ug = function () {
+    var suspendResult = this.og_1;
+    $sm: do
+      try {
+        var tmp = this.mg_1;
+        switch (tmp) {
+          case 0:
+            this.ng_1 = 5;
+            this.z1k_1 = this.x1k_1;
+            this.mg_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.z1k_1.oy()) {
+              this.mg_1 = 3;
+              continue $sm;
+            }
+
+            this.mg_1 = 2;
+            suspendResult = this.y1k_1.a5(this.z1k_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.z1k_1 = this.z1k_1.castToStruct().getArgAt(0);
+            this.mg_1 = 1;
+            continue $sm;
+          case 3:
+            this.mg_1 = 4;
+            suspendResult = this.y1k_1.a5(this.z1k_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 4:
+            return Unit_getInstance();
+          case 5:
+            throw this.pg_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.ng_1 === 5) {
+          throw e;
+        } else {
+          this.mg_1 = this.ng_1;
+          this.pg_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(Utils$firstArguments$slambda).b1l = function ($this$sequence, completion) {
+    var i = new Utils$firstArguments$slambda(this.x1k_1, completion);
+    i.y1k_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, $completion) {
+      return i.a1l($this$sequence, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function SituatedIndexedClause$compareTo$ref() {
+    var l = function (p0, p1) {
+      return p0.br(p1);
+    };
+    l.callableName = 'compareTo';
+    return l;
+  }
+  function Utils() {
+    Utils_instance = this;
+  }
+  protoOf(Utils).c1l = 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().lt();
+    tmp$ret$1 = tmp$ret$0;
+    return tmp$ret$1;
+  };
+  protoOf(Utils).d1l = 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().rt();
+    tmp$ret$1 = tmp$ret$0;
+    return tmp$ret$1;
+  };
+  protoOf(Utils).e1l = function (_this__u8e3s4, nestingLevel) {
+    return takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel);
+  };
+  protoOf(Utils).f1l = function (args) {
+    return this.g1l(listOf(args.slice()));
+  };
+  protoOf(Utils).h1l = function (sequence) {
+    return this.g1l(asIterable(sequence));
+  };
+  protoOf(Utils).g1l = function (iterable) {
+    return mergeSequences(iterable, SituatedIndexedClause$compareTo$ref());
+  };
+  protoOf(Utils).i1l = function (args) {
+    return this.j1l(sequenceOf(args.slice()));
+  };
+  protoOf(Utils).j1l = function (sequence) {
+    return flatten(sequence);
+  };
+  protoOf(Utils).k1l = function (iterable) {
+    return this.j1l(asSequence(iterable));
+  };
+  protoOf(Utils).l1l = function (args) {
+    return this.m1l(sequenceOf(args.slice()));
+  };
+  protoOf(Utils).m1l = function (sequence) {
+    return flatten(sequence);
+  };
+  protoOf(Utils).n1l = function (a, b) {
+    return (a == null ? b == null : false) ? null : a == null ? b : b == null ? a : a.br(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.p1l_1 = $indexedClause;
+    this.o1l_1 = listOf($traversed.slice());
+  }
+  protoOf(IndexedClause$Companion$wrap$1).bp = function () {
+    return this.p1l_1.bp();
+  };
+  protoOf(IndexedClause$Companion$wrap$1).p2 = function () {
+    return this.p1l_1.p2();
+  };
+  protoOf(IndexedClause$Companion$wrap$1).q1l = function () {
+    return this.o1l_1;
+  };
+  protoOf(IndexedClause$Companion$wrap$1).i1k = function () {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_forEach = this.o1l_1;
+    var tmp0_iterator = tmp0_forEach.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.clause.<no name provided>.invalidateAllCaches.<anonymous>' call
+      element.o1k();
+    }
+  };
+  protoOf(IndexedClause$Companion$wrap$1).gf = function (other) {
+    return this.br((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_2() {
+    Companion_instance_2 = this;
+  }
+  protoOf(Companion_2).s1l = function (indexedClause, traversed) {
+    return new IndexedClause$Companion$wrap$1(traversed, indexedClause);
+  };
+  protoOf(Companion_2).t1l = function (index, clause, traversed) {
+    return this.s1l(Companion_getInstance_0().ar(index, clause), traversed.slice());
+  };
+  protoOf(Companion_2).u1l = function (index, clause, traversed) {
+    var tmp = Companion_getInstance_0().ar(index, clause);
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.toTypedArray' call
+    tmp$ret$0 = copyToArray(traversed);
+    return this.s1l(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.v1l_1 = $indexed;
+    this.w1l_1 = $index;
+  }
+  protoOf(SituatedIndexedClause$Companion$of$1).bp = function () {
+    return this.v1l_1.bp();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).p2 = function () {
+    return this.v1l_1.p2();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).x1l = function () {
+    this.w1l_1.y1l(this);
+    this.i1k();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).q1l = function () {
+    return this.v1l_1.q1l();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).i1k = function () {
+    this.v1l_1.i1k();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(!(other == null) ? isInterface(other, SituatedIndexedClause) : false))
+      return false;
+    if (!this.bp().equals(other.bp()))
+      return false;
+    return true;
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).gf = function (other) {
+    return this.br((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_3() {
+    Companion_instance_3 = this;
+  }
+  protoOf(Companion_3).z1l = 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);
+  }
+  protoOf(AbstractIndexingLeaf).o1k = function () {
+  };
+  function extractFirst($this, clause) {
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.mapNotNull' call
+    var tmp1_mapNotNull = $this.j1m_1.f3();
+    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 = tmp1_mapNotNull.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      // 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.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.extractFirst.<anonymous>' call
+        tmp$ret$0 = $this.f1i().match(item.k1k(), 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.o(actualIndex);
+    }
+    return tmp;
+  }
+  function nestedFirstArgument(_this__u8e3s4, $this) {
+    return Utils_getInstance().e1l(ensureNotNull(_this__u8e3s4.lv()), $this.i1m_1 + 1 | 0);
+  }
+  function asInnerAtom(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4, $this).castToAtom();
+  }
+  function asInnerAtom_0(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4.k1k(), $this).castToAtom();
+  }
+  function asInnerAtom_1(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4.k1k(), $this).castToAtom();
+  }
+  function AtomIndex$_get_size_$lambda_ygjfwe(it) {
+    return it.p();
+  }
+  function AtomIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function AtomIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.l1k(it, $clause);
+    };
+  }
+  function AtomIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function AtomIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function AtomIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.h1m_1 = ordered;
+    this.i1m_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.j1m_1 = tmp$ret$0;
+  }
+  protoOf(AtomIndex).p = function () {
+    var tmp = asSequence(this.j1m_1.f3());
+    return sum(map(tmp, AtomIndex$_get_size_$lambda_ygjfwe));
+  };
+  protoOf(AtomIndex).j1i = function () {
+    var tmp;
+    if (this.j1m_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.j1m_1.f3();
+        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.n();
+          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;
+  };
+  protoOf(AtomIndex).m1k = function (clause) {
+    if (this.h1m_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.j1m_1;
+      var value = tmp0_getOrPut.d3(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.h4(tmp0_let, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      tmp$ret$1 = tmp;
+      addFirst(tmp$ret$1, Companion_getInstance_11().z1l(clause.r1l(this), this));
+      tmp$ret$2 = Unit_getInstance();
+    } else {
+      this.n1k(clause);
+    }
+  };
+  protoOf(AtomIndex).n1k = 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.j1m_1;
+    var value = tmp0_getOrPut.d3(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.h4(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$2 = tmp$ret$1.g(Companion_getInstance_11().z1l(clause.r1l(this), this));
+    tmp$ret$3 = tmp$ret$2;
+  };
+  protoOf(AtomIndex).b1m = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).mt()) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = this.j1m_1.d3(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;
+  };
+  protoOf(AtomIndex).c1m = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).mt()) {
+      var tmp0_safe_receiver = this.j1m_1.d3(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.e1m(clause);
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).y1l = function (indexed) {
+    ensureNotNull(this.j1m_1.d3(asInnerAtom_0(indexed, this))).ba(indexed);
+  };
+  protoOf(AtomIndex).d1m = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).mt()) {
+      var partialIndex = this.j1m_1.d3(asInnerAtom(clause, this));
+      tmp = partialIndex == null ? emptySequence() : this.l1k(partialIndex, clause);
+    } else {
+      var tmp_0 = Utils_getInstance();
+      var tmp_1 = asSequence(this.j1m_1.f3());
+      tmp = tmp_0.h1l(map(tmp_1, AtomIndex$retractAllIndexed$lambda(this, clause)));
+    }
+    return buffered(tmp);
+  };
+  protoOf(AtomIndex).f1m = function () {
+    var tmp = Utils_getInstance();
+    var tmp_0 = asSequence(this.j1m_1.f3());
+    return tmp.h1l(map(tmp_0, AtomIndex$getCache$lambda));
+  };
+  protoOf(AtomIndex).e1m = function (clause) {
+    var tmp = this.f1m();
+    return filter(tmp, AtomIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function nestedFunctor(_this__u8e3s4, $this) {
+    return Utils_getInstance().d1l(ensureNotNull(_this__u8e3s4.lv()), $this.m1m_1);
+  }
+  function nestedFunctor_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().d1l(ensureNotNull(_this__u8e3s4.k1k().lv()), $this.m1m_1);
+  }
+  function isGlobal(_this__u8e3s4, $this) {
+    return Utils_getInstance().e1l(ensureNotNull(_this__u8e3s4.lv()), $this.m1m_1).fu();
+  }
+  function regenerateCache($this) {
+    var tmp;
+    if ($this.l1m_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.n1m_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.f1m();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp3_map = $this.n1m_1.f3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+      var tmp0_iterator_0 = tmp3_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.f1m();
+        tmp2_mapTo.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp2_mapTo;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.k1l(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.p();
+  }
+  function CompoundIndex(unificator, ordered, nestingLevel) {
+    AbstractReteNode.call(this, unificator);
+    this.l1m_1 = ordered;
+    this.m1m_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.n1m_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.o1m_1 = tmp_1.no(CompoundIndex$regenerateCache$ref(this));
+  }
+  protoOf(CompoundIndex).p = function () {
+    var tmp = asSequence(this.n1m_1.f3());
+    return sum(map(tmp, CompoundIndex$_get_size_$lambda_91vt0k));
+  };
+  protoOf(CompoundIndex).j1i = function () {
+    var tmp;
+    if (this.n1m_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.n1m_1.f3();
+        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.n();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.j1i();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).m1k = 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.l1m_1) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = this.n1m_1;
+      var value = tmp0_getOrPut.d3(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.f1i(), this.l1m_1, this.m1m_1);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.h4(tmp0_let, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp$ret$1 = tmp_0;
+      tmp$ret$1.m1k(clause.r1l(this));
+      tmp = Unit_getInstance();
+    } else {
+      this.n1k(clause);
+      tmp = Unit_getInstance();
+    }
+    tmp$ret$2 = tmp;
+    return tmp$ret$2;
+  };
+  protoOf(CompoundIndex).n1k = 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.n1m_1;
+    var value = tmp0_getOrPut.d3(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.f1i(), this.l1m_1, this.m1m_1);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.h4(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.n1k(clause.r1l(this));
+    tmp$ret$2 = Unit_getInstance();
+    return tmp$ret$2;
+  };
+  protoOf(CompoundIndex).f1m = function () {
+    return asSequence(this.o1m_1.p2());
+  };
+  protoOf(CompoundIndex).b1m = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$3;
+      // Inline function 'kotlin.collections.mapNotNull' call
+      var tmp1_mapNotNull = this.n1m_1.f3();
+      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 = tmp1_mapNotNull.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.n();
+        // 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.b1m(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.h1l(sequenceOf([asSequence(tmp$ret$3)])));
+    } else {
+      var tmp0_safe_receiver_0 = this.n1m_1.d3(nestedFunctor(clause, this));
+      tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.b1m(clause);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).c1m = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = this.n1m_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.getIndexed.<anonymous>' call
+        tmp$ret$0 = item.e1m(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp0_safe_receiver = this.n1m_1.d3(nestedFunctor(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1m(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).d1m = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = this.n1m_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.retractAllIndexed.<anonymous>' call
+        tmp$ret$0 = item.d1m(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp0_safe_receiver = this.n1m_1.d3(nestedFunctor(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.d1m(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).e1m = function (clause) {
+    var tmp;
+    if (this.l1m_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = this.n1m_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$0 = item.e1m(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp3_map = this.n1m_1.f3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+      var tmp0_iterator_0 = tmp3_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$3 = item_0.e1m(clause);
+        tmp2_mapTo.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp2_mapTo;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.k1l(tmp$ret$5);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).o1k = function () {
+    this.o1m_1.po();
+  };
+  function DirectiveIndex$retractFirst$lambda(it) {
+    return it.k1k();
+  }
+  function DirectiveIndex$retractAll$lambda(it) {
+    return it.k1k();
+  }
+  function DirectiveIndex$getCache$lambda(it) {
+    var tmp = Companion_getInstance_11();
+    return tmp.z1l(it, new DirectiveIndex$getCache$1$1());
+  }
+  function DirectiveIndex$getCache$1$1() {
+  }
+  protoOf(DirectiveIndex$getCache$1$1).y1l = 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.q1m_1 = ordered;
+    this.r1m_1 = dequeOf([]);
+  }
+  protoOf(DirectiveIndex).p = function () {
+    return this.r1m_1.p();
+  };
+  protoOf(DirectiveIndex).j1i = function () {
+    return this.r1m_1.d();
+  };
+  protoOf(DirectiveIndex).m1i = function (clause) {
+    var tmp$ret$5;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp1_filter = this.r1m_1;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp1_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.DirectiveIndex.get.<anonymous>' call
+      tmp$ret$0 = this.f1i().match(element.k1k(), clause);
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    var tmp3_map = tmp$ret$2;
+    var tmp$ret$4;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+    var tmp0_iterator_0 = tmp3_map.j();
+    while (tmp0_iterator_0.m()) {
+      var item = tmp0_iterator_0.n();
+      var tmp$ret$3;
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.DirectiveIndex.get.<anonymous>' call
+      tmp$ret$3 = item.k1k();
+      tmp2_mapTo.g(tmp$ret$3);
+    }
+    tmp$ret$4 = tmp2_mapTo;
+    tmp$ret$5 = tmp$ret$4;
+    return asSequence(tmp$ret$5);
+  };
+  protoOf(DirectiveIndex).m1k = function (clause) {
+    if (this.q1m_1) {
+      addFirst(this.r1m_1, clause.r1l(this));
+    } else {
+      this.n1k(clause);
+    }
+  };
+  protoOf(DirectiveIndex).n1k = function (clause) {
+    this.r1m_1.g(clause.r1l(this));
+  };
+  protoOf(DirectiveIndex).v1i = function (clause) {
+    var tmp = this.l1k(this.r1m_1, clause);
+    return buffered(take(map(tmp, DirectiveIndex$retractFirst$lambda), 1));
+  };
+  protoOf(DirectiveIndex).x1i = function (clause) {
+    var tmp = this.l1k(this.r1m_1, clause);
+    return buffered(map(tmp, DirectiveIndex$retractAll$lambda));
+  };
+  protoOf(DirectiveIndex).f1m = function () {
+    var tmp = asSequence(this.r1m_1);
+    return map(tmp, DirectiveIndex$getCache$lambda);
+  };
+  protoOf(DirectiveIndex).o1k = function () {
+  };
+  function extractFirst_1($this, clause) {
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.mapNotNull' call
+    var tmp1_mapNotNull = $this.v1m_1.f3();
+    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 = tmp1_mapNotNull.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      // 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.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.extractFirst.<anonymous>' call
+        tmp$ret$0 = $this.f1i().match(item.k1k(), 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.o(actualIndex);
+    }
+    return tmp;
+  }
+  function nestedFirstArgument_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().e1l(ensureNotNull(_this__u8e3s4.lv()), $this.u1m_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.k1k(), $this).castToNumeric();
+  }
+  function asInnerNumeric_1(_this__u8e3s4, $this) {
+    return nestedFirstArgument_0(_this__u8e3s4.k1k(), $this).castToNumeric();
+  }
+  function NumericIndex$_get_size_$lambda_exo30i(it) {
+    return it.p();
+  }
+  function NumericIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function NumericIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.l1k(it, $clause);
+    };
+  }
+  function NumericIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function NumericIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function NumericIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.t1m_1 = ordered;
+    this.u1m_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.v1m_1 = tmp$ret$0;
+  }
+  protoOf(NumericIndex).p = function () {
+    var tmp = asSequence(this.v1m_1.f3());
+    return sum(map(tmp, NumericIndex$_get_size_$lambda_exo30i));
+  };
+  protoOf(NumericIndex).j1i = function () {
+    var tmp;
+    if (this.v1m_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.v1m_1.f3();
+        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.n();
+          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;
+  };
+  protoOf(NumericIndex).m1k = function (clause) {
+    if (this.t1m_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.v1m_1;
+      var value = tmp0_getOrPut.d3(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.h4(tmp0_let, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      tmp$ret$1 = tmp;
+      addFirst(tmp$ret$1, Companion_getInstance_11().z1l(clause.r1l(this), this));
+      tmp$ret$2 = Unit_getInstance();
+    } else {
+      this.n1k(clause);
+    }
+  };
+  protoOf(NumericIndex).n1k = 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.v1m_1;
+    var value = tmp0_getOrPut.d3(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.h4(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$2 = tmp$ret$1.g(Companion_getInstance_11().z1l(clause.r1l(this), this));
+    tmp$ret$3 = tmp$ret$2;
+  };
+  protoOf(NumericIndex).b1m = function (clause) {
+    if (nestedFirstArgument_0(clause, this).hu()) {
+      var tmp$ret$0;
+      // Inline function 'kotlin.let' call
+      var tmp0_let = this.v1m_1.d3(asInnerNumeric(clause, this));
+      // Inline function 'kotlin.contracts.contract' call
+      var tmp;
+      if (tmp0_let == null) {
+        tmp = null;
+      } else {
+        tmp = extractFirst_2(this, clause, tmp0_let);
+      }
+      return tmp;
+    } else {
+      return extractFirst_1(this, clause);
+    }
+  };
+  protoOf(NumericIndex).c1m = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(clause, this).hu()) {
+      var tmp0_safe_receiver = this.v1m_1.d3(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.e1m(clause);
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).y1l = function (indexed) {
+    ensureNotNull(this.v1m_1.d3(asInnerNumeric_0(indexed, this))).ba(indexed);
+  };
+  protoOf(NumericIndex).d1m = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(clause, this).hu()) {
+      var partialIndex = this.v1m_1.d3(asInnerNumeric(clause, this));
+      tmp = partialIndex == null ? emptySequence() : buffered(this.l1k(partialIndex, clause));
+    } else {
+      var tmp_0 = Utils_getInstance();
+      var tmp_1 = asSequence(this.v1m_1.f3());
+      tmp = buffered(tmp_0.h1l(map(tmp_1, NumericIndex$retractAllIndexed$lambda(this, clause))));
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).f1m = function () {
+    var tmp = Utils_getInstance();
+    var tmp_0 = asSequence(this.v1m_1.f3());
+    return tmp.h1l(map(tmp_0, NumericIndex$getCache$lambda));
+  };
+  protoOf(NumericIndex).e1m = function (clause) {
+    var tmp = this.f1m();
+    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.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.VariableIndex.extractFirst.<anonymous>' call
+        tmp$ret$0 = $this.f1i().match(item.k1k(), 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.o(actualIndex);
+    }
+    return tmp;
+  }
+  function VariableIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function VariableIndex(unificator, ordered) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.x1m_1 = ordered;
+    this.y1m_1 = dequeOf([]);
+  }
+  protoOf(VariableIndex).p = function () {
+    return this.y1m_1.p();
+  };
+  protoOf(VariableIndex).j1i = function () {
+    return this.y1m_1.d();
+  };
+  protoOf(VariableIndex).m1k = function (clause) {
+    var tmp;
+    if (this.x1m_1) {
+      addFirst(this.y1m_1, Companion_getInstance_11().z1l(clause.r1l(this), this));
+      tmp = Unit_getInstance();
+    } else {
+      this.n1k(clause);
+      tmp = Unit_getInstance();
+    }
+    return tmp;
+  };
+  protoOf(VariableIndex).n1k = function (clause) {
+    this.y1m_1.g(Companion_getInstance_11().z1l(clause.r1l(this), this));
+  };
+  protoOf(VariableIndex).f1m = function () {
+    return asSequence(this.y1m_1);
+  };
+  protoOf(VariableIndex).b1m = function (clause) {
+    return extractFirst_3(this, clause, this.y1m_1);
+  };
+  protoOf(VariableIndex).c1m = function (clause) {
+    return this.e1m(clause);
+  };
+  protoOf(VariableIndex).y1l = function (indexed) {
+    this.y1m_1.ba(indexed);
+  };
+  protoOf(VariableIndex).d1m = function (clause) {
+    return buffered(this.l1k(this.y1m_1, clause));
+  };
+  protoOf(VariableIndex).e1m = function (clause) {
+    var tmp = asSequence(this.y1m_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.h1n_1 = ordered;
+  }
+  protoOf(FamilyArityIndexingNode).b1m = function (clause) {
+    var tmp;
+    if (this.h1n_1) {
+      tmp = this.r1n(clause);
+    } else {
+      tmp = this.q1n(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).c1m = function (clause) {
+    var tmp;
+    if (this.h1n_1) {
+      tmp = this.t1n(clause);
+    } else {
+      tmp = this.s1n(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).d1m = function (clause) {
+    var tmp;
+    if (this.h1n_1) {
+      tmp = this.v1n(clause);
+    } else {
+      tmp = this.u1n(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).e1m = function (clause) {
+    var tmp;
+    if (this.h1n_1) {
+      tmp = Utils_getInstance().f1l([this.m1n_1.e1m(clause), this.l1n_1.e1m(clause), this.n1n_1.e1m(clause), this.o1n_1.e1m(clause)]);
+    } else {
+      tmp = Utils_getInstance().i1l([this.m1n_1.e1m(clause), this.l1n_1.e1m(clause), this.n1n_1.e1m(clause), this.o1n_1.e1m(clause)]);
+    }
+    return tmp;
+  };
+  function retractAllOrdered($this, clause) {
+    var tmp = $this.v1n(clause);
+    return map(tmp, FamilyArityReteNode$retractAllOrdered$lambda);
+  }
+  function getOrdered($this, clause) {
+    var tmp = $this.t1n(clause);
+    return map(tmp, FamilyArityReteNode$getOrdered$lambda);
+  }
+  function retractAllUnordered($this, clause) {
+    var tmp = $this.u1n(clause);
+    return map(tmp, FamilyArityReteNode$retractAllUnordered$lambda);
+  }
+  function getUnordered($this, clause) {
+    var tmp = $this.s1n(clause);
+    return map(tmp, FamilyArityReteNode$getUnordered$lambda);
+  }
+  function regenerateCache_0($this) {
+    var tmp;
+    if ($this.j1n_1) {
+      tmp = Utils_getInstance().f1l([$this.m1n_1.f1m(), $this.l1n_1.f1m(), $this.n1n_1.f1m(), $this.o1n_1.f1m()]);
+    } else {
+      tmp = Utils_getInstance().i1l([$this.m1n_1.f1m(), $this.l1n_1.f1m(), $this.n1n_1.f1m(), $this.o1n_1.f1m()]);
+    }
+    return dequeOf_0(tmp);
+  }
+  function nestedFirstArgument_1(_this__u8e3s4, $this) {
+    return Utils_getInstance().e1l(ensureNotNull(_this__u8e3s4.lv()), $this.k1n_1 + 1 | 0);
+  }
+  function assertByFirstParameter($this, clause) {
+    var innerFirst = nestedFirstArgument_1(clause.k1k(), $this);
+    return innerFirst.hu() ? $this.l1n_1 : innerFirst.mt() ? $this.m1n_1 : innerFirst.fu() ? $this.n1n_1 : $this.o1n_1;
+  }
+  function isGlobal_0(_this__u8e3s4, $this) {
+    return Utils_getInstance().e1l(ensureNotNull(_this__u8e3s4.lv()), $this.k1n_1 + 1 | 0).fu();
+  }
+  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.p();
+  }
+  function FamilyArityReteNode$get$lambda(it) {
+    return it.k1k();
+  }
+  function FamilyArityReteNode$get$lambda_0(it) {
+    return it.k1k();
+  }
+  function FamilyArityReteNode$retractAllOrdered$lambda(it) {
+    return it.k1k();
+  }
+  function FamilyArityReteNode$getOrdered$lambda(it) {
+    return it.k1k();
+  }
+  function FamilyArityReteNode$retractAllUnordered$lambda(it) {
+    return it.k1k();
+  }
+  function FamilyArityReteNode$getUnordered$lambda(it) {
+    return it.k1k();
+  }
+  function FamilyArityReteNode(unificator, ordered, nestingLevel) {
+    ArityNode.call(this, unificator);
+    this.j1n_1 = ordered;
+    this.k1n_1 = nestingLevel;
+    this.l1n_1 = new NumericIndex(unificator, this.j1n_1, this.k1n_1);
+    this.m1n_1 = new AtomIndex(unificator, this.j1n_1, this.k1n_1);
+    this.n1n_1 = new VariableIndex(unificator, this.j1n_1);
+    this.o1n_1 = new CompoundIndex(unificator, this.j1n_1, this.k1n_1 + 1 | 0);
+    var tmp = this;
+    var tmp_0 = Companion_getInstance_1();
+    tmp.p1n_1 = tmp_0.no(FamilyArityReteNode$regenerateCache$ref(this));
+  }
+  protoOf(FamilyArityReteNode).v1i = function (clause) {
+    var tmp;
+    if (this.j1n_1) {
+      tmp = this.r1n(clause);
+    } else {
+      tmp = this.q1n(clause);
+    }
+    var result = tmp;
+    var tmp_0;
+    if (result == null) {
+      tmp_0 = emptySequence();
+    } else {
+      result.x1l();
+      this.o1k();
+      tmp_0 = sequenceOf([result.k1k()]);
+    }
+    return tmp_0;
+  };
+  protoOf(FamilyArityReteNode).p = function () {
+    var tmp = sequenceOf([this.l1n_1, this.m1n_1, this.n1n_1, this.o1n_1]);
+    return sum(map(tmp, FamilyArityReteNode$_get_size_$lambda_sxz8zo));
+  };
+  protoOf(FamilyArityReteNode).j1i = function () {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var tmp0_all = sequenceOf([this.l1n_1, this.m1n_1, this.n1n_1, this.o1n_1]);
+      var tmp0_iterator = tmp0_all.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FamilyArityReteNode.<get-isEmpty>.<anonymous>' call
+        tmp$ret$0 = element.j1i();
+        if (!tmp$ret$0) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    return tmp$ret$1;
+  };
+  protoOf(FamilyArityReteNode).m1i = function (clause) {
+    var tmp;
+    if (isGlobal_0(clause, this)) {
+      var tmp_0;
+      if (this.j1n_1) {
+        var tmp_1 = Utils_getInstance().f1l([this.m1n_1.e1m(clause), this.n1n_1.e1m(clause), this.l1n_1.e1m(clause), this.o1n_1.e1m(clause)]);
+        tmp_0 = map(tmp_1, FamilyArityReteNode$get$lambda);
+      } else {
+        var tmp_2 = Utils_getInstance().i1l([this.m1n_1.e1m(clause), this.n1n_1.e1m(clause), this.l1n_1.e1m(clause), this.o1n_1.e1m(clause)]);
+        tmp_0 = map(tmp_2, FamilyArityReteNode$get$lambda_0);
+      }
+      tmp = tmp_0;
+    } else {
+      var tmp_3;
+      if (this.j1n_1) {
+        tmp_3 = getOrdered(this, clause);
+      } else {
+        tmp_3 = getUnordered(this, clause);
+      }
+      tmp = tmp_3;
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).m1k = function (clause) {
+    return assertByFirstParameter(this, clause).m1k(clause.r1l(this));
+  };
+  protoOf(FamilyArityReteNode).n1k = function (clause) {
+    return assertByFirstParameter(this, clause).n1k(clause.r1l(this));
+  };
+  protoOf(FamilyArityReteNode).x1i = function (clause) {
+    var tmp;
+    if (this.j1n_1) {
+      tmp = retractAllOrdered(this, clause);
+    } else {
+      tmp = retractAllUnordered(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).f1m = function () {
+    return asSequence(this.p1n_1.p2());
+  };
+  protoOf(FamilyArityReteNode).v1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.hu()) {
+      tmp = Utils_getInstance().f1l([this.n1n_1.d1m(clause), this.l1n_1.d1m(clause)]);
+    } else if (innerFirst.mt()) {
+      tmp = Utils_getInstance().f1l([this.n1n_1.d1m(clause), this.m1n_1.d1m(clause)]);
+    } else if (innerFirst.fu()) {
+      tmp = Utils_getInstance().f1l([this.n1n_1.d1m(clause), this.l1n_1.d1m(clause), this.m1n_1.d1m(clause), this.o1n_1.d1m(clause)]);
+    } else {
+      tmp = Utils_getInstance().f1l([this.n1n_1.d1m(clause), this.o1n_1.d1m(clause)]);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).u1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.hu() ? Utils_getInstance().i1l([this.n1n_1.d1m(clause), this.l1n_1.d1m(clause)]) : innerFirst.mt() ? Utils_getInstance().i1l([this.n1n_1.d1m(clause), this.m1n_1.d1m(clause)]) : innerFirst.fu() ? Utils_getInstance().i1l([this.n1n_1.d1m(clause), this.l1n_1.d1m(clause), this.m1n_1.d1m(clause), this.o1n_1.d1m(clause)]) : Utils_getInstance().i1l([this.n1n_1.d1m(clause), this.o1n_1.d1m(clause)]);
+  };
+  protoOf(FamilyArityReteNode).t1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.hu() ? Utils_getInstance().f1l([this.n1n_1.c1m(clause), this.l1n_1.c1m(clause)]) : innerFirst.mt() ? Utils_getInstance().f1l([this.n1n_1.c1m(clause), this.m1n_1.c1m(clause)]) : innerFirst.fu() ? Utils_getInstance().f1l([this.n1n_1.c1m(clause), this.l1n_1.c1m(clause), this.m1n_1.c1m(clause), this.o1n_1.c1m(clause)]) : Utils_getInstance().f1l([this.n1n_1.c1m(clause), this.o1n_1.c1m(clause)]);
+  };
+  protoOf(FamilyArityReteNode).s1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.hu() ? Utils_getInstance().i1l([this.n1n_1.c1m(clause), this.l1n_1.c1m(clause)]) : innerFirst.mt() ? Utils_getInstance().i1l([this.n1n_1.c1m(clause), this.m1n_1.c1m(clause)]) : innerFirst.fu() ? Utils_getInstance().i1l([this.n1n_1.c1m(clause), this.l1n_1.c1m(clause), this.m1n_1.c1m(clause), this.o1n_1.c1m(clause)]) : Utils_getInstance().i1l([this.n1n_1.c1m(clause), this.o1n_1.c1m(clause)]);
+  };
+  protoOf(FamilyArityReteNode).q1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.hu()) {
+      var tmp0_elvis_lhs = this.n1n_1.b1m(clause);
+      tmp = tmp0_elvis_lhs == null ? this.l1n_1.b1m(clause) : tmp0_elvis_lhs;
+    } else if (innerFirst.mt()) {
+      var tmp1_elvis_lhs = this.n1n_1.b1m(clause);
+      tmp = tmp1_elvis_lhs == null ? this.m1n_1.b1m(clause) : tmp1_elvis_lhs;
+    } else if (innerFirst.fu()) {
+      var tmp2_elvis_lhs = this.n1n_1.b1m(clause);
+      var tmp3_elvis_lhs = tmp2_elvis_lhs == null ? this.l1n_1.b1m(clause) : tmp2_elvis_lhs;
+      var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? this.m1n_1.b1m(clause) : tmp3_elvis_lhs;
+      tmp = tmp4_elvis_lhs == null ? this.o1n_1.b1m(clause) : tmp4_elvis_lhs;
+    } else {
+      var tmp5_elvis_lhs = this.n1n_1.b1m(clause);
+      tmp = tmp5_elvis_lhs == null ? this.o1n_1.b1m(clause) : tmp5_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).r1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.hu()) {
+      tmp = Utils_getInstance().n1l(this.l1n_1.b1m(clause), this.n1n_1.b1m(clause));
+    } else if (innerFirst.mt()) {
+      tmp = Utils_getInstance().n1l(this.m1n_1.b1m(clause), this.n1n_1.b1m(clause));
+    } else if (innerFirst.fu()) {
+      tmp = Utils_getInstance().n1l(Utils_getInstance().n1l(this.l1n_1.b1m(clause), this.m1n_1.b1m(clause)), Utils_getInstance().n1l(this.n1n_1.b1m(clause), this.o1n_1.b1m(clause)));
+    } else {
+      tmp = Utils_getInstance().n1l(this.n1n_1.b1m(clause), this.o1n_1.b1m(clause));
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).o1k = function () {
+    this.p1n_1.po();
+  };
+  function isGlobal_1(_this__u8e3s4, $this) {
+    return _this__u8e3s4.wt() ? Utils_getInstance().e1l(_this__u8e3s4.castToRule().lv(), $this.y1n_1).fu() : 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.lv();
+    var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : Utils_getInstance().c1l(tmp1_safe_receiver, $this.y1n_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().c1l(ensureNotNull(_this__u8e3s4.k1k().lv()), $this.y1n_1);
+  }
+  function regenerateCache_1($this) {
+    var tmp;
+    if ($this.x1n_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.z1n_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.f1m();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp3_map = $this.z1n_1.f3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+      var tmp0_iterator_0 = tmp3_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.f1m();
+        tmp2_mapTo.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp2_mapTo;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.k1l(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.p();
+  }
+  function FunctorIndexingNode$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function FunctorIndexingNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.x1n_1 = ordered;
+    this.y1n_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.z1n_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.a1o_1 = tmp_1.no(FunctorIndexingNode$regenerateCache$ref(this));
+  }
+  protoOf(FunctorIndexingNode).p = function () {
+    var tmp = asSequence(this.z1n_1.f3());
+    return sum(map(tmp, FunctorIndexingNode$_get_size_$lambda_vcufvm));
+  };
+  protoOf(FunctorIndexingNode).j1i = function () {
+    var tmp;
+    if (this.z1n_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.z1n_1.f3();
+        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.n();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.j1i();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).m1k = function (clause) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.z1n_1;
+    var tmp1_getOrPut = nestedArity_0(clause, this);
+    var value = tmp0_getOrPut.d3(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.f1i(), this.x1n_1, this.y1n_1);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.h4(tmp1_getOrPut, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.m1k(clause.r1l(this));
+  };
+  protoOf(FunctorIndexingNode).n1k = function (clause) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var tmp0_getOrPut = this.z1n_1;
+    var tmp1_getOrPut = nestedArity_0(clause, this);
+    var value = tmp0_getOrPut.d3(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.f1i(), this.x1n_1, this.y1n_1);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.h4(tmp1_getOrPut, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.n1k(clause.r1l(this));
+  };
+  protoOf(FunctorIndexingNode).f1m = function () {
+    return asSequence(this.a1o_1.p2());
+  };
+  protoOf(FunctorIndexingNode).b1m = 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 tmp1_map = this.z1n_1.f3();
+        var tmp$ret$1;
+        // Inline function 'kotlin.collections.mapTo' call
+        var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+        var tmp0_iterator = tmp1_map.j();
+        while (tmp0_iterator.m()) {
+          var item = tmp0_iterator.n();
+          var tmp$ret$0;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getFirstIndexed.<anonymous>' call
+          tmp$ret$0 = item.e1m(clause);
+          tmp0_mapTo.g(tmp$ret$0);
+        }
+        tmp$ret$1 = tmp0_mapTo;
+        tmp$ret$2 = tmp$ret$1;
+        var tmp2_firstOrNull = tmp_0.g1l(tmp$ret$2);
+        var tmp0_iterator_0 = tmp2_firstOrNull.j();
+        while (tmp0_iterator_0.m()) {
+          var element = tmp0_iterator_0.n();
+          var tmp$ret$3;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getFirstIndexed.<anonymous>' call
+          tmp$ret$3 = this.f1i().match(element.k1k(), 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.z1n_1.d3(nestedArity(clause, this));
+      tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.b1m(clause);
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).c1m = 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 tmp1_map = this.z1n_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getIndexed.<anonymous>' call
+        tmp$ret$0 = item.e1m(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp0_safe_receiver = this.z1n_1.d3(nestedArity(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1m(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).d1m = 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 tmp1_map = this.z1n_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.retractAllIndexed.<anonymous>' call
+        tmp$ret$0 = item.e1m(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      var tmp_1 = tmp_0.g1l(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.o1k();
+        // Inline function 'kotlin.collections.forEach' call
+        var tmp0_iterator_0 = partialResult.j();
+        while (tmp0_iterator_0.m()) {
+          var element = tmp0_iterator_0.n();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.retractAllIndexed.<anonymous>' call
+          element.x1l();
+        }
+      }
+      tmp = asSequence(partialResult);
+    } else {
+      var tmp0_safe_receiver = this.z1n_1.d3(nestedArity(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.d1m(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).e1m = function (clause) {
+    var tmp;
+    if (this.x1n_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = this.z1n_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$0 = item.e1m(clause);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp3_map = this.z1n_1.f3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+      var tmp0_iterator_0 = tmp3_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.extractGlobalIndexedSequence.<anonymous>' call
+        tmp$ret$3 = item_0.e1m(clause);
+        tmp2_mapTo.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp2_mapTo;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.k1l(tmp$ret$5);
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).o1k = function () {
+    this.a1o_1.po();
+  };
+  function FunctorNode(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  function assignHigherIndex($this, clause) {
+    var tmp = Companion_getInstance_10();
+    var tmp0_this = $this;
+    tmp0_this.h1o_1 = tmp0_this.h1o_1.xf();
+    return tmp.t1l(tmp0_this.h1o_1, clause, [$this]);
+  }
+  function assignLowerIndex($this, clause) {
+    var tmp = Companion_getInstance_10();
+    var tmp0_this = $this;
+    tmp0_this.g1o_1 = tmp0_this.g1o_1.yf();
+    return tmp.t1l(tmp0_this.g1o_1, clause, [$this]);
+  }
+  function regenerateCache_2($this) {
+    var tmp;
+    if ($this.c1o_1) {
+      var tmp_0 = Utils_getInstance().f1l([$this.f1o_1.f1m(), $this.e1o_1.f1m()]);
+      tmp = map(tmp_0, RootNode$regenerateCache$lambda);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp_2 = $this.f1o_1.f1m();
+      var tmp_3 = map(tmp_2, RootNode$regenerateCache$lambda_0);
+      var tmp_4 = $this.e1o_1.f1m();
+      tmp = tmp_1.l1l([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.p2().castToDirective();
+  }
+  function RootNode$_get_rules_$lambda_py6utr(it) {
+    return it.p2().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.k1k();
+  }
+  function RootNode$regenerateCache$lambda_0(it) {
+    return it.k1k();
+  }
+  function RootNode$regenerateCache$lambda_1(it) {
+    return it.k1k();
+  }
+  function RootNode(unificator, clauses, isOrdered) {
+    this.b1o_1 = unificator;
+    this.c1o_1 = isOrdered;
+    var tmp = this;
+    var tmp_0 = Companion_getInstance_1();
+    tmp.d1o_1 = tmp_0.no(RootNode$regenerateCache$ref(this));
+    this.e1o_1 = new RuleNode(this.b1o_1, this.c1o_1);
+    this.f1o_1 = new DirectiveIndex(this.b1o_1, this.c1o_1);
+    this.g1o_1 = new Long(0, 0);
+    this.h1o_1 = new Long(0, 0);
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RootNode.<anonymous>' call
+      this.r1i(element);
+    }
+  }
+  protoOf(RootNode).f1i = function () {
+    return this.b1o_1;
+  };
+  protoOf(RootNode).n1j = function () {
+    return this.c1o_1;
+  };
+  protoOf(RootNode).p = function () {
+    return this.f1o_1.p() + this.e1o_1.p() | 0;
+  };
+  protoOf(RootNode).j1i = function () {
+    return this.f1o_1.j1i() ? this.e1o_1.j1i() : false;
+  };
+  protoOf(RootNode).o1i = function () {
+    return asSequence(this.d1o_1.p2());
+  };
+  protoOf(RootNode).h1i = function () {
+    var tmp = this.f1o_1.f1m();
+    return map(tmp, RootNode$_get_directives_$lambda_9lfp1g);
+  };
+  protoOf(RootNode).i1i = function () {
+    var tmp = this.e1o_1.f1m();
+    return map(tmp, RootNode$_get_rules_$lambda_py6utr);
+  };
+  protoOf(RootNode).m1i = function (clause) {
+    var tmp;
+    if (clause.xv()) {
+      tmp = this.f1o_1.m1i(clause);
+    } else {
+      tmp = this.e1o_1.m1i(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).v1i = function (clause) {
+    var tmp;
+    if (clause.xv()) {
+      tmp = this.f1o_1.v1i(clause);
+    } else {
+      tmp = this.e1o_1.v1i(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).x1i = function (clause) {
+    var tmp;
+    if (clause.xv()) {
+      tmp = this.f1o_1.x1i(clause);
+    } else {
+      tmp = this.e1o_1.x1i(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).a1j = function () {
+    return new RootNode(this.b1o_1, asIterable(this.o1i()), this.c1o_1);
+  };
+  protoOf(RootNode).r1j = function (clause) {
+    var indexed = assignLowerIndex(this, clause);
+    if (this.c1o_1) {
+      this.d1o_1.qo(RootNode$assertA$lambda(clause));
+      if (clause.xv()) {
+        this.f1o_1.m1k(indexed);
+      } else {
+        this.e1o_1.m1k(indexed);
+      }
+    } else {
+      throw UnsupportedOperationException_init_$Create$('An unordered ReteTree cannot perform the assertA operation.');
+    }
+  };
+  protoOf(RootNode).r1i = function (clause) {
+    var indexed = assignHigherIndex(this, clause);
+    this.d1o_1.qo(RootNode$assertZ$lambda(clause));
+    if (clause.xv()) {
+      this.f1o_1.n1k(indexed);
+    } else {
+      this.e1o_1.n1k(indexed);
+    }
+  };
+  protoOf(RootNode).o1k = function () {
+    this.d1o_1.po();
+  };
+  function nestedFunctor_1(_this__u8e3s4, $this) {
+    return Utils_getInstance().d1l(ensureNotNull(_this__u8e3s4.lv()), 0);
+  }
+  function nestedFunctor_2(_this__u8e3s4, $this) {
+    return nestedFunctor_1(_this__u8e3s4.k1k(), $this);
+  }
+  function regenerateCache_3($this) {
+    var tmp;
+    if ($this.j1o_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.k1o_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.f1m();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp3_map = $this.k1o_1.f3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+      var tmp0_iterator_0 = tmp3_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.f1m();
+        tmp2_mapTo.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp2_mapTo;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.k1l(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.p();
+  }
+  function RuleNode(unificator, ordered) {
+    this.i1o_1 = unificator;
+    this.j1o_1 = ordered;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.k1o_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.l1o_1 = tmp_1.no(RuleNode$regenerateCache$ref(this));
+  }
+  protoOf(RuleNode).m1i = function (clause) {
+    var tmp0_safe_receiver = this.k1o_1.d3(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.m1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).m1k = 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.j1o_1) {
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var tmp0_getOrPut = this.k1o_1;
+      var value = tmp0_getOrPut.d3(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.i1o_1, this.j1o_1, 0);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.h4(tmp0_let, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp$ret$1 = tmp_0;
+      tmp$ret$1.m1k(clause.r1l(this));
+      tmp = Unit_getInstance();
+    } else {
+      this.n1k(clause);
+      tmp = Unit_getInstance();
+    }
+    tmp$ret$2 = tmp;
+  };
+  protoOf(RuleNode).n1k = 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.k1o_1;
+    var value = tmp0_getOrPut.d3(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.i1o_1, this.j1o_1, 0);
+      var answer = tmp$ret$0;
+      tmp0_getOrPut.h4(tmp0_let, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp$ret$1 = tmp;
+    tmp$ret$1.n1k(clause.r1l(this));
+    tmp$ret$2 = Unit_getInstance();
+  };
+  protoOf(RuleNode).v1i = function (clause) {
+    var tmp0_safe_receiver = this.k1o_1.d3(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).p = function () {
+    var tmp = asSequence(this.k1o_1.f3());
+    return sum(map(tmp, RuleNode$_get_size_$lambda_xjenvf));
+  };
+  protoOf(RuleNode).j1i = function () {
+    var tmp;
+    if (this.k1o_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.k1o_1.f3();
+        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.n();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.j1i();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(RuleNode).x1i = function (clause) {
+    var tmp0_safe_receiver = this.k1o_1.d3(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.x1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).f1m = function () {
+    return asSequence(this.l1o_1.p2());
+  };
+  protoOf(RuleNode).o1k = function () {
+    this.l1o_1.po();
+  };
+  function selectArity($this, clause) {
+    return $this.p1o_1.d3(Utils_getInstance().c1l(ensureNotNull(clause.lv()), $this.o1o_1));
+  }
+  function chooseAssertionBranch($this, clause, op) {
+    var tmp$ret$5;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = Utils_getInstance().c1l(ensureNotNull(clause.k1k().lv()), $this.o1o_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.p1o_1;
+      var value = tmp0_getOrPut.d3(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.f1i(), $this.n1o_1);
+        var answer = tmp$ret$0;
+        tmp0_getOrPut.h4(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.p1o_1;
+      var value_0 = tmp1_getOrPut.d3(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.f1i(), $this.n1o_1, $this.o1o_1);
+        var answer_0 = tmp$ret$2;
+        tmp1_getOrPut.h4(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.n1o_1) {
+      var tmp_0 = Utils_getInstance();
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = $this.p1o_1.f3();
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator = tmp1_map.j();
+      while (tmp0_iterator.m()) {
+        var item = tmp0_iterator.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.regenerateCache.<anonymous>' call
+        tmp$ret$0 = item.f1m();
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      tmp = tmp_0.g1l(tmp$ret$2);
+    } else {
+      var tmp_1 = Utils_getInstance();
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp3_map = $this.p1o_1.f3();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp2_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+      var tmp0_iterator_0 = tmp3_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.regenerateCache.<anonymous>' call
+        tmp$ret$3 = item_0.f1m();
+        tmp2_mapTo.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp2_mapTo;
+      tmp$ret$5 = tmp$ret$4;
+      tmp = tmp_1.k1l(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.p();
+  }
+  function ReteNode$assertA$ref() {
+    var l = function (p0, p1) {
+      p0.m1k(p1);
+      return Unit_getInstance();
+    };
+    l.callableName = 'assertA';
+    return l;
+  }
+  function ReteNode$assertZ$ref() {
+    var l = function (p0, p1) {
+      p0.n1k(p1);
+      return Unit_getInstance();
+    };
+    l.callableName = 'assertZ';
+    return l;
+  }
+  function TopLevelFunctorReteNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.n1o_1 = ordered;
+    this.o1o_1 = nestingLevel;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp$ret$0 = LinkedHashMap_init_$Create$();
+    tmp.p1o_1 = tmp$ret$0;
+    var tmp_0 = this;
+    var tmp_1 = Companion_getInstance_1();
+    tmp_0.q1o_1 = tmp_1.no(TopLevelFunctorReteNode$regenerateCache$ref(this));
+  }
+  protoOf(TopLevelFunctorReteNode).p = function () {
+    var tmp = asSequence(this.p1o_1.f3());
+    return sum(map(tmp, TopLevelFunctorReteNode$_get_size_$lambda_6i36rr));
+  };
+  protoOf(TopLevelFunctorReteNode).j1i = function () {
+    var tmp;
+    if (this.p1o_1.d()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp0_all = this.p1o_1.f3();
+        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.n();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.<get-isEmpty>.<anonymous>' call
+          tmp$ret$1 = element.j1i();
+          if (!tmp$ret$1) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(TopLevelFunctorReteNode).m1i = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.m1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).m1k = function (clause) {
+    var tmp = clause.r1l(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertA$ref());
+  };
+  protoOf(TopLevelFunctorReteNode).n1k = function (clause) {
+    var tmp = clause.r1l(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertZ$ref());
+  };
+  protoOf(TopLevelFunctorReteNode).v1i = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).x1i = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.x1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).f1m = function () {
+    return asSequence(this.q1o_1.p2());
+  };
+  protoOf(TopLevelFunctorReteNode).o1k = function () {
+    this.q1o_1.po();
+  };
+  function ZeroArityReteNode$retractFirst$lambda(it) {
+    return it.k1k();
+  }
+  function ZeroArityReteNode$get$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.f1i().match(it.k1k(), $clause);
+    };
+  }
+  function ZeroArityReteNode$get$lambda_0(it) {
+    return it.k1k();
+  }
+  function ZeroArityReteNode$retractAll$lambda(it) {
+    return it.k1k();
+  }
+  function ZeroArityReteNode(unificator, ordered) {
+    ArityNode.call(this, unificator);
+    this.s1o_1 = ordered;
+    this.t1o_1 = dequeOf([]);
+  }
+  protoOf(ZeroArityReteNode).v1i = function (clause) {
+    var tmp = this.l1k(this.t1o_1, clause);
+    return buffered(take(map(tmp, ZeroArityReteNode$retractFirst$lambda), 1));
+  };
+  protoOf(ZeroArityReteNode).p = function () {
+    return this.t1o_1.p();
+  };
+  protoOf(ZeroArityReteNode).j1i = function () {
+    return this.t1o_1.d();
+  };
+  protoOf(ZeroArityReteNode).m1i = function (clause) {
+    var tmp = asSequence(this.t1o_1);
+    var tmp_0 = filter(tmp, ZeroArityReteNode$get$lambda(this, clause));
+    return map(tmp_0, ZeroArityReteNode$get$lambda_0);
+  };
+  protoOf(ZeroArityReteNode).m1k = function (clause) {
+    if (this.s1o_1) {
+      addFirst(this.t1o_1, Companion_getInstance_11().z1l(clause.r1l(this), this));
+    } else {
+      this.n1k(clause);
+    }
+  };
+  protoOf(ZeroArityReteNode).n1k = function (clause) {
+    this.t1o_1.g(Companion_getInstance_11().z1l(clause.r1l(this), this));
+  };
+  protoOf(ZeroArityReteNode).x1i = function (clause) {
+    var tmp = this.l1k(this.t1o_1, clause);
+    return buffered(map(tmp, ZeroArityReteNode$retractAll$lambda));
+  };
+  protoOf(ZeroArityReteNode).f1m = function () {
+    return asSequence(this.t1o_1);
+  };
+  protoOf(ZeroArityReteNode).o1k = function () {
+  };
+  protoOf(ZeroArityReteNode).y1l = function (indexed) {
+    this.t1o_1.ba(indexed);
+  };
+  function AbstractTheory$get$lambda(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory$get$lambda_0(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory(tags) {
+    this.u1o_1 = tags;
+  }
+  protoOf(AbstractTheory).fr = function () {
+    return this.u1o_1;
+  };
+  protoOf(AbstractTheory).v1o = function () {
+    return this;
+  };
+  protoOf(AbstractTheory).toImmutableTheory = function () {
+    return this.v1o();
+  };
+  protoOf(AbstractTheory).w1o = function (clause) {
+    return plus_2.call(this, TheoryUtils_getInstance().b1j(clause));
+  };
+  protoOf(AbstractTheory).plus = function (clause) {
+    return this.w1o(clause);
+  };
+  protoOf(AbstractTheory).l1i = function (clause) {
+    return any(this.get(clause));
+  };
+  protoOf(AbstractTheory).contains = function (clause) {
+    return this.l1i(clause);
+  };
+  protoOf(AbstractTheory).x1o = function (head) {
+    return this.l1i(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+  };
+  protoOf(AbstractTheory).containsHead = function (head) {
+    return this.x1o(head);
+  };
+  protoOf(AbstractTheory).y1o = function (indicator) {
+    return any(this.z1o(indicator));
+  };
+  protoOf(AbstractTheory).containsIndicator = function (indicator) {
+    return this.y1o(indicator);
+  };
+  protoOf(AbstractTheory).a1p = function (head) {
+    var tmp = this.get(Companion_getInstance_2().of(head, [Companion_getInstance_3().anonymous()]));
+    return map(tmp, AbstractTheory$get$lambda);
+  };
+  protoOf(AbstractTheory).getByHead = function (head) {
+    return this.a1p(head);
+  };
+  protoOf(AbstractTheory).z1o = function (indicator) {
+    // Inline function 'kotlin.require' call
+    var tmp0_require = indicator.vv();
+    // 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.tw());
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.map' call
+    var tmp2_map = numberRangeToNumber(1, ensureNotNull(indicator.uw()));
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp1_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp2_map, 10));
+    var inductionVariable = tmp2_map.o8_1;
+    var last = tmp2_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();
+        tmp1_mapTo.g(tmp$ret$1);
+      }
+       while (!(item === last));
+    tmp$ret$2 = tmp1_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);
+  };
+  protoOf(AbstractTheory).getByIndicator = function (indicator) {
+    return this.z1o(indicator);
+  };
+  protoOf(AbstractTheory).b1p = function (indicator) {
+    // Inline function 'kotlin.require' call
+    var tmp0_require = indicator.vv();
+    // 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.tw()), ensureNotNull(indicator.uw()))).c1p();
+  };
+  protoOf(AbstractTheory).abolish = function (indicator) {
+    return this.b1p(indicator);
+  };
+  protoOf(AbstractTheory).toString = function () {
+    return '' + getKClassFromExpression(this).xc() + '{ ' + joinToString(this.o1i(), '. ') + ' }';
+  };
+  protoOf(AbstractTheory).d1p = function (asPrologText) {
+    var tmp;
+    if (asPrologText) {
+      tmp = joinToString(this.o1i(), '.\n', '', '.\n');
+    } else {
+      tmp = this.toString();
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).toStringAsProlog = function (asPrologText) {
+    return this.d1p(asPrologText);
+  };
+  protoOf(AbstractTheory).j = function () {
+    return this.o1i().j();
+  };
+  protoOf(AbstractTheory).equals = function (other) {
+    if (other == null)
+      return false;
+    if (!(!(other == null) ? isInterface(other, Theory) : false))
+      return false;
+    return this.e1p(other, true);
+  };
+  protoOf(AbstractTheory).e1p = function (other, useVarCompleteName) {
+    if (this === other)
+      return true;
+    var i = this.o1i().j();
+    var j = other.o1i().j();
+    while (i.m() ? j.m() : false) {
+      if (!i.n().equalsUsingVarCompleteNames(j.n(), useVarCompleteName)) {
+        return false;
+      }
+    }
+    return i.m() === j.m();
+  };
+  protoOf(AbstractTheory).equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.e1p(other, useVarCompleteName);
+  };
+  protoOf(AbstractTheory).hashCode = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_hashCode = getKClass(AbstractTheory).xc();
+    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.o1i().j();
+    while (tmp0_iterator.m()) {
+      var clause = tmp0_iterator.n();
+      result = imul(31, result) + clause.hashCode() | 0;
+    }
+    return result;
+  };
+  protoOf(AbstractTheory).p = function () {
+    var i = new Long(0, 0);
+    var iter = this.j();
+    while (iter.m()) {
+      iter.n();
+      var tmp0 = i;
+      i = tmp0.xf();
+    }
+    return i;
+  };
+  protoOf(AbstractTheory).j1i = function () {
+    return !this.f1p();
+  };
+  protoOf(AbstractTheory).f1p = function () {
+    return this.j().m();
+  };
+  protoOf(AbstractTheory).g1p = function (unificator) {
+    var tmp;
+    if (!equals(unificator, this.f1i())) {
+      tmp = this.h1p(asSequence(this.o1i()), VOID, unificator);
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).setUnificator = function (unificator) {
+    return this.g1p(unificator);
+  };
+  protoOf(AbstractTheory).i1p = function (theory) {
+    var tmp;
+    if (theory.f1p()) {
+      tmp = this.h1p(plus_0(asSequence(this.o1i()), TheoryUtils_getInstance().j1p(asSequence(theory.o1i()))));
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).plusTheory = function (theory) {
+    return this.i1p(theory);
+  };
+  protoOf(AbstractTheory).k1p = function (clause) {
+    return this.h1p(plus_0(TheoryUtils_getInstance().l1p([clause]), asSequence(this.o1i())));
+  };
+  protoOf(AbstractTheory).assertA = function (clause) {
+    return this.k1p(clause);
+  };
+  protoOf(AbstractTheory).m1p = function (clauses) {
+    return this.h1p(plus_0(TheoryUtils_getInstance().j1p(asSequence(clauses)), asSequence(this.o1i())));
+  };
+  protoOf(AbstractTheory).assertAIterable = function (clauses) {
+    return this.m1p(clauses);
+  };
+  protoOf(AbstractTheory).n1p = function (clauses) {
+    return this.h1p(plus_0(TheoryUtils_getInstance().j1p(clauses), asSequence(this.o1i())));
+  };
+  protoOf(AbstractTheory).assertASequence = function (clauses) {
+    return this.n1p(clauses);
+  };
+  protoOf(AbstractTheory).o1p = function (clause) {
+    return this.h1p(plus_0(asSequence(this.o1i()), TheoryUtils_getInstance().j1p(sequenceOf([clause]))));
+  };
+  protoOf(AbstractTheory).assertZ = function (clause) {
+    return this.o1p(clause);
+  };
+  protoOf(AbstractTheory).p1p = function (clauses) {
+    return this.h1p(plus_0(asSequence(this.o1i()), asSequence(TheoryUtils_getInstance().m1j(clauses))));
+  };
+  protoOf(AbstractTheory).assertZIterable = function (clauses) {
+    return this.p1p(clauses);
+  };
+  protoOf(AbstractTheory).q1p = function (clauses) {
+    return this.h1p(plus_0(asSequence(this.o1i()), TheoryUtils_getInstance().j1p(clauses)));
+  };
+  protoOf(AbstractTheory).assertZSequence = function (clauses) {
+    return this.q1p(clauses);
+  };
+  protoOf(AbstractTheory).h1p = function (clauses, tags, unificator, $super) {
+    tags = tags === VOID ? this.fr() : tags;
+    unificator = unificator === VOID ? this.f1i() : unificator;
+    return $super === VOID ? this.r1p(clauses, tags, unificator) : $super.r1p.call(this, clauses, tags, unificator);
+  };
+  protoOf(AbstractTheory).s1p = function (clauses) {
+    return this.t1p(asIterable(clauses));
+  };
+  protoOf(AbstractTheory).retractSequence = function (clauses) {
+    return this.s1p(clauses);
+  };
+  protoOf(AbstractTheory).u1p = function () {
+    return this;
+  };
+  protoOf(AbstractTheory).clone = function () {
+    return this.u1p();
+  };
+  function Companion_4() {
+    Companion_instance_4 = this;
+  }
+  protoOf(Companion_4).empty = function (unificator) {
+    return this.indexedOfIterable(unificator, emptyList());
+  };
+  protoOf(Companion_4).of = function (unificator, clause) {
+    return this.indexedOf(unificator, clause.slice());
+  };
+  protoOf(Companion_4).ofIterable = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, clauses);
+  };
+  protoOf(Companion_4).ofSequence = function (unificator, clauses) {
+    return this.indexedOfSequence(unificator, clauses);
+  };
+  protoOf(Companion_4).ofScopes = function (unificator, clauses) {
+    return this.indexedOfScopes(unificator, clauses.slice());
+  };
+  protoOf(Companion_4).emptyIndexed = function (unificator) {
+    return this.indexedOfIterable(unificator, emptyList());
+  };
+  protoOf(Companion_4).indexedOf = function (unificator, clause) {
+    return this.indexedOfIterable(unificator, asIterable_0(clause));
+  };
+  protoOf(Companion_4).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);
+  };
+  protoOf(Companion_4).indexedOfSequence = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_4).indexedOfIterable = function (unificator, clauses) {
+    return MutableIndexedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(Companion_4).emptyListed = function (unificator) {
+    return this.listedOfSequence(unificator, emptySequence());
+  };
+  protoOf(Companion_4).listedOf = function (unificator, clause) {
+    return this.listedOfIterable(unificator, asIterable_0(clause));
+  };
+  protoOf(Companion_4).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);
+  };
+  protoOf(Companion_4).listedOfSequence = function (unificator, clauses) {
+    return this.listedOfIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_4).listedOfIterable = function (unificator, clauses) {
+    return MutableListedTheory_init_$Create$(unificator, clauses);
+  };
+  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.c1q_1 = theory;
+    this.d1q_1 = clauses;
+  }
+  protoOf(Success_0).c1p = function () {
+    return this.c1q_1;
+  };
+  protoOf(Success_0).o1i = function () {
+    return this.d1q_1;
+  };
+  protoOf(Success_0).i1j = function () {
+    return first_0(this.d1q_1);
+  };
+  protoOf(Success_0).toString = function () {
+    return 'Success(theory=' + this.c1q_1 + ', clauses=' + this.d1q_1 + ')';
+  };
+  protoOf(Success_0).hashCode = function () {
+    var result = hashCode(this.c1q_1);
+    result = imul(result, 31) + hashCode(this.d1q_1) | 0;
+    return result;
+  };
+  protoOf(Success_0).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.c1q_1, tmp0_other_with_cast.c1q_1))
+      return false;
+    if (!equals(this.d1q_1, tmp0_other_with_cast.d1q_1))
+      return false;
+    return true;
+  };
+  function Failure_0(theory) {
+    RetractResult.call(this);
+    this.e1q_1 = theory;
+  }
+  protoOf(Failure_0).c1p = function () {
+    return this.e1q_1;
+  };
+  protoOf(Failure_0).o1i = function () {
+    return null;
+  };
+  protoOf(Failure_0).i1j = function () {
+    return null;
+  };
+  protoOf(Failure_0).toString = function () {
+    return 'Failure(theory=' + this.e1q_1 + ')';
+  };
+  protoOf(Failure_0).hashCode = function () {
+    return hashCode(this.e1q_1);
+  };
+  protoOf(Failure_0).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.e1q_1, tmp0_other_with_cast.e1q_1))
+      return false;
+    return true;
+  };
+  function RetractResult() {
+  }
+  defineProp(protoOf(RetractResult), 'theory', function () {
+    return this.c1p();
+  });
+  defineProp(protoOf(RetractResult), 'clauses', function () {
+    return this.o1i();
+  });
+  defineProp(protoOf(RetractResult), 'firstClause', function () {
+    return this.i1j();
+  });
+  function Companion_5() {
+    Companion_instance_5 = this;
+  }
+  protoOf(Companion_5).empty = function (unificator) {
+    return this.indexedOfSequence(unificator, emptySequence());
+  };
+  protoOf(Companion_5).emptyWithDefaultUnificator = function () {
+    return this.empty(Companion_getInstance_6().c1i());
+  };
+  protoOf(Companion_5).of = function (unificator, clause) {
+    return this.indexedOf(unificator, clause.slice());
+  };
+  protoOf(Companion_5).ofWithDefaultUnificator = function (clause) {
+    return this.indexedOf(Companion_getInstance_6().c1i(), clause.slice());
+  };
+  protoOf(Companion_5).ofIterable = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, clauses);
+  };
+  protoOf(Companion_5).ofIterableWithDefaultUnificator = function (clauses) {
+    return this.indexedOfIterable(Companion_getInstance_6().c1i(), clauses);
+  };
+  protoOf(Companion_5).ofSequence = function (unificator, clauses) {
+    return this.indexedOfSequence(unificator, clauses);
+  };
+  protoOf(Companion_5).ofSequenceWithDefaultUnificator = function (clauses) {
+    return this.indexedOfSequence(Companion_getInstance_6().c1i(), clauses);
+  };
+  protoOf(Companion_5).ofScopes = function (unificator, clauses) {
+    return this.indexedOfScopes(unificator, clauses.slice());
+  };
+  protoOf(Companion_5).ofScopesWithDefaultUnificator = function (clauses) {
+    return this.indexedOfScopes(Companion_getInstance_6().c1i(), clauses.slice());
+  };
+  protoOf(Companion_5).emptyIndexed = function (unificator) {
+    return this.indexedOfIterable(unificator, emptyList());
+  };
+  protoOf(Companion_5).indexedOf = function (unificator, clause) {
+    return this.indexedOfIterable(unificator, asIterable_0(clause));
+  };
+  protoOf(Companion_5).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);
+  };
+  protoOf(Companion_5).indexedOfSequence = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_5).indexedOfIterable = function (unificator, clauses) {
+    return IndexedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(Companion_5).emptyListed = function (unificator) {
+    return this.listedOfSequence(unificator, emptySequence());
+  };
+  protoOf(Companion_5).listedOf = function (unificator, clause) {
+    return this.listedOfIterable(unificator, asIterable_0(clause));
+  };
+  protoOf(Companion_5).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);
+  };
+  protoOf(Companion_5).listedOfSequence = function (unificator, clauses) {
+    return this.listedOfIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_5).listedOfIterable = function (unificator, clauses) {
+    return ListedTheory_init_$Create$(unificator, clauses);
+  };
+  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.n();
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.actualCheck.<anonymous>' call
+        tmp$ret$0 = element.vv();
+        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.vv();
+  }
+  function TheoryUtils() {
+    TheoryUtils_instance = this;
+  }
+  protoOf(TheoryUtils).b1j = 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.vv();
+    // 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;
+  };
+  protoOf(TheoryUtils).l1p = 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;
+  };
+  protoOf(TheoryUtils).m1j = 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;
+  };
+  protoOf(TheoryUtils).j1p = 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.f1q_1 = this$0;
+  }
+  protoOf(_no_name_provided__qut3iv).j = function () {
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.theory.impl.AbstractIndexedTheory.<get-clauses>.<anonymous>' call
+    tmp$ret$0 = this.f1q_1.i1q().j();
+    return tmp$ret$0;
+  };
+  function AbstractIndexedTheory(queue, tags) {
+    AbstractTheory.call(this, tags);
+    this.h1q_1 = queue;
+  }
+  protoOf(AbstractIndexedTheory).f1i = function () {
+    return this.i1q().f1i();
+  };
+  protoOf(AbstractIndexedTheory).i1q = function () {
+    return this.h1q_1;
+  };
+  protoOf(AbstractIndexedTheory).h1i = function () {
+    return this.i1q().g1i();
+  };
+  protoOf(AbstractIndexedTheory).i1i = function () {
+    return this.i1q().i1i();
+  };
+  protoOf(AbstractIndexedTheory).o1i = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.Iterable' call
+    tmp$ret$0 = new _no_name_provided__qut3iv(this);
+    return tmp$ret$0;
+  };
+  protoOf(AbstractIndexedTheory).m1i = function (clause) {
+    return this.i1q().m1i(clause);
+  };
+  protoOf(AbstractIndexedTheory).get = function (clause) {
+    return this.m1i(clause);
+  };
+  protoOf(AbstractIndexedTheory).p = function () {
+    return toLong(this.i1q().p());
+  };
+  protoOf(AbstractIndexedTheory).j1i = function () {
+    return this.i1q().isEmpty();
+  };
+  protoOf(AbstractIndexedTheory).f1p = function () {
+    return !this.j1i();
+  };
+  function AbstractListedTheory(unificator, clauses, tags) {
+    AbstractTheory.call(this, tags);
+    this.k1q_1 = clauses;
+    this.l1q_1 = unificator;
+  }
+  protoOf(AbstractListedTheory).o1i = function () {
+    return this.k1q_1;
+  };
+  protoOf(AbstractListedTheory).m1q = function (_set____db54di) {
+    this.l1q_1 = _set____db54di;
+  };
+  protoOf(AbstractListedTheory).f1i = function () {
+    return this.l1q_1;
+  };
+  protoOf(AbstractListedTheory).m1i = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp1_filter = this.o1i();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp1_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.impl.AbstractListedTheory.get.<anonymous>' call
+      tmp$ret$0 = this.f1i().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);
+  };
+  protoOf(AbstractListedTheory).get = function (clause) {
+    return this.m1i(clause);
+  };
+  function IndexedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    IndexedTheory.call($this, Companion_getInstance_7().ofIterable(unificator, clauses), tags);
+    TheoryUtils_getInstance().m1j(clauses);
+    return $this;
+  }
+  function IndexedTheory_init_$Create$(unificator, clauses, tags) {
+    return IndexedTheory_init_$Init$(unificator, clauses, tags, objectCreate(protoOf(IndexedTheory)));
+  }
+  function IndexedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    IndexedTheory_init_$Init$(unificator, asIterable(clauses), tags, $this);
+    return $this;
+  }
+  function IndexedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return IndexedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(IndexedTheory)));
+  }
+  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.p1q_1.p2();
+    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.q1q_1.p2();
+    return tmp$ret$0;
+  }
+  function IndexedTheory$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractIndexedTheory).hashCode.call(this$0);
+    };
+  }
+  function IndexedTheory$sizeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractIndexedTheory).p.call(this$0);
+    };
+  }
+  function IndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    var tmp = this;
+    tmp.p1q_1 = lazy(IndexedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.q1q_1 = lazy(IndexedTheory$sizeCache$delegate$lambda(this));
+  }
+  protoOf(IndexedTheory).r1p = function (clauses, tags, unificator) {
+    return IndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(IndexedTheory).z1p = function (clause) {
+    var newTheory = Companion_getInstance_7().ofIterable(this.f1i(), this.o1i());
+    var retracted = newTheory.retrieveFirst(clause);
+    return retracted.j1j() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.h1j(), this.fr()), ensureNotNull(retracted.o1i()));
+  };
+  protoOf(IndexedTheory).retract = function (clause) {
+    return this.z1p(clause);
+  };
+  protoOf(IndexedTheory).i1p = function (theory) {
+    return this.j1i() ? theory.toImmutableTheory() : theory.j1i() ? this : protoOf(AbstractIndexedTheory).i1p.call(this, theory);
+  };
+  protoOf(IndexedTheory).plusTheory = function (theory) {
+    return this.i1p(theory);
+  };
+  protoOf(IndexedTheory).w1p = function () {
+    return Companion_getInstance_12().indexedOfIterable(this.f1i(), this);
+  };
+  protoOf(IndexedTheory).toMutableTheory = function () {
+    return this.w1p();
+  };
+  protoOf(IndexedTheory).t1p = function (clauses) {
+    var newTheory = Companion_getInstance_8().ofIterable(this.f1i(), this.o1i());
+    var removed = dequeOf([]);
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var clause = tmp0_iterator.n();
+      var result = newTheory.e1j(clause);
+      if (result.az()) {
+        removed.t(ensureNotNull(result.o1i()));
+      }
+    }
+    var tmp;
+    if (removed.d()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(new IndexedTheory(newTheory, this.fr()), removed);
+    }
+    return tmp;
+  };
+  protoOf(IndexedTheory).retractIterable = function (clauses) {
+    return this.t1p(clauses);
+  };
+  protoOf(IndexedTheory).x1i = function (clause) {
+    var newTheory = Companion_getInstance_7().ofIterable(this.f1i(), this.o1i());
+    var retracted = newTheory.w1i(clause);
+    return retracted.j1j() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.h1j(), this.fr()), ensureNotNull(retracted.o1i()));
+  };
+  protoOf(IndexedTheory).retractAll = function (clause) {
+    return this.x1i(clause);
+  };
+  protoOf(IndexedTheory).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_0(this);
+  };
+  protoOf(IndexedTheory).p = function () {
+    return _get_sizeCache__6eswog(this);
+  };
+  protoOf(IndexedTheory).c10 = function (tags) {
+    return tags === this.fr() ? this : new IndexedTheory(this.i1q(), tags);
+  };
+  protoOf(IndexedTheory).resetTags = function (tags) {
+    return this.c10(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) {
+    tags = tags === VOID ? emptyMap() : tags;
+    ListedTheory.call($this, unificator, toList_0(clauses), tags);
+    TheoryUtils_getInstance().m1j(clauses);
+    return $this;
+  }
+  function ListedTheory_init_$Create$(unificator, clauses, tags) {
+    return ListedTheory_init_$Init$(unificator, clauses, tags, objectCreate(protoOf(ListedTheory)));
+  }
+  function ListedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    ListedTheory.call($this, unificator, toList(clauses), tags);
+    TheoryUtils_getInstance().j1p(clauses);
+    return $this;
+  }
+  function ListedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return ListedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(ListedTheory)));
+  }
+  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.u1q_1.p2();
+    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.v1q_1.p2();
+    return tmp$ret$0;
+  }
+  function ListedTheory$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractListedTheory).hashCode.call(this$0);
+    };
+  }
+  function ListedTheory$sizeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractListedTheory).p.call(this$0);
+    };
+  }
+  function ListedTheory(unificator, clauses, tags) {
+    AbstractListedTheory.call(this, unificator, clauses, tags);
+    var tmp = this;
+    tmp.u1q_1 = lazy(ListedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.v1q_1 = lazy(ListedTheory$sizeCache$delegate$lambda(this));
+  }
+  protoOf(ListedTheory).r1p = function (clauses, tags, unificator) {
+    return ListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(ListedTheory).z1p = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp1_filter = this.o1i();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp1_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+      tmp$ret$0 = this.f1i().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 tmp3_filter = this.o1i();
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.filterTo' call
+      var tmp2_filterTo = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = tmp3_filter.j();
+      while (tmp0_iterator_0.m()) {
+        var element_0 = tmp0_iterator_0.n();
+        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) {
+          tmp2_filterTo.g(element_0);
+        }
+      }
+      tmp$ret$4 = tmp2_filterTo;
+      tmp$ret$5 = tmp$ret$4;
+      var newTheory = tmp$ret$5;
+      tmp = new Success_0(new ListedTheory(this.f1i(), newTheory, this.fr()), listOf_0(toBeActuallyRetracted));
+    }
+    return tmp;
+  };
+  protoOf(ListedTheory).retract = function (clause) {
+    return this.z1p(clause);
+  };
+  protoOf(ListedTheory).w1p = function () {
+    return Companion_getInstance_12().listedOfIterable(this.f1i(), this);
+  };
+  protoOf(ListedTheory).toMutableTheory = function () {
+    return this.w1p();
+  };
+  protoOf(ListedTheory).t1p = function (clauses) {
+    var residual = dequeOf_1(this.o1i());
+    var removed = dequeOf([]);
+    var i = residual.j();
+    while (i.m()) {
+      var current = i.n();
+      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.n();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+          tmp$ret$1 = this.f1i().match(element, current);
+          if (tmp$ret$1) {
+            tmp$ret$0 = true;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = false;
+      }
+      if (tmp$ret$0) {
+        i.v4();
+        removed.g(current);
+      }
+    }
+    var tmp_0;
+    if (removed.d()) {
+      tmp_0 = new Failure_0(this);
+    } else {
+      tmp_0 = new Success_0(new ListedTheory(this.f1i(), residual, this.fr()), removed);
+    }
+    return tmp_0;
+  };
+  protoOf(ListedTheory).retractIterable = function (clauses) {
+    return this.t1p(clauses);
+  };
+  protoOf(ListedTheory).x1i = function (clause) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp1_filter = this.o1i();
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp1_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.n();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retractAll.<anonymous>' call
+      tmp$ret$0 = this.f1i().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 tmp2_partition = toList_0(this.o1i());
+      var first = ArrayList_init_$Create$_0();
+      var second = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = tmp2_partition.j();
+      while (tmp0_iterator_0.m()) {
+        var element_0 = tmp0_iterator_0.n();
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retractAll.<anonymous>' call
+        tmp$ret$3 = this.f1i().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.g4_1;
+      var toBeActuallyRetracted = partitionedClauses.f4_1;
+      tmp = new Success_0(new ListedTheory(this.f1i(), newTheory, this.fr()), toBeActuallyRetracted);
+    }
+    return tmp;
+  };
+  protoOf(ListedTheory).retractAll = function (clause) {
+    return this.x1i(clause);
+  };
+  protoOf(ListedTheory).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_1(this);
+  };
+  protoOf(ListedTheory).p = function () {
+    return _get_sizeCache__6eswog_0(this);
+  };
+  protoOf(ListedTheory).c10 = function (tags) {
+    return tags === this.fr() ? this : new ListedTheory(this.f1i(), this.o1i(), tags);
+  };
+  protoOf(ListedTheory).resetTags = function (tags) {
+    return this.c10(tags);
+  };
+  protoOf(ListedTheory).i1p = function (theory) {
+    return this.j1i() ? theory.toImmutableTheory() : theory.j1i() ? this : protoOf(AbstractListedTheory).i1p.call(this, theory);
+  };
+  protoOf(ListedTheory).plusTheory = function (theory) {
+    return this.i1p(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) {
+    tags = tags === VOID ? emptyMap() : tags;
+    MutableIndexedTheory.call($this, Companion_getInstance_8().ofIterable(unificator, clauses), tags);
+    TheoryUtils_getInstance().m1j(clauses);
+    return $this;
+  }
+  function MutableIndexedTheory_init_$Create$(unificator, clauses, tags) {
+    return MutableIndexedTheory_init_$Init$(unificator, clauses, tags, objectCreate(protoOf(MutableIndexedTheory)));
+  }
+  function MutableIndexedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    MutableIndexedTheory_init_$Init$(unificator, asIterable(clauses), tags, $this);
+    return $this;
+  }
+  function MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return MutableIndexedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(MutableIndexedTheory)));
+  }
+  function toRetractResult(_this__u8e3s4, $this) {
+    return _this__u8e3s4.az() ? new Success_0($this, ensureNotNull(_this__u8e3s4.o1i())) : new Failure_0($this);
+  }
+  function MutableIndexedTheory$retract$lambda(this$0) {
+    return function (it) {
+      return this$0.y1q_1.u1i(it);
+    };
+  }
+  function MutableIndexedTheory$retract$lambda_0(it) {
+    return it.az();
+  }
+  function MutableIndexedTheory$retract$lambda_1(it) {
+    return asSequence(ensureNotNull(it.o1i()));
+  }
+  function MutableIndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    this.y1q_1 = queue;
+  }
+  protoOf(MutableIndexedTheory).i1q = function () {
+    return this.y1q_1;
+  };
+  protoOf(MutableIndexedTheory).g1p = function (unificator) {
+    return protoOf(AbstractIndexedTheory).g1p.call(this, unificator).toMutableTheory();
+  };
+  protoOf(MutableIndexedTheory).setUnificator = function (unificator) {
+    return this.g1p(unificator);
+  };
+  protoOf(MutableIndexedTheory).w1p = function () {
+    return toMutableTheory.call(this);
+  };
+  protoOf(MutableIndexedTheory).toMutableTheory = function () {
+    return this.w1p();
+  };
+  protoOf(MutableIndexedTheory).o1i = function () {
+    return toList_0(this.y1q_1);
+  };
+  protoOf(MutableIndexedTheory).j = function () {
+    return this.y1q_1.j();
+  };
+  protoOf(MutableIndexedTheory).r1p = function (clauses, tags, unificator) {
+    return MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(MutableIndexedTheory).z1p = function (clause) {
+    return toRetractResult(this.y1q_1.u1i(clause), this);
+  };
+  protoOf(MutableIndexedTheory).retract = function (clause) {
+    return this.z1p(clause);
+  };
+  protoOf(MutableIndexedTheory).t1p = 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));
+    var tmp_2;
+    if (retracted.d()) {
+      tmp_2 = new Failure_0(this);
+    } else {
+      tmp_2 = new Success_0(this, retracted);
+    }
+    return tmp_2;
+  };
+  protoOf(MutableIndexedTheory).retractIterable = function (clauses) {
+    return this.t1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).x1i = function (clause) {
+    return toRetractResult(this.y1q_1.w1i(clause), this);
+  };
+  protoOf(MutableIndexedTheory).retractAll = function (clause) {
+    return this.x1i(clause);
+  };
+  protoOf(MutableIndexedTheory).w1o = function (clause) {
+    return this.o1p(TheoryUtils_getInstance().b1j(clause));
+  };
+  protoOf(MutableIndexedTheory).plus = function (clause) {
+    return this.w1o(clause);
+  };
+  protoOf(MutableIndexedTheory).i1p = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.p1p(toList_0(theory));
+    } else {
+      tmp = this.p1p(theory);
+    }
+    return tmp;
+  };
+  protoOf(MutableIndexedTheory).plusTheory = function (theory) {
+    return this.i1p(theory);
+  };
+  protoOf(MutableIndexedTheory).k1p = 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.y1q_1.c1j(TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableIndexedTheory).assertA = function (clause) {
+    return this.k1p(clause);
+  };
+  protoOf(MutableIndexedTheory).m1p = 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().m1j(clauses))).j();
+    while (tmp0_iterator.m()) {
+      var clause = tmp0_iterator.n();
+      this.y1q_1.c1j(clause);
+    }
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableIndexedTheory).assertAIterable = function (clauses) {
+    return this.m1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).n1p = function (clauses) {
+    return this.m1p(asIterable(clauses));
+  };
+  protoOf(MutableIndexedTheory).assertASequence = function (clauses) {
+    return this.n1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).o1p = 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.y1q_1.d1j(TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableIndexedTheory).assertZ = function (clause) {
+    return this.o1p(clause);
+  };
+  protoOf(MutableIndexedTheory).p1p = 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.y1q_1.t1i(TheoryUtils_getInstance().m1j(clauses));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableIndexedTheory).assertZIterable = function (clauses) {
+    return this.p1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).q1p = function (clauses) {
+    return this.p1p(TheoryUtils_getInstance().m1j(asIterable(clauses)));
+  };
+  protoOf(MutableIndexedTheory).assertZSequence = function (clauses) {
+    return this.q1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).s1p = function (clauses) {
+    return this.t1p(asIterable(clauses));
+  };
+  protoOf(MutableIndexedTheory).retractSequence = function (clauses) {
+    return this.s1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).b1p = function (indicator) {
+    return protoOf(AbstractIndexedTheory).b1p.call(this, indicator).toMutableTheory();
+  };
+  protoOf(MutableIndexedTheory).abolish = function (indicator) {
+    return this.b1p(indicator);
+  };
+  protoOf(MutableIndexedTheory).v1o = function () {
+    return Companion_getInstance_13().indexedOfIterable(this.f1i(), this);
+  };
+  protoOf(MutableIndexedTheory).toImmutableTheory = function () {
+    return this.v1o();
+  };
+  protoOf(MutableIndexedTheory).c10 = function (tags) {
+    return tags === this.fr() ? this : new MutableIndexedTheory(this.y1q_1, tags);
+  };
+  protoOf(MutableIndexedTheory).resetTags = function (tags) {
+    return this.c10(tags);
+  };
+  protoOf(MutableIndexedTheory).u1p = function () {
+    return this.h1p(asSequence(this.o1i()));
+  };
+  protoOf(MutableIndexedTheory).clone = function () {
+    return this.u1p();
+  };
+  protoOf(MutableIndexedTheory).assertAFact = function (struct) {
+    return this.x1p(struct);
+  };
+  protoOf(MutableIndexedTheory).assertZFact = function (struct) {
+    return this.y1p(struct);
+  };
+  protoOf(MutableIndexedTheory).retractByHead = function (head) {
+    return this.a1q(head);
+  };
+  protoOf(MutableIndexedTheory).retractAllByHead = function (head) {
+    return this.b1q(head);
+  };
+  function MutableListedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    MutableListedTheory.call($this, unificator, toMutableList(clauses), tags);
+    TheoryUtils_getInstance().m1j(clauses);
+    return $this;
+  }
+  function MutableListedTheory_init_$Create$(unificator, clauses, tags) {
+    return MutableListedTheory_init_$Init$(unificator, clauses, tags, objectCreate(protoOf(MutableListedTheory)));
+  }
+  function MutableListedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    MutableListedTheory.call($this, unificator, toMutableList_0(clauses), tags);
+    TheoryUtils_getInstance().j1p(clauses);
+    return $this;
+  }
+  function MutableListedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return MutableListedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(MutableListedTheory)));
+  }
+  function MutableListedTheory(unificator, clauses, tags) {
+    AbstractListedTheory.call(this, unificator, clauses, tags);
+    this.c1r_1 = clauses;
+  }
+  protoOf(MutableListedTheory).o1i = function () {
+    return this.c1r_1;
+  };
+  protoOf(MutableListedTheory).g1p = function (unificator) {
+    this.m1q(unificator);
+    return this;
+  };
+  protoOf(MutableListedTheory).setUnificator = function (unificator) {
+    return this.g1p(unificator);
+  };
+  protoOf(MutableListedTheory).w1p = function () {
+    return toMutableTheory.call(this);
+  };
+  protoOf(MutableListedTheory).toMutableTheory = function () {
+    return this.w1p();
+  };
+  protoOf(MutableListedTheory).r1p = function (clauses, tags, unificator) {
+    return MutableListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(MutableListedTheory).z1p = function (clause) {
+    var i = this.c1r_1.ua();
+    while (i.m()) {
+      var c = i.n();
+      if (this.f1i().match(c, clause)) {
+        i.v4();
+        return new Success_0(this, listOf_0(c));
+      }
+    }
+    return new Failure_0(this);
+  };
+  protoOf(MutableListedTheory).retract = function (clause) {
+    return this.z1p(clause);
+  };
+  protoOf(MutableListedTheory).t1p = function (clauses) {
+    var i = this.c1r_1.ua();
+    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.n();
+      var tmp0_iterator = clauses.j();
+      while (tmp0_iterator.m()) {
+        var clause = tmp0_iterator.n();
+        if (this.f1i().match(c, clause)) {
+          retracted.g(c);
+          i.v4();
+        }
+      }
+    }
+    var tmp;
+    if (retracted.d()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).retractIterable = function (clauses) {
+    return this.t1p(clauses);
+  };
+  protoOf(MutableListedTheory).x1i = function (clause) {
+    var i = this.c1r_1.ua();
+    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.n();
+      if (this.f1i().match(c, clause)) {
+        retracted.g(c);
+        i.v4();
+      }
+    }
+    var tmp;
+    if (retracted.d()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).retractAll = function (clause) {
+    return this.x1i(clause);
+  };
+  protoOf(MutableListedTheory).w1o = function (clause) {
+    return this.o1p(clause);
+  };
+  protoOf(MutableListedTheory).plus = function (clause) {
+    return this.w1o(clause);
+  };
+  protoOf(MutableListedTheory).i1p = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.p1p(toList_0(theory));
+    } else {
+      tmp = this.p1p(theory);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).plusTheory = function (theory) {
+    return this.i1p(theory);
+  };
+  protoOf(MutableListedTheory).k1p = 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.c1r_1, TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableListedTheory).assertA = function (clause) {
+    return this.k1p(clause);
+  };
+  protoOf(MutableListedTheory).m1p = 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.c1r_1, TheoryUtils_getInstance().m1j(clauses));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableListedTheory).assertAIterable = function (clauses) {
+    return this.m1p(clauses);
+  };
+  protoOf(MutableListedTheory).n1p = function (clauses) {
+    return this.m1p(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).assertASequence = function (clauses) {
+    return this.n1p(clauses);
+  };
+  protoOf(MutableListedTheory).o1p = 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.c1r_1.g(TheoryUtils_getInstance().b1j(clause));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableListedTheory).assertZ = function (clause) {
+    return this.o1p(clause);
+  };
+  protoOf(MutableListedTheory).p1p = 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.c1r_1, TheoryUtils_getInstance().m1j(clauses));
+    tmp$ret$0 = this;
+    return tmp$ret$0;
+  };
+  protoOf(MutableListedTheory).assertZIterable = function (clauses) {
+    return this.p1p(clauses);
+  };
+  protoOf(MutableListedTheory).q1p = function (clauses) {
+    return this.p1p(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).assertZSequence = function (clauses) {
+    return this.q1p(clauses);
+  };
+  protoOf(MutableListedTheory).s1p = function (clauses) {
+    return this.t1p(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).retractSequence = function (clauses) {
+    return this.s1p(clauses);
+  };
+  protoOf(MutableListedTheory).b1p = function (indicator) {
+    return protoOf(AbstractListedTheory).b1p.call(this, indicator).toMutableTheory();
+  };
+  protoOf(MutableListedTheory).abolish = function (indicator) {
+    return this.b1p(indicator);
+  };
+  protoOf(MutableListedTheory).v1o = function () {
+    return Companion_getInstance_13().listedOfIterable(this.f1i(), this);
+  };
+  protoOf(MutableListedTheory).toImmutableTheory = function () {
+    return this.v1o();
+  };
+  protoOf(MutableListedTheory).c10 = function (tags) {
+    return tags === this.fr() ? this : new MutableListedTheory(this.f1i(), this.c1r_1, tags);
+  };
+  protoOf(MutableListedTheory).resetTags = function (tags) {
+    return this.c10(tags);
+  };
+  protoOf(MutableListedTheory).u1p = function () {
+    return this.h1p(asSequence(this.c1r_1));
+  };
+  protoOf(MutableListedTheory).clone = function () {
+    return this.u1p();
+  };
+  protoOf(MutableListedTheory).assertAFact = function (struct) {
+    return this.x1p(struct);
+  };
+  protoOf(MutableListedTheory).assertZFact = function (struct) {
+    return this.y1p(struct);
+  };
+  protoOf(MutableListedTheory).retractByHead = function (head) {
+    return this.a1q(head);
+  };
+  protoOf(MutableListedTheory).retractAllByHead = function (head) {
+    return this.b1q(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.n();
+      }
+       while (inductionVariable < n);
+    return iter.n();
+  }
+  //region block: post-declaration
+  protoOf(MutableReteClauseQueue).m1i = get;
+  protoOf(ReteClauseQueue).m1i = get;
+  protoOf(IndexedClause$Companion$wrap$1).k1k = get_innerClause;
+  protoOf(IndexedClause$Companion$wrap$1).r1l = plus_1;
+  protoOf(IndexedClause$Companion$wrap$1).br = compareTo;
+  protoOf(SituatedIndexedClause$Companion$of$1).k1k = get_innerClause;
+  protoOf(SituatedIndexedClause$Companion$of$1).r1l = plus_1;
+  protoOf(SituatedIndexedClause$Companion$of$1).br = compareTo;
+  protoOf(AbstractTheory).v1p = get_isMutable;
+  protoOf(AbstractTheory).i1i = get_rules;
+  protoOf(AbstractTheory).h1i = get_directives;
+  protoOf(AbstractTheory).assertAFact = assertAFact;
+  protoOf(AbstractTheory).assertZFact = assertZFact;
+  protoOf(AbstractTheory).retractByHead = retractByHead;
+  protoOf(AbstractTheory).retractAllByHead = retractAllByHead;
+  protoOf(AbstractTheory).getTag = getTag;
+  protoOf(AbstractTheory).containsTag = containsTag;
+  protoOf(AbstractIndexedTheory).assertAFact = assertAFact;
+  protoOf(AbstractIndexedTheory).assertZFact = assertZFact;
+  protoOf(AbstractIndexedTheory).retractByHead = retractByHead;
+  protoOf(AbstractIndexedTheory).v1p = get_isMutable;
+  protoOf(AbstractIndexedTheory).retractAllByHead = retractAllByHead;
+  protoOf(AbstractIndexedTheory).getTag = getTag;
+  protoOf(AbstractIndexedTheory).containsTag = containsTag;
+  protoOf(AbstractListedTheory).assertAFact = assertAFact;
+  protoOf(AbstractListedTheory).assertZFact = assertZFact;
+  protoOf(AbstractListedTheory).retractByHead = retractByHead;
+  protoOf(AbstractListedTheory).v1p = get_isMutable;
+  protoOf(AbstractListedTheory).i1i = get_rules;
+  protoOf(AbstractListedTheory).h1i = get_directives;
+  protoOf(AbstractListedTheory).retractAllByHead = retractAllByHead;
+  protoOf(AbstractListedTheory).getTag = getTag;
+  protoOf(AbstractListedTheory).containsTag = containsTag;
+  protoOf(IndexedTheory).assertAFact = assertAFact;
+  protoOf(IndexedTheory).assertZFact = assertZFact;
+  protoOf(IndexedTheory).retractByHead = retractByHead;
+  protoOf(IndexedTheory).v1p = get_isMutable;
+  protoOf(IndexedTheory).retractAllByHead = retractAllByHead;
+  protoOf(IndexedTheory).getTag = getTag;
+  protoOf(IndexedTheory).containsTag = containsTag;
+  protoOf(ListedTheory).assertAFact = assertAFact;
+  protoOf(ListedTheory).assertZFact = assertZFact;
+  protoOf(ListedTheory).retractByHead = retractByHead;
+  protoOf(ListedTheory).v1p = get_isMutable;
+  protoOf(ListedTheory).i1i = get_rules;
+  protoOf(ListedTheory).h1i = get_directives;
+  protoOf(ListedTheory).retractAllByHead = retractAllByHead;
+  protoOf(ListedTheory).getTag = getTag;
+  protoOf(ListedTheory).containsTag = containsTag;
+  protoOf(MutableIndexedTheory).x1p = assertAFact_0;
+  protoOf(MutableIndexedTheory).y1p = assertZFact_0;
+  protoOf(MutableIndexedTheory).a1q = retractByHead_0;
+  protoOf(MutableIndexedTheory).v1p = get_isMutable_0;
+  protoOf(MutableIndexedTheory).b1q = retractAllByHead_0;
+  protoOf(MutableIndexedTheory).getTag = getTag;
+  protoOf(MutableIndexedTheory).containsTag = containsTag;
+  protoOf(MutableListedTheory).x1p = assertAFact_0;
+  protoOf(MutableListedTheory).y1p = assertZFact_0;
+  protoOf(MutableListedTheory).a1q = retractByHead_0;
+  protoOf(MutableListedTheory).v1p = get_isMutable_0;
+  protoOf(MutableListedTheory).i1i = get_rules;
+  protoOf(MutableListedTheory).h1i = get_directives;
+  protoOf(MutableListedTheory).b1q = retractAllByHead_0;
+  protoOf(MutableListedTheory).getTag = getTag;
+  protoOf(MutableListedTheory).containsTag = containsTag;
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_getInstance_12;
+  _.$_$.b = Companion_getInstance_13;
+  _.$_$.c = MutableTheory;
+  _.$_$.d = Success_0;
+  _.$_$.e = Theory;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-theory.js.map