@tuprolog/arg2p-causality-solver 0.9.0

package/2p-theory.js

@@ -0,0 +1,4771 @@
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './2p-core.js', './2p-utils.js', './2p-unify.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-core.js'), require('./2p-utils.js'), require('./2p-unify.js'));
+  else {
+    if (typeof this['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module '2p-theory'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' 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'], 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.$_$.a6;
+  var asIterable = kotlin_kotlin.$_$.y6;
+  var any = kotlin_kotlin.$_$.x6;
+  var asSequence = kotlin_kotlin.$_$.h2;
+  var getKClassFromExpression = kotlin_kotlin.$_$.b;
+  var joinToString = kotlin_kotlin.$_$.c3;
+  var Iterable = kotlin_kotlin.$_$.u1;
+  var classMeta = kotlin_kotlin.$_$.e5;
+  var setMetadataFor = kotlin_kotlin.$_$.b6;
+  var VOID = kotlin_kotlin.$_$.d;
+  var Unit_instance = kotlin_kotlin.$_$.s1;
+  var toList = kotlin_kotlin.$_$.g8;
+  var none = kotlin_kotlin.$_$.u7;
+  var emptyList = kotlin_kotlin.$_$.t2;
+  var asIterable_0 = kotlin_kotlin.$_$.c2;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.e;
+  var Companion_instance = kotlin_it_unibo_tuprolog_core.$_$.t;
+  var itemWiseEquals = kotlin_it_unibo_tuprolog_utils.$_$.e1;
+  var getKClass = kotlin_kotlin.$_$.c;
+  var itemWiseHashCode = kotlin_it_unibo_tuprolog_utils.$_$.f1;
+  var itemWiseHashCode_0 = kotlin_it_unibo_tuprolog_utils.$_$.g1;
+  var objectMeta = kotlin_kotlin.$_$.z5;
+  var interfaceMeta = kotlin_kotlin.$_$.n5;
+  var first = kotlin_kotlin.$_$.x2;
+  var hashCode = kotlin_kotlin.$_$.m5;
+  var THROW_CCE = kotlin_kotlin.$_$.v9;
+  var equals = kotlin_kotlin.$_$.h5;
+  var defineProp = kotlin_kotlin.$_$.g5;
+  var objectCreate = kotlin_kotlin.$_$.y5;
+  var toString = kotlin_kotlin.$_$.f6;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.s;
+  var asReversed = kotlin_kotlin.$_$.e2;
+  var isInterface = kotlin_kotlin.$_$.q5;
+  var lazy = kotlin_kotlin.$_$.aa;
+  var KProperty1 = kotlin_kotlin.$_$.u6;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.k5;
+  var CoroutineImpl = kotlin_kotlin.$_$.w4;
+  var SequenceScope = kotlin_kotlin.$_$.v6;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.v4;
+  var sequence = kotlin_kotlin.$_$.z7;
+  var listOf = kotlin_kotlin.$_$.k3;
+  var mergeSequences = kotlin_it_unibo_tuprolog_utils.$_$.i1;
+  var sequenceOf = kotlin_kotlin.$_$.y7;
+  var flatten = kotlin_kotlin.$_$.l7;
+  var compareTo = kotlin_it_unibo_tuprolog_utils.$_$.g;
+  var LongIndexed = kotlin_it_unibo_tuprolog_utils.$_$.h;
+  var Companion_instance_0 = kotlin_it_unibo_tuprolog_utils.$_$.d;
+  var copyToArray = kotlin_kotlin.$_$.r2;
+  var plus = kotlin_kotlin.$_$.d4;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.f;
+  var minOrNull = kotlin_kotlin.$_$.o3;
+  var ensureNotNull = kotlin_kotlin.$_$.y9;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.h;
+  var map = kotlin_kotlin.$_$.s7;
+  var sum = kotlin_kotlin.$_$.b8;
+  var Collection = kotlin_kotlin.$_$.t1;
+  var dequeOf = kotlin_it_unibo_tuprolog_utils.$_$.z;
+  var addFirst = kotlin_it_unibo_tuprolog_utils.$_$.o;
+  var filter = kotlin_kotlin.$_$.h7;
+  var emptySequence = kotlin_kotlin.$_$.e7;
+  var buffered = kotlin_it_unibo_tuprolog_utils.$_$.s;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j2;
+  var dequeOf_0 = kotlin_it_unibo_tuprolog_utils.$_$.x;
+  var Companion_instance_1 = kotlin_it_unibo_tuprolog_utils.$_$.b;
+  var firstOrNull = kotlin_kotlin.$_$.i7;
+  var NotImplementedError = kotlin_kotlin.$_$.q9;
+  var take = kotlin_kotlin.$_$.d8;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.v;
+  var Long = kotlin_kotlin.$_$.p9;
+  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.e1;
+  var Companion_instance_2 = kotlin_it_unibo_tuprolog_core.$_$.s;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.z;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.u;
+  var numberRangeToNumber = kotlin_kotlin.$_$.u5;
+  var plus_0 = kotlin_kotlin.$_$.w7;
+  var getTag = kotlin_it_unibo_tuprolog_utils.$_$.l;
+  var containsTag = kotlin_it_unibo_tuprolog_utils.$_$.k;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_unify.$_$.b;
+  var Companion_instance_3 = kotlin_it_unibo_tuprolog_core.$_$.m;
+  var first_0 = kotlin_kotlin.$_$.y2;
+  var filterNotNull = kotlin_kotlin.$_$.f7;
+  var Taggable = kotlin_it_unibo_tuprolog_utils.$_$.m;
+  var filterNot = kotlin_kotlin.$_$.g7;
+  var asSequence_0 = kotlin_kotlin.$_$.i2;
+  var toLong = kotlin_kotlin.$_$.d6;
+  var emptyMap = kotlin_kotlin.$_$.u2;
+  var toList_0 = kotlin_kotlin.$_$.k4;
+  var listOf_0 = kotlin_kotlin.$_$.j3;
+  var none_0 = kotlin_kotlin.$_$.x3;
+  var dequeOf_1 = kotlin_it_unibo_tuprolog_utils.$_$.y;
+  var Pair = kotlin_kotlin.$_$.t9;
+  var flatMap = kotlin_kotlin.$_$.k7;
+  var toMutableList = kotlin_kotlin.$_$.q4;
+  var toMutableList_0 = kotlin_kotlin.$_$.h8;
+  var addFirst_0 = kotlin_it_unibo_tuprolog_utils.$_$.n;
+  var addAll = kotlin_kotlin.$_$.z1;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(AbstractClauseCollection, 'AbstractClauseCollection', classMeta, VOID, [Iterable]);
+  setMetadataFor(AbstractMutableReteClauseCollection, 'AbstractMutableReteClauseCollection', classMeta, AbstractClauseCollection, [Iterable, AbstractClauseCollection]);
+  setMetadataFor(AbstractReteClauseCollection, 'AbstractReteClauseCollection', classMeta, AbstractClauseCollection);
+  setMetadataFor(Companion, 'Companion', objectMeta);
+  function get(clause) {
+    return this.getFifoOrdered(clause);
+  }
+  function add(clause) {
+    return this.addLast(clause);
+  }
+  function add_0(clause) {
+    return this.r1l(clause);
+  }
+  function retrieve(clause) {
+    return this.retrieveFirst(clause);
+  }
+  function retrieve_0(clause) {
+    return this.u1l(clause);
+  }
+  setMetadataFor(ClauseQueue, 'ClauseQueue', interfaceMeta, VOID, [Iterable]);
+  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, VOID, [1]);
+  setMetadataFor(AbstractReteNode, 'AbstractReteNode', classMeta);
+  setMetadataFor(Companion_1, 'Companion', objectMeta);
+  setMetadataFor(Utils$firstArguments$slambda, 'Utils$firstArguments$slambda', classMeta, CoroutineImpl, VOID, VOID, VOID, VOID, [1]);
+  setMetadataFor(Utils, 'Utils', objectMeta);
+  function get_innerClause() {
+    return this.r2();
+  }
+  function plus_1(traversed) {
+    return Companion_instance_7.v1o(this.bq(), this.k1n(), plus(this.r1o(), 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.p1l());
+    return asIterable(filterNotNull(map(tmp, Theory$_get_rules_$lambda_c39n1s)));
+  }
+  function get_directives() {
+    var tmp = asSequence(this.p1l());
+    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_instance_3.of(struct));
+  }
+  function assertZFact(struct) {
+    return this.assertZ(Companion_instance_3.of(struct));
+  }
+  function retractByHead(head) {
+    return this.retract(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  }
+  function retractAllByHead(head) {
+    return this.retractAll(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  }
+  setMetadataFor(Theory, 'Theory', interfaceMeta, VOID, [Iterable, Taggable]);
+  setMetadataFor(AbstractTheory, 'AbstractTheory', classMeta, VOID, [Theory]);
+  function emptyTheory() {
+    return this.emptyTheoryWithUnificator(this.e1l());
+  }
+  function theoryOfIterable(clauses) {
+    return this.theoryOfIterableWithUnificator(clauses, this.e1l());
+  }
+  function theoryOf(clauses) {
+    return this.theoryOfWithUnificator(this.e1l(), clauses.slice());
+  }
+  function theoryOfSequence(clauses) {
+    return this.theoryOfSequenceWithUnificator(clauses, this.e1l());
+  }
+  function emptyMutableTheory() {
+    return this.emptyMutableTheoryWithUnificator(this.e1l());
+  }
+  function mutableTheoryOfIterable(clauses) {
+    return this.mutableTheoryOfIterableWithUnificator(clauses, this.e1l());
+  }
+  function mutableTheoryOf(clauses) {
+    return this.mutableTheoryOfWithUnificator(this.e1l(), clauses.slice());
+  }
+  function mutableTheoryOfSequence(clauses) {
+    return this.mutableTheoryOfSequenceWithUnificator(clauses, this.e1l());
+  }
+  setMetadataFor(TheoryFactory, 'TheoryFactory', interfaceMeta);
+  setMetadataFor(Default, 'Default', objectMeta, VOID, [TheoryFactory]);
+  setMetadataFor(IndexedTheoryFactory, 'IndexedTheoryFactory', classMeta, VOID, [TheoryFactory]);
+  setMetadataFor(Default_0, 'Default', objectMeta, VOID, [TheoryFactory]);
+  setMetadataFor(ListedTheoryFactory, 'ListedTheoryFactory', classMeta, VOID, [TheoryFactory]);
+  setMetadataFor(Companion_4, 'Companion', objectMeta);
+  function get_isMutable_0() {
+    return true;
+  }
+  function toMutableTheory() {
+    return this;
+  }
+  function assertAFact_0(struct) {
+    return this.k1s(Companion_instance_3.of(struct));
+  }
+  function assertZFact_0(struct) {
+    return this.o1s(Companion_instance_3.of(struct));
+  }
+  function retractByHead_0(head) {
+    return this.l1t(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  }
+  function retractAllByHead_0(head) {
+    return this.x1l(Companion_instance_2.of(head, [Companion_getInstance().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, VOID, [Iterable]);
+  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.f1l_1 = rete;
+  }
+  protoOf(AbstractClauseCollection).e1l = function () {
+    return this.f1l_1.e1l();
+  };
+  protoOf(AbstractClauseCollection).l = function () {
+    return this.f1l_1.l();
+  };
+  protoOf(AbstractClauseCollection).h1l = function () {
+    return asIterable(this.f1l_1.i1l());
+  };
+  protoOf(AbstractClauseCollection).j1l = function () {
+    return asIterable(this.f1l_1.j1l());
+  };
+  protoOf(AbstractClauseCollection).z = function () {
+    return this.f1l_1.k1l();
+  };
+  protoOf(AbstractClauseCollection).isEmpty = function () {
+    return this.z();
+  };
+  protoOf(AbstractClauseCollection).l1l = function () {
+    return !this.z();
+  };
+  protoOf(AbstractClauseCollection).isNonEmpty = function () {
+    return this.l1l();
+  };
+  protoOf(AbstractClauseCollection).m1l = function (element) {
+    return any(this.f1l_1.n1l(element));
+  };
+  protoOf(AbstractClauseCollection).contains = function (element) {
+    return this.m1l(element);
+  };
+  protoOf(AbstractClauseCollection).o1l = function (elements) {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var tmp0_iterator = asSequence(elements).r();
+      while (tmp0_iterator.s()) {
+        var element = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.AbstractClauseCollection.containsAll.<anonymous>' call
+        if (!this.m1l(element)) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    return tmp$ret$1;
+  };
+  protoOf(AbstractClauseCollection).containsAll = function (elements) {
+    return this.o1l(elements);
+  };
+  protoOf(AbstractClauseCollection).r = function () {
+    return this.f1l_1.p1l().r();
+  };
+  protoOf(AbstractClauseCollection).toString = function () {
+    return '' + getKClassFromExpression(this).o6() + '(' + joinToString(this, ', ') + ')';
+  };
+  function AbstractMutableReteClauseCollection_init_$Init$(rete, $this) {
+    AbstractClauseCollection.call($this, rete);
+    AbstractMutableReteClauseCollection.call($this);
+    return $this;
+  }
+  protoOf(AbstractMutableReteClauseCollection).r1l = function (clause) {
+    this.f1l_1.s1l(clause);
+    return this.g1l();
+  };
+  protoOf(AbstractMutableReteClauseCollection).add = function (clause) {
+    return this.r1l(clause);
+  };
+  protoOf(AbstractMutableReteClauseCollection).t1l = function (clauses) {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.collections.AbstractMutableReteClauseCollection.addAll.<anonymous>' call
+      this.f1l_1.s1l(element);
+    }
+    return this.g1l();
+  };
+  protoOf(AbstractMutableReteClauseCollection).addAll = function (clauses) {
+    return this.t1l(clauses);
+  };
+  protoOf(AbstractMutableReteClauseCollection).u1l = function (clause) {
+    var retracted = this.f1l_1.v1l(clause);
+    return none(retracted) ? new Failure(this.g1l()) : new Success(this.g1l(), toList(retracted));
+  };
+  protoOf(AbstractMutableReteClauseCollection).retrieve = function (clause) {
+    return this.u1l(clause);
+  };
+  protoOf(AbstractMutableReteClauseCollection).w1l = function (clause) {
+    var retracted = this.f1l_1.x1l(clause);
+    return none(retracted) ? new Failure(this.g1l()) : new Success(this.g1l(), toList(retracted));
+  };
+  protoOf(AbstractMutableReteClauseCollection).retrieveAll = function (clause) {
+    return this.w1l(clause);
+  };
+  function AbstractMutableReteClauseCollection() {
+  }
+  function AbstractReteClauseCollection(rete) {
+    AbstractClauseCollection.call(this, rete);
+  }
+  protoOf(AbstractReteClauseCollection).r1l = function (clause) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.f1l_1.a1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.add.<anonymous>' call
+    this_0.s1l(TheoryUtils_instance.b1m(clause));
+    return this.z1l(this_0);
+  };
+  protoOf(AbstractReteClauseCollection).add = function (clause) {
+    return this.r1l(clause);
+  };
+  protoOf(AbstractReteClauseCollection).t1l = function (clauses) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.f1l_1.a1m();
+    // 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.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.collections.AbstractReteClauseCollection.addAll.<anonymous>.<anonymous>' call
+      this_0.s1l(TheoryUtils_instance.b1m(element));
+    }
+    return this.z1l(this_0);
+  };
+  protoOf(AbstractReteClauseCollection).addAll = function (clauses) {
+    return this.t1l(clauses);
+  };
+  protoOf(AbstractReteClauseCollection).u1l = function (clause) {
+    var newTheory = this.f1l_1.a1m();
+    var retracted = newTheory.v1l(clause);
+    return none(retracted) ? new Failure(this.g1l()) : new Success(this.z1l(newTheory), toList(retracted));
+  };
+  protoOf(AbstractReteClauseCollection).retrieve = function (clause) {
+    return this.u1l(clause);
+  };
+  protoOf(AbstractReteClauseCollection).w1l = function (clause) {
+    var newTheory = this.f1l_1.a1m();
+    var retracted = newTheory.x1l(clause);
+    return none(retracted) ? new Failure(this.g1l()) : new Success(this.z1l(newTheory), toList(retracted));
+  };
+  protoOf(AbstractReteClauseCollection).retrieveAll = function (clause) {
+    return this.w1l(clause);
+  };
+  function Companion() {
+  }
+  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) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(clause.length);
+    var inductionVariable = 0;
+    var last = clause.length;
+    while (inductionVariable < last) {
+      var item = clause[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.collections.Companion.of.<anonymous>' call
+      var tmp$ret$0 = Companion_instance.emptyWithFunction(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.ofIterable(unificator, destination);
+  };
+  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_4;
+  function Companion_getInstance_2() {
+    return Companion_instance_4;
+  }
+  function ClauseQueue() {
+  }
+  function Companion_0() {
+  }
+  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) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(clause.length);
+    var inductionVariable = 0;
+    var last = clause.length;
+    while (inductionVariable < last) {
+      var item = clause[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.collections.Companion.of.<anonymous>' call
+      var tmp$ret$0 = Companion_instance.emptyWithFunction(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.ofIterable(unificator, destination);
+  };
+  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_instance_4.areEquals(queue1, queue2);
+  };
+  protoOf(Companion_0).computeHashCode = function (queue) {
+    return itemWiseHashCode_0([getKClass(MutableClauseQueue), itemWiseHashCode(queue)]);
+  };
+  var Companion_instance_5;
+  function Companion_getInstance_3() {
+    return Companion_instance_5;
+  }
+  function MutableClauseQueue() {
+  }
+  function Success(collection, clauses) {
+    RetrieveResult.call(this);
+    this.f1m_1 = collection;
+    this.g1m_1 = clauses;
+  }
+  protoOf(Success).h1m = function () {
+    return this.f1m_1;
+  };
+  protoOf(Success).p1l = function () {
+    return this.g1m_1;
+  };
+  protoOf(Success).d11 = function () {
+    return true;
+  };
+  protoOf(Success).i1m = function () {
+    return first(this.g1m_1);
+  };
+  protoOf(Success).toString = function () {
+    return 'Success(collection=' + this.f1m_1 + ', clauses=' + this.g1m_1 + ')';
+  };
+  protoOf(Success).hashCode = function () {
+    var result = hashCode(this.f1m_1);
+    result = imul(result, 31) + hashCode(this.g1m_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.f1m_1, tmp0_other_with_cast.f1m_1))
+      return false;
+    if (!equals(this.g1m_1, tmp0_other_with_cast.g1m_1))
+      return false;
+    return true;
+  };
+  function Failure(collection) {
+    RetrieveResult.call(this);
+    this.k1m_1 = collection;
+  }
+  protoOf(Failure).h1m = function () {
+    return this.k1m_1;
+  };
+  protoOf(Failure).j1m = function () {
+    return true;
+  };
+  protoOf(Failure).p1l = function () {
+    return null;
+  };
+  protoOf(Failure).i1m = function () {
+    return null;
+  };
+  protoOf(Failure).toString = function () {
+    return 'Failure(collection=' + this.k1m_1 + ')';
+  };
+  protoOf(Failure).hashCode = function () {
+    return hashCode(this.k1m_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.k1m_1, tmp0_other_with_cast.k1m_1))
+      return false;
+    return true;
+  };
+  function RetrieveResult() {
+  }
+  protoOf(RetrieveResult).d11 = function () {
+    return false;
+  };
+  protoOf(RetrieveResult).j1m = function () {
+    return false;
+  };
+  function MutableReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    MutableReteClauseQueue.call($this, Companion_instance_6.l1m(unificator, clauses));
+    TheoryUtils_instance.m1m(clauses);
+    return $this;
+  }
+  function MutableReteClauseQueue_init_$Create$(unificator, clauses) {
+    return MutableReteClauseQueue_init_$Init$(unificator, clauses, objectCreate(protoOf(MutableReteClauseQueue)));
+  }
+  function MutableReteClauseQueue(rete) {
+    AbstractMutableReteClauseCollection_init_$Init$(rete, this);
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!rete.n1m()) {
+      // Inline function 'kotlin.require.<anonymous>' call
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(MutableReteClauseQueue).p1m = function (clause) {
+    return this.f1l_1.n1l(clause);
+  };
+  protoOf(MutableReteClauseQueue).getFifoOrdered = function (clause) {
+    return this.p1m(clause);
+  };
+  protoOf(MutableReteClauseQueue).q1m = function (clause) {
+    return asSequence(asReversed(toList(this.p1m(clause))));
+  };
+  protoOf(MutableReteClauseQueue).getLifoOrdered = function (clause) {
+    return this.q1m(clause);
+  };
+  protoOf(MutableReteClauseQueue).c1m = function (clause) {
+    this.f1l_1.r1m(clause);
+    return this;
+  };
+  protoOf(MutableReteClauseQueue).addFirst = function (clause) {
+    return this.c1m(clause);
+  };
+  protoOf(MutableReteClauseQueue).d1m = function (clause) {
+    this.f1l_1.s1l(clause);
+    return this;
+  };
+  protoOf(MutableReteClauseQueue).addLast = function (clause) {
+    return this.d1m(clause);
+  };
+  protoOf(MutableReteClauseQueue).e1m = function (clause) {
+    var retracted = this.f1l_1.v1l(clause);
+    return none(retracted) ? new Failure(this) : new Success(this, toList(retracted));
+  };
+  protoOf(MutableReteClauseQueue).retrieveFirst = function (clause) {
+    return this.e1m(clause);
+  };
+  protoOf(MutableReteClauseQueue).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, MutableClauseQueue) : false) {
+      tmp = Companion_instance_5.areEquals(this, other);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(MutableReteClauseQueue).hashCode = function () {
+    return Companion_instance_5.computeHashCode(this);
+  };
+  protoOf(MutableReteClauseQueue).g1l = function () {
+    return this;
+  };
+  function _get_hashCodeCache__ny3r0q($this) {
+    // Inline function 'kotlin.getValue' call
+    var this_0 = $this.t1m_1;
+    hashCodeCache$factory();
+    return this_0.r2();
+  }
+  function ReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    ReteClauseQueue.call($this, Companion_instance_6.l1m(unificator, clauses));
+    TheoryUtils_instance.m1m(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_instance_4.computeHashCode(this$0);
+    };
+  }
+  function ReteClauseQueue(rete) {
+    AbstractReteClauseCollection.call(this, rete);
+    var tmp = this;
+    tmp.t1m_1 = lazy(ReteClauseQueue$hashCodeCache$delegate$lambda(this));
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!rete.n1m()) {
+      // Inline function 'kotlin.require.<anonymous>' call
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(ReteClauseQueue).c1m = function (clause) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.f1l_1.a1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.impl.ReteClauseQueue.addFirst.<anonymous>' call
+    this_0.r1m(TheoryUtils_instance.b1m(clause));
+    return new ReteClauseQueue(this_0);
+  };
+  protoOf(ReteClauseQueue).addFirst = function (clause) {
+    return this.c1m(clause);
+  };
+  protoOf(ReteClauseQueue).d1m = function (clause) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.f1l_1.a1m();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.impl.ReteClauseQueue.addLast.<anonymous>' call
+    this_0.s1l(TheoryUtils_instance.b1m(clause));
+    return new ReteClauseQueue(this_0);
+  };
+  protoOf(ReteClauseQueue).addLast = function (clause) {
+    return this.d1m(clause);
+  };
+  protoOf(ReteClauseQueue).p1m = function (clause) {
+    return this.f1l_1.n1l(clause);
+  };
+  protoOf(ReteClauseQueue).getFifoOrdered = function (clause) {
+    return this.p1m(clause);
+  };
+  protoOf(ReteClauseQueue).q1m = function (clause) {
+    return asSequence(asReversed(toList(this.p1m(clause))));
+  };
+  protoOf(ReteClauseQueue).getLifoOrdered = function (clause) {
+    return this.q1m(clause);
+  };
+  protoOf(ReteClauseQueue).r1l = function (clause) {
+    return this.d1m(clause);
+  };
+  protoOf(ReteClauseQueue).add = function (clause) {
+    return this.r1l(clause);
+  };
+  protoOf(ReteClauseQueue).u1l = function (clause) {
+    return protoOf(AbstractReteClauseCollection).u1l.call(this, clause);
+  };
+  protoOf(ReteClauseQueue).retrieve = function (clause) {
+    return this.u1l(clause);
+  };
+  protoOf(ReteClauseQueue).e1m = function (clause) {
+    return protoOf(AbstractReteClauseCollection).u1l.call(this, clause);
+  };
+  protoOf(ReteClauseQueue).retrieveFirst = function (clause) {
+    return this.e1m(clause);
+  };
+  protoOf(ReteClauseQueue).z1l = 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_instance_4.areEquals(this, other);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(ReteClauseQueue).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q(this);
+  };
+  protoOf(ReteClauseQueue).g1l = 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.c1n_1 = $source;
+    this.d1n_1 = this$0;
+    this.e1n_1 = $clause;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(AbstractReteNode$removeAllLazily$slambda).rq = function ($this$sequence, $completion) {
+    var tmp = this.sq($this$sequence, $completion);
+    tmp.hb_1 = Unit_instance;
+    tmp.ib_1 = null;
+    return tmp.qb();
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).dc = function (p1, $completion) {
+    return this.rq(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).qb = function () {
+    var suspendResult = this.hb_1;
+    $sm: do
+      try {
+        var tmp = this.fb_1;
+        switch (tmp) {
+          case 0:
+            this.gb_1 = 5;
+            this.g1n_1 = this.c1n_1.r();
+            this.fb_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.g1n_1.s()) {
+              this.fb_1 = 4;
+              continue $sm;
+            }
+
+            this.h1n_1 = this.g1n_1.u();
+            if (this.d1n_1.e1l().match(this.h1n_1.k1n(), this.e1n_1)) {
+              this.h1n_1.i1n();
+              this.g1n_1.t();
+              this.fb_1 = 2;
+              suspendResult = this.f1n_1.wd(this.h1n_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.fb_1 = 3;
+              continue $sm;
+            }
+
+          case 2:
+            this.fb_1 = 3;
+            continue $sm;
+          case 3:
+            this.fb_1 = 1;
+            continue $sm;
+          case 4:
+            return Unit_instance;
+          case 5:
+            throw this.ib_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.gb_1 === 5) {
+          throw e;
+        } else {
+          this.fb_1 = this.gb_1;
+          this.ib_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).sq = function ($this$sequence, completion) {
+    var i = new AbstractReteNode$removeAllLazily$slambda(this.c1n_1, this.d1n_1, this.e1n_1, completion);
+    i.f1n_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.rq($this$sequence, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function AbstractReteNode(unificator) {
+    this.j1n_1 = unificator;
+  }
+  protoOf(AbstractReteNode).e1l = function () {
+    return this.j1n_1;
+  };
+  protoOf(AbstractReteNode).l1n = function (source, clause) {
+    return sequence(AbstractReteNode$removeAllLazily$slambda_0(source, this, clause, null));
+  };
+  function Companion_1() {
+  }
+  protoOf(Companion_1).l1m = function (unificator, clauses) {
+    return new RootNode(unificator, clauses, true);
+  };
+  var Companion_instance_6;
+  function Companion_getInstance_4() {
+    return Companion_instance_6;
+  }
+  function firstArguments(_this__u8e3s4, $this) {
+    return sequence(Utils$firstArguments$slambda_0(_this__u8e3s4, null));
+  }
+  function Utils$firstArguments$slambda($this_firstArguments, resultContinuation) {
+    this.y1n_1 = $this_firstArguments;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(Utils$firstArguments$slambda).b1o = function ($this$sequence, $completion) {
+    var tmp = this.c1o($this$sequence, $completion);
+    tmp.hb_1 = Unit_instance;
+    tmp.ib_1 = null;
+    return tmp.qb();
+  };
+  protoOf(Utils$firstArguments$slambda).dc = function (p1, $completion) {
+    return this.b1o(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(Utils$firstArguments$slambda).qb = function () {
+    var suspendResult = this.hb_1;
+    $sm: do
+      try {
+        var tmp = this.fb_1;
+        switch (tmp) {
+          case 0:
+            this.gb_1 = 5;
+            this.a1o_1 = this.y1n_1;
+            this.fb_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.a1o_1.fv()) {
+              this.fb_1 = 3;
+              continue $sm;
+            }
+
+            this.fb_1 = 2;
+            suspendResult = this.z1n_1.wd(this.a1o_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.a1o_1 = this.a1o_1.castToStruct().getArgAt(0);
+            this.fb_1 = 1;
+            continue $sm;
+          case 3:
+            this.fb_1 = 4;
+            suspendResult = this.z1n_1.wd(this.a1o_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 4:
+            return Unit_instance;
+          case 5:
+            throw this.ib_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.gb_1 === 5) {
+          throw e;
+        } else {
+          this.fb_1 = this.gb_1;
+          this.ib_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(Utils$firstArguments$slambda).c1o = function ($this$sequence, completion) {
+    var i = new Utils$firstArguments$slambda(this.y1n_1, completion);
+    i.z1n_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.b1o($this$sequence, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function SituatedIndexedClause$compareTo$ref() {
+    var l = function (p0, p1) {
+      return p0.cs(p1);
+    };
+    l.callableName = 'compareTo';
+    return l;
+  }
+  function Utils() {
+  }
+  protoOf(Utils).d1o = function (_this__u8e3s4, nestingLevel) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.Utils.arityOfNestedFirstArgument.<anonymous>' call
+    return takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel).castToStruct().tu();
+  };
+  protoOf(Utils).e1o = function (_this__u8e3s4, nestingLevel) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.Utils.functorOfNestedFirstArgument.<anonymous>' call
+    return takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel).castToStruct().zu();
+  };
+  protoOf(Utils).f1o = function (_this__u8e3s4, nestingLevel) {
+    return takeFirstAfterSkipping(firstArguments(_this__u8e3s4, this), nestingLevel);
+  };
+  protoOf(Utils).g1o = function (args) {
+    return this.h1o(listOf(args.slice()));
+  };
+  protoOf(Utils).i1o = function (sequence) {
+    return this.h1o(asIterable(sequence));
+  };
+  protoOf(Utils).h1o = function (iterable) {
+    return mergeSequences(iterable, SituatedIndexedClause$compareTo$ref());
+  };
+  protoOf(Utils).j1o = function (args) {
+    return this.k1o(sequenceOf(args.slice()));
+  };
+  protoOf(Utils).k1o = function (sequence) {
+    return flatten(sequence);
+  };
+  protoOf(Utils).l1o = function (iterable) {
+    return this.k1o(asSequence(iterable));
+  };
+  protoOf(Utils).m1o = function (args) {
+    return this.n1o(sequenceOf(args.slice()));
+  };
+  protoOf(Utils).n1o = function (sequence) {
+    return flatten(sequence);
+  };
+  protoOf(Utils).o1o = function (a, b) {
+    return (a == null ? b == null : false) ? null : a == null ? b : b == null ? a : a.cs(b) < 0 ? a : b;
+  };
+  var Utils_instance;
+  function Utils_getInstance() {
+    return Utils_instance;
+  }
+  function IndexedClause$Companion$wrap$1($traversed, $indexedClause) {
+    this.q1o_1 = $indexedClause;
+    this.p1o_1 = listOf($traversed.slice());
+  }
+  protoOf(IndexedClause$Companion$wrap$1).bq = function () {
+    return this.q1o_1.bq();
+  };
+  protoOf(IndexedClause$Companion$wrap$1).r2 = function () {
+    return this.q1o_1.r2();
+  };
+  protoOf(IndexedClause$Companion$wrap$1).r1o = function () {
+    return this.p1o_1;
+  };
+  protoOf(IndexedClause$Companion$wrap$1).i1n = function () {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = this.p1o_1.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.clause.<no name provided>.invalidateAllCaches.<anonymous>' call
+      element.p1n();
+    }
+  };
+  protoOf(IndexedClause$Companion$wrap$1).d = function (other) {
+    return this.cs((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_2() {
+  }
+  protoOf(Companion_2).t1o = function (indexedClause, traversed) {
+    return new IndexedClause$Companion$wrap$1(traversed, indexedClause);
+  };
+  protoOf(Companion_2).u1o = function (index, clause, traversed) {
+    return this.t1o(Companion_instance_0.bs(index, clause), traversed.slice());
+  };
+  protoOf(Companion_2).v1o = function (index, clause, traversed) {
+    var tmp = Companion_instance_0.bs(index, clause);
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var tmp$ret$0 = copyToArray(traversed);
+    return this.t1o(tmp, tmp$ret$0.slice());
+  };
+  var Companion_instance_7;
+  function Companion_getInstance_5() {
+    return Companion_instance_7;
+  }
+  function IndexedClause() {
+  }
+  function SituatedIndexedClause$Companion$of$1($indexed, $index) {
+    this.w1o_1 = $indexed;
+    this.x1o_1 = $index;
+  }
+  protoOf(SituatedIndexedClause$Companion$of$1).bq = function () {
+    return this.w1o_1.bq();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).r2 = function () {
+    return this.w1o_1.r2();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).y1o = function () {
+    this.x1o_1.z1o(this);
+    this.i1n();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).r1o = function () {
+    return this.w1o_1.r1o();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).i1n = function () {
+    this.w1o_1.i1n();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(!(other == null) ? isInterface(other, SituatedIndexedClause) : false))
+      return false;
+    if (!this.bq().equals(other.bq()))
+      return false;
+    return true;
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).d = function (other) {
+    return this.cs((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_3() {
+  }
+  protoOf(Companion_3).a1p = function (indexed, index) {
+    return new SituatedIndexedClause$Companion$of$1(indexed, index);
+  };
+  var Companion_instance_8;
+  function Companion_getInstance_6() {
+    return Companion_instance_8;
+  }
+  function SituatedIndexedClause() {
+  }
+  function AbstractIndexingLeaf(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  protoOf(AbstractIndexingLeaf).p1n = function () {
+  };
+  function extractFirst($this, clause) {
+    // Inline function 'kotlin.collections.mapNotNull' call
+    // Inline function 'kotlin.collections.mapNotNullTo' call
+    var this_0 = $this.j1p_1.m2();
+    var destination = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.extractFirst.<anonymous>' call
+      var tmp0_safe_receiver = extractFirst_0($this, clause, element);
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlin.contracts.contract' call
+        destination.o(tmp0_safe_receiver);
+      }
+    }
+    return minOrNull(destination);
+  }
+  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.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.extractFirst.<anonymous>' call
+        if ($this.e1l().match(item.k1n(), clause)) {
+          tmp$ret$1 = index_0;
+          break $l$block;
+        }
+        index_0 = index_0 + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    var actualIndex = tmp$ret$1;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.d1(actualIndex);
+    }
+    return tmp;
+  }
+  function nestedFirstArgument(_this__u8e3s4, $this) {
+    return Utils_instance.f1o(ensureNotNull(_this__u8e3s4.fx()), $this.i1p_1 + 1 | 0);
+  }
+  function asInnerAtom(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4, $this).castToAtom();
+  }
+  function asInnerAtom_0(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4.k1n(), $this).castToAtom();
+  }
+  function asInnerAtom_1(_this__u8e3s4, $this) {
+    return nestedFirstArgument(_this__u8e3s4.k1n(), $this).castToAtom();
+  }
+  function AtomIndex$_get_size_$lambda_ygjfwe(it) {
+    return it.l();
+  }
+  function AtomIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function AtomIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.l1n(it, $clause);
+    };
+  }
+  function AtomIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function AtomIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function AtomIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.h1p_1 = ordered;
+    this.i1p_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.j1p_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(AtomIndex).l = function () {
+    var tmp = asSequence(this.j1p_1.m2());
+    return sum(map(tmp, AtomIndex$_get_size_$lambda_ygjfwe));
+  };
+  protoOf(AtomIndex).k1l = function () {
+    var tmp;
+    if (this.j1p_1.z()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = this.j1p_1.m2();
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.z();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.<get-isEmpty>.<anonymous>' call
+          if (!element.z()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).m1n = function (clause) {
+    if (this.h1p_1) {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      var it = asInnerAtom_1(clause, this);
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.j1p_1;
+      var value = this_0.x2(it);
+      var tmp;
+      if (value == null) {
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.assertA.<anonymous>.<anonymous>' call
+        var answer = dequeOf([]);
+        this_0.o2(it, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      var tmp$ret$1 = tmp;
+      addFirst(tmp$ret$1, Companion_instance_8.a1p(clause.s1o(this), this));
+    } else {
+      this.n1n(clause);
+    }
+  };
+  protoOf(AtomIndex).n1n = function (clause) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.assertZ.<anonymous>' call
+    var it = asInnerAtom_1(clause, this);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.j1p_1;
+    var value = this_0.x2(it);
+    var tmp;
+    if (value == null) {
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.assertZ.<anonymous>.<anonymous>' call
+      var answer = dequeOf([]);
+      this_0.o2(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.o(Companion_instance_8.a1p(clause.s1o(this), this));
+  };
+  protoOf(AtomIndex).c1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).uu()) {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.AtomIndex.getFirstIndexed.<anonymous>' call
+      var it = this.j1p_1.x2(asInnerAtom(clause, this));
+      var tmp_0;
+      if (it == null) {
+        tmp_0 = null;
+      } else {
+        tmp_0 = extractFirst_0(this, clause, it);
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = extractFirst(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).d1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).uu()) {
+      var tmp0_safe_receiver = this.j1p_1.x2(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.f1p(clause);
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).z1o = function (indexed) {
+    ensureNotNull(this.j1p_1.x2(asInnerAtom_0(indexed, this))).p(indexed);
+  };
+  protoOf(AtomIndex).e1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(clause, this).uu()) {
+      var partialIndex = this.j1p_1.x2(asInnerAtom(clause, this));
+      tmp = partialIndex == null ? emptySequence() : this.l1n(partialIndex, clause);
+    } else {
+      var tmp_0 = Utils_instance;
+      var tmp_1 = asSequence(this.j1p_1.m2());
+      tmp = tmp_0.i1o(map(tmp_1, AtomIndex$retractAllIndexed$lambda(this, clause)));
+    }
+    return buffered(tmp);
+  };
+  protoOf(AtomIndex).o1n = function () {
+    var tmp = Utils_instance;
+    var tmp_0 = asSequence(this.j1p_1.m2());
+    return tmp.i1o(map(tmp_0, AtomIndex$getCache$lambda));
+  };
+  protoOf(AtomIndex).f1p = function (clause) {
+    var tmp = this.o1n();
+    return filter(tmp, AtomIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function nestedFunctor(_this__u8e3s4, $this) {
+    return Utils_instance.e1o(ensureNotNull(_this__u8e3s4.fx()), $this.m1p_1);
+  }
+  function nestedFunctor_0(_this__u8e3s4, $this) {
+    return Utils_instance.e1o(ensureNotNull(_this__u8e3s4.k1n().fx()), $this.m1p_1);
+  }
+  function isGlobal(_this__u8e3s4, $this) {
+    return Utils_instance.f1o(ensureNotNull(_this__u8e3s4.fx()), $this.m1p_1).vv();
+  }
+  function regenerateCache($this) {
+    var tmp;
+    if ($this.l1p_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.n1p_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.regenerateCache.<anonymous>' call
+        var tmp$ret$0 = item.o1n();
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.n1p_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var item_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.regenerateCache.<anonymous>' call
+        var tmp$ret$3 = item_0.o1n();
+        destination_0.o(tmp$ret$3);
+      }
+      tmp = tmp_1.l1o(destination_0);
+    }
+    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.l();
+  }
+  function CompoundIndex(unificator, ordered, nestingLevel) {
+    AbstractReteNode.call(this, unificator);
+    this.l1p_1 = ordered;
+    this.m1p_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.n1p_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.o1p_1 = tmp_1.np(CompoundIndex$regenerateCache$ref(this));
+  }
+  protoOf(CompoundIndex).l = function () {
+    var tmp = asSequence(this.n1p_1.m2());
+    return sum(map(tmp, CompoundIndex$_get_size_$lambda_91vt0k));
+  };
+  protoOf(CompoundIndex).k1l = function () {
+    var tmp;
+    if (this.n1p_1.z()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = this.n1p_1.m2();
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.z();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.<get-isEmpty>.<anonymous>' call
+          if (!element.k1l()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).m1n = function (clause) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    var it = nestedFunctor_0(clause, this);
+    var tmp;
+    if (this.l1p_1) {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.n1p_1;
+      var value = this_0.x2(it);
+      var tmp_0;
+      if (value == null) {
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.assertA.<anonymous>.<anonymous>' call
+        var answer = new FunctorIndexingNode(this.e1l(), this.l1p_1, this.m1p_1);
+        this_0.o2(it, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp_0.m1n(clause.s1o(this));
+      tmp = Unit_instance;
+    } else {
+      this.n1n(clause);
+      tmp = Unit_instance;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).n1n = function (clause) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    var it = nestedFunctor_0(clause, this);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.n1p_1;
+    var value = this_0.x2(it);
+    var tmp;
+    if (value == null) {
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.assertZ.<anonymous>.<anonymous>' call
+      var answer = new FunctorIndexingNode(this.e1l(), this.l1p_1, this.m1p_1);
+      this_0.o2(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.n1n(clause.s1o(this));
+    return Unit_instance;
+  };
+  protoOf(CompoundIndex).o1n = function () {
+    return asSequence(this.o1p_1.r2());
+  };
+  protoOf(CompoundIndex).c1p = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.mapNotNull' call
+      // Inline function 'kotlin.collections.mapNotNullTo' call
+      var this_0 = this.n1p_1.m2();
+      var destination = ArrayList_init_$Create$_0();
+      // Inline function 'kotlin.collections.forEach' call
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var element = tmp0_iterator.u();
+        // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.getFirstIndexed.<anonymous>' call
+        var tmp0_safe_receiver = element.c1p(clause);
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          // Inline function 'kotlin.contracts.contract' call
+          destination.o(tmp0_safe_receiver);
+        }
+      }
+      tmp = firstOrNull(tmp_0.i1o(sequenceOf([asSequence(destination)])));
+    } else {
+      var tmp0_safe_receiver_0 = this.n1p_1.x2(nestedFunctor(clause, this));
+      tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.c1p(clause);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).d1p = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.n1p_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.getIndexed.<anonymous>' call
+        var tmp$ret$0 = item.f1p(clause);
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp0_safe_receiver = this.n1p_1.x2(nestedFunctor(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.d1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).e1p = function (clause) {
+    var tmp;
+    if (isGlobal(clause, this)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.n1p_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.retractAllIndexed.<anonymous>' call
+        var tmp$ret$0 = item.e1p(clause);
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp0_safe_receiver = this.n1p_1.x2(nestedFunctor(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).f1p = function (clause) {
+    var tmp;
+    if (this.l1p_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.n1p_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.extractGlobalIndexedSequence.<anonymous>' call
+        var tmp$ret$0 = item.f1p(clause);
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = this.n1p_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var item_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.CompoundIndex.extractGlobalIndexedSequence.<anonymous>' call
+        var tmp$ret$3 = item_0.f1p(clause);
+        destination_0.o(tmp$ret$3);
+      }
+      tmp = tmp_1.l1o(destination_0);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).p1n = function () {
+    this.o1p_1.pp();
+  };
+  function DirectiveIndex$retractFirst$lambda(it) {
+    return it.k1n();
+  }
+  function DirectiveIndex$retractAll$lambda(it) {
+    return it.k1n();
+  }
+  function DirectiveIndex$getCache$lambda(it) {
+    var tmp = Companion_instance_8;
+    return tmp.a1p(it, new DirectiveIndex$getCache$1$1());
+  }
+  function DirectiveIndex$getCache$1$1() {
+  }
+  protoOf(DirectiveIndex$getCache$1$1).z1o = function (indexed) {
+    // Inline function 'kotlin.TODO' call
+    var reason = '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: ' + reason);
+  };
+  function DirectiveIndex(unificator, ordered) {
+    AbstractReteNode.call(this, unificator);
+    this.q1p_1 = ordered;
+    this.r1p_1 = dequeOf([]);
+  }
+  protoOf(DirectiveIndex).l = function () {
+    return this.r1p_1.l();
+  };
+  protoOf(DirectiveIndex).k1l = function () {
+    return this.r1p_1.z();
+  };
+  protoOf(DirectiveIndex).n1l = function (clause) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var this_0 = this.r1p_1;
+    var destination = ArrayList_init_$Create$_0();
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.DirectiveIndex.get.<anonymous>' call
+      if (this.e1l().match(element.k1n(), clause)) {
+        destination.o(element);
+      }
+    }
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(destination, 10));
+    var tmp0_iterator_0 = destination.r();
+    while (tmp0_iterator_0.s()) {
+      var item = tmp0_iterator_0.u();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.DirectiveIndex.get.<anonymous>' call
+      var tmp$ret$3 = item.k1n();
+      destination_0.o(tmp$ret$3);
+    }
+    return asSequence(destination_0);
+  };
+  protoOf(DirectiveIndex).m1n = function (clause) {
+    if (this.q1p_1) {
+      addFirst(this.r1p_1, clause.s1o(this));
+    } else {
+      this.n1n(clause);
+    }
+  };
+  protoOf(DirectiveIndex).n1n = function (clause) {
+    this.r1p_1.o(clause.s1o(this));
+  };
+  protoOf(DirectiveIndex).v1l = function (clause) {
+    var tmp = this.l1n(this.r1p_1, clause);
+    return buffered(take(map(tmp, DirectiveIndex$retractFirst$lambda), 1));
+  };
+  protoOf(DirectiveIndex).x1l = function (clause) {
+    var tmp = this.l1n(this.r1p_1, clause);
+    return buffered(map(tmp, DirectiveIndex$retractAll$lambda));
+  };
+  protoOf(DirectiveIndex).o1n = function () {
+    var tmp = asSequence(this.r1p_1);
+    return map(tmp, DirectiveIndex$getCache$lambda);
+  };
+  protoOf(DirectiveIndex).p1n = function () {
+  };
+  function extractFirst_1($this, clause) {
+    // Inline function 'kotlin.collections.mapNotNull' call
+    // Inline function 'kotlin.collections.mapNotNullTo' call
+    var this_0 = $this.v1p_1.m2();
+    var destination = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.extractFirst.<anonymous>' call
+      var tmp0_safe_receiver = extractFirst_2($this, clause, element);
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlin.contracts.contract' call
+        destination.o(tmp0_safe_receiver);
+      }
+    }
+    return minOrNull(destination);
+  }
+  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.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.extractFirst.<anonymous>' call
+        if ($this.e1l().match(item.k1n(), clause)) {
+          tmp$ret$1 = index_0;
+          break $l$block;
+        }
+        index_0 = index_0 + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    var actualIndex = tmp$ret$1;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.d1(actualIndex);
+    }
+    return tmp;
+  }
+  function nestedFirstArgument_0(_this__u8e3s4, $this) {
+    return Utils_instance.f1o(ensureNotNull(_this__u8e3s4.fx()), $this.u1p_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.k1n(), $this).castToNumeric();
+  }
+  function asInnerNumeric_1(_this__u8e3s4, $this) {
+    return nestedFirstArgument_0(_this__u8e3s4.k1n(), $this).castToNumeric();
+  }
+  function NumericIndex$_get_size_$lambda_exo30i(it) {
+    return it.l();
+  }
+  function NumericIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function NumericIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.l1n(it, $clause);
+    };
+  }
+  function NumericIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function NumericIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function NumericIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.t1p_1 = ordered;
+    this.u1p_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.v1p_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(NumericIndex).l = function () {
+    var tmp = asSequence(this.v1p_1.m2());
+    return sum(map(tmp, NumericIndex$_get_size_$lambda_exo30i));
+  };
+  protoOf(NumericIndex).k1l = function () {
+    var tmp;
+    if (this.v1p_1.z()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = this.v1p_1.m2();
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.z();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.<get-isEmpty>.<anonymous>' call
+          if (!element.z()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).m1n = function (clause) {
+    if (this.t1p_1) {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      var it = asInnerNumeric_1(clause, this);
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.v1p_1;
+      var value = this_0.x2(it);
+      var tmp;
+      if (value == null) {
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.assertA.<anonymous>.<anonymous>' call
+        var answer = dequeOf([]);
+        this_0.o2(it, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      var tmp$ret$1 = tmp;
+      addFirst(tmp$ret$1, Companion_instance_8.a1p(clause.s1o(this), this));
+    } else {
+      this.n1n(clause);
+    }
+  };
+  protoOf(NumericIndex).n1n = function (clause) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.assertZ.<anonymous>' call
+    var it = asInnerNumeric_1(clause, this);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.v1p_1;
+    var value = this_0.x2(it);
+    var tmp;
+    if (value == null) {
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.NumericIndex.assertZ.<anonymous>.<anonymous>' call
+      var answer = dequeOf([]);
+      this_0.o2(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.o(Companion_instance_8.a1p(clause.s1o(this), this));
+  };
+  protoOf(NumericIndex).c1p = function (clause) {
+    if (nestedFirstArgument_0(clause, this).zv()) {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      var it = this.v1p_1.x2(asInnerNumeric(clause, this));
+      var tmp;
+      if (it == null) {
+        tmp = null;
+      } else {
+        tmp = extractFirst_2(this, clause, it);
+      }
+      return tmp;
+    } else {
+      return extractFirst_1(this, clause);
+    }
+  };
+  protoOf(NumericIndex).d1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(clause, this).zv()) {
+      var tmp0_safe_receiver = this.v1p_1.x2(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.f1p(clause);
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).z1o = function (indexed) {
+    ensureNotNull(this.v1p_1.x2(asInnerNumeric_0(indexed, this))).p(indexed);
+  };
+  protoOf(NumericIndex).e1p = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(clause, this).zv()) {
+      var partialIndex = this.v1p_1.x2(asInnerNumeric(clause, this));
+      tmp = partialIndex == null ? emptySequence() : buffered(this.l1n(partialIndex, clause));
+    } else {
+      var tmp_0 = Utils_instance;
+      var tmp_1 = asSequence(this.v1p_1.m2());
+      tmp = buffered(tmp_0.i1o(map(tmp_1, NumericIndex$retractAllIndexed$lambda(this, clause))));
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).o1n = function () {
+    var tmp = Utils_instance;
+    var tmp_0 = asSequence(this.v1p_1.m2());
+    return tmp.i1o(map(tmp_0, NumericIndex$getCache$lambda));
+  };
+  protoOf(NumericIndex).f1p = function (clause) {
+    var tmp = this.o1n();
+    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.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.leaf.VariableIndex.extractFirst.<anonymous>' call
+        if ($this.e1l().match(item.k1n(), clause)) {
+          tmp$ret$1 = index_0;
+          break $l$block;
+        }
+        index_0 = index_0 + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    var actualIndex = tmp$ret$1;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.d1(actualIndex);
+    }
+    return tmp;
+  }
+  function VariableIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function VariableIndex(unificator, ordered) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.x1p_1 = ordered;
+    this.y1p_1 = dequeOf([]);
+  }
+  protoOf(VariableIndex).l = function () {
+    return this.y1p_1.l();
+  };
+  protoOf(VariableIndex).k1l = function () {
+    return this.y1p_1.z();
+  };
+  protoOf(VariableIndex).m1n = function (clause) {
+    var tmp;
+    if (this.x1p_1) {
+      addFirst(this.y1p_1, Companion_instance_8.a1p(clause.s1o(this), this));
+      tmp = Unit_instance;
+    } else {
+      this.n1n(clause);
+      tmp = Unit_instance;
+    }
+    return tmp;
+  };
+  protoOf(VariableIndex).n1n = function (clause) {
+    this.y1p_1.o(Companion_instance_8.a1p(clause.s1o(this), this));
+  };
+  protoOf(VariableIndex).o1n = function () {
+    return asSequence(this.y1p_1);
+  };
+  protoOf(VariableIndex).c1p = function (clause) {
+    return extractFirst_3(this, clause, this.y1p_1);
+  };
+  protoOf(VariableIndex).d1p = function (clause) {
+    return this.f1p(clause);
+  };
+  protoOf(VariableIndex).z1o = function (indexed) {
+    this.y1p_1.p(indexed);
+  };
+  protoOf(VariableIndex).e1p = function (clause) {
+    return buffered(this.l1n(this.y1p_1, clause));
+  };
+  protoOf(VariableIndex).f1p = function (clause) {
+    var tmp = asSequence(this.y1p_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.h1q_1 = ordered;
+  }
+  protoOf(FamilyArityIndexingNode).c1p = function (clause) {
+    var tmp;
+    if (this.h1q_1) {
+      tmp = this.r1q(clause);
+    } else {
+      tmp = this.q1q(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).d1p = function (clause) {
+    var tmp;
+    if (this.h1q_1) {
+      tmp = this.t1q(clause);
+    } else {
+      tmp = this.s1q(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).e1p = function (clause) {
+    var tmp;
+    if (this.h1q_1) {
+      tmp = this.v1q(clause);
+    } else {
+      tmp = this.u1q(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).f1p = function (clause) {
+    var tmp;
+    if (this.h1q_1) {
+      tmp = Utils_instance.g1o([this.m1q_1.f1p(clause), this.l1q_1.f1p(clause), this.n1q_1.f1p(clause), this.o1q_1.f1p(clause)]);
+    } else {
+      tmp = Utils_instance.j1o([this.m1q_1.f1p(clause), this.l1q_1.f1p(clause), this.n1q_1.f1p(clause), this.o1q_1.f1p(clause)]);
+    }
+    return tmp;
+  };
+  function retractAllOrdered($this, clause) {
+    var tmp = $this.v1q(clause);
+    return map(tmp, FamilyArityReteNode$retractAllOrdered$lambda);
+  }
+  function getOrdered($this, clause) {
+    var tmp = $this.t1q(clause);
+    return map(tmp, FamilyArityReteNode$getOrdered$lambda);
+  }
+  function retractAllUnordered($this, clause) {
+    var tmp = $this.u1q(clause);
+    return map(tmp, FamilyArityReteNode$retractAllUnordered$lambda);
+  }
+  function getUnordered($this, clause) {
+    var tmp = $this.s1q(clause);
+    return map(tmp, FamilyArityReteNode$getUnordered$lambda);
+  }
+  function regenerateCache_0($this) {
+    var tmp;
+    if ($this.j1q_1) {
+      tmp = Utils_instance.g1o([$this.m1q_1.o1n(), $this.l1q_1.o1n(), $this.n1q_1.o1n(), $this.o1q_1.o1n()]);
+    } else {
+      tmp = Utils_instance.j1o([$this.m1q_1.o1n(), $this.l1q_1.o1n(), $this.n1q_1.o1n(), $this.o1q_1.o1n()]);
+    }
+    return dequeOf_0(tmp);
+  }
+  function nestedFirstArgument_1(_this__u8e3s4, $this) {
+    return Utils_instance.f1o(ensureNotNull(_this__u8e3s4.fx()), $this.k1q_1 + 1 | 0);
+  }
+  function assertByFirstParameter($this, clause) {
+    var innerFirst = nestedFirstArgument_1(clause.k1n(), $this);
+    return innerFirst.zv() ? $this.l1q_1 : innerFirst.uu() ? $this.m1q_1 : innerFirst.vv() ? $this.n1q_1 : $this.o1q_1;
+  }
+  function isGlobal_0(_this__u8e3s4, $this) {
+    return Utils_instance.f1o(ensureNotNull(_this__u8e3s4.fx()), $this.k1q_1 + 1 | 0).vv();
+  }
+  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.l();
+  }
+  function FamilyArityReteNode$get$lambda(it) {
+    return it.k1n();
+  }
+  function FamilyArityReteNode$get$lambda_0(it) {
+    return it.k1n();
+  }
+  function FamilyArityReteNode$retractAllOrdered$lambda(it) {
+    return it.k1n();
+  }
+  function FamilyArityReteNode$getOrdered$lambda(it) {
+    return it.k1n();
+  }
+  function FamilyArityReteNode$retractAllUnordered$lambda(it) {
+    return it.k1n();
+  }
+  function FamilyArityReteNode$getUnordered$lambda(it) {
+    return it.k1n();
+  }
+  function FamilyArityReteNode(unificator, ordered, nestingLevel) {
+    ArityNode.call(this, unificator);
+    this.j1q_1 = ordered;
+    this.k1q_1 = nestingLevel;
+    this.l1q_1 = new NumericIndex(unificator, this.j1q_1, this.k1q_1);
+    this.m1q_1 = new AtomIndex(unificator, this.j1q_1, this.k1q_1);
+    this.n1q_1 = new VariableIndex(unificator, this.j1q_1);
+    this.o1q_1 = new CompoundIndex(unificator, this.j1q_1, this.k1q_1 + 1 | 0);
+    var tmp = this;
+    var tmp_0 = Companion_instance_1;
+    tmp.p1q_1 = tmp_0.np(FamilyArityReteNode$regenerateCache$ref(this));
+  }
+  protoOf(FamilyArityReteNode).v1l = function (clause) {
+    var tmp;
+    if (this.j1q_1) {
+      tmp = this.r1q(clause);
+    } else {
+      tmp = this.q1q(clause);
+    }
+    var result = tmp;
+    var tmp_0;
+    if (result == null) {
+      tmp_0 = emptySequence();
+    } else {
+      result.y1o();
+      this.p1n();
+      tmp_0 = sequenceOf([result.k1n()]);
+    }
+    return tmp_0;
+  };
+  protoOf(FamilyArityReteNode).l = function () {
+    var tmp = sequenceOf([this.l1q_1, this.m1q_1, this.n1q_1, this.o1q_1]);
+    return sum(map(tmp, FamilyArityReteNode$_get_size_$lambda_sxz8zo));
+  };
+  protoOf(FamilyArityReteNode).k1l = function () {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var tmp0_iterator = sequenceOf([this.l1q_1, this.m1q_1, this.n1q_1, this.o1q_1]).r();
+      while (tmp0_iterator.s()) {
+        var element = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FamilyArityReteNode.<get-isEmpty>.<anonymous>' call
+        if (!element.k1l()) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    return tmp$ret$1;
+  };
+  protoOf(FamilyArityReteNode).n1l = function (clause) {
+    var tmp;
+    if (isGlobal_0(clause, this)) {
+      var tmp_0;
+      if (this.j1q_1) {
+        var tmp_1 = Utils_instance.g1o([this.m1q_1.f1p(clause), this.n1q_1.f1p(clause), this.l1q_1.f1p(clause), this.o1q_1.f1p(clause)]);
+        tmp_0 = map(tmp_1, FamilyArityReteNode$get$lambda);
+      } else {
+        var tmp_2 = Utils_instance.j1o([this.m1q_1.f1p(clause), this.n1q_1.f1p(clause), this.l1q_1.f1p(clause), this.o1q_1.f1p(clause)]);
+        tmp_0 = map(tmp_2, FamilyArityReteNode$get$lambda_0);
+      }
+      tmp = tmp_0;
+    } else {
+      var tmp_3;
+      if (this.j1q_1) {
+        tmp_3 = getOrdered(this, clause);
+      } else {
+        tmp_3 = getUnordered(this, clause);
+      }
+      tmp = tmp_3;
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).m1n = function (clause) {
+    return assertByFirstParameter(this, clause).m1n(clause.s1o(this));
+  };
+  protoOf(FamilyArityReteNode).n1n = function (clause) {
+    return assertByFirstParameter(this, clause).n1n(clause.s1o(this));
+  };
+  protoOf(FamilyArityReteNode).x1l = function (clause) {
+    var tmp;
+    if (this.j1q_1) {
+      tmp = retractAllOrdered(this, clause);
+    } else {
+      tmp = retractAllUnordered(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).o1n = function () {
+    return asSequence(this.p1q_1.r2());
+  };
+  protoOf(FamilyArityReteNode).v1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.zv()) {
+      tmp = Utils_instance.g1o([this.n1q_1.e1p(clause), this.l1q_1.e1p(clause)]);
+    } else if (innerFirst.uu()) {
+      tmp = Utils_instance.g1o([this.n1q_1.e1p(clause), this.m1q_1.e1p(clause)]);
+    } else if (innerFirst.vv()) {
+      tmp = Utils_instance.g1o([this.n1q_1.e1p(clause), this.l1q_1.e1p(clause), this.m1q_1.e1p(clause), this.o1q_1.e1p(clause)]);
+    } else {
+      tmp = Utils_instance.g1o([this.n1q_1.e1p(clause), this.o1q_1.e1p(clause)]);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).u1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.zv() ? Utils_instance.j1o([this.n1q_1.e1p(clause), this.l1q_1.e1p(clause)]) : innerFirst.uu() ? Utils_instance.j1o([this.n1q_1.e1p(clause), this.m1q_1.e1p(clause)]) : innerFirst.vv() ? Utils_instance.j1o([this.n1q_1.e1p(clause), this.l1q_1.e1p(clause), this.m1q_1.e1p(clause), this.o1q_1.e1p(clause)]) : Utils_instance.j1o([this.n1q_1.e1p(clause), this.o1q_1.e1p(clause)]);
+  };
+  protoOf(FamilyArityReteNode).t1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.zv() ? Utils_instance.g1o([this.n1q_1.d1p(clause), this.l1q_1.d1p(clause)]) : innerFirst.uu() ? Utils_instance.g1o([this.n1q_1.d1p(clause), this.m1q_1.d1p(clause)]) : innerFirst.vv() ? Utils_instance.g1o([this.n1q_1.d1p(clause), this.l1q_1.d1p(clause), this.m1q_1.d1p(clause), this.o1q_1.d1p(clause)]) : Utils_instance.g1o([this.n1q_1.d1p(clause), this.o1q_1.d1p(clause)]);
+  };
+  protoOf(FamilyArityReteNode).s1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    return innerFirst.zv() ? Utils_instance.j1o([this.n1q_1.d1p(clause), this.l1q_1.d1p(clause)]) : innerFirst.uu() ? Utils_instance.j1o([this.n1q_1.d1p(clause), this.m1q_1.d1p(clause)]) : innerFirst.vv() ? Utils_instance.j1o([this.n1q_1.d1p(clause), this.l1q_1.d1p(clause), this.m1q_1.d1p(clause), this.o1q_1.d1p(clause)]) : Utils_instance.j1o([this.n1q_1.d1p(clause), this.o1q_1.d1p(clause)]);
+  };
+  protoOf(FamilyArityReteNode).q1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.zv()) {
+      var tmp0_elvis_lhs = this.n1q_1.c1p(clause);
+      tmp = tmp0_elvis_lhs == null ? this.l1q_1.c1p(clause) : tmp0_elvis_lhs;
+    } else if (innerFirst.uu()) {
+      var tmp1_elvis_lhs = this.n1q_1.c1p(clause);
+      tmp = tmp1_elvis_lhs == null ? this.m1q_1.c1p(clause) : tmp1_elvis_lhs;
+    } else if (innerFirst.vv()) {
+      var tmp2_elvis_lhs = this.n1q_1.c1p(clause);
+      var tmp3_elvis_lhs = tmp2_elvis_lhs == null ? this.l1q_1.c1p(clause) : tmp2_elvis_lhs;
+      var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? this.m1q_1.c1p(clause) : tmp3_elvis_lhs;
+      tmp = tmp4_elvis_lhs == null ? this.o1q_1.c1p(clause) : tmp4_elvis_lhs;
+    } else {
+      var tmp5_elvis_lhs = this.n1q_1.c1p(clause);
+      tmp = tmp5_elvis_lhs == null ? this.o1q_1.c1p(clause) : tmp5_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).r1q = function (clause) {
+    var innerFirst = nestedFirstArgument_1(clause, this);
+    var tmp;
+    if (innerFirst.zv()) {
+      tmp = Utils_instance.o1o(this.l1q_1.c1p(clause), this.n1q_1.c1p(clause));
+    } else if (innerFirst.uu()) {
+      tmp = Utils_instance.o1o(this.m1q_1.c1p(clause), this.n1q_1.c1p(clause));
+    } else if (innerFirst.vv()) {
+      tmp = Utils_instance.o1o(Utils_instance.o1o(this.l1q_1.c1p(clause), this.m1q_1.c1p(clause)), Utils_instance.o1o(this.n1q_1.c1p(clause), this.o1q_1.c1p(clause)));
+    } else {
+      tmp = Utils_instance.o1o(this.n1q_1.c1p(clause), this.o1q_1.c1p(clause));
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).p1n = function () {
+    this.p1q_1.pp();
+  };
+  function isGlobal_1(_this__u8e3s4, $this) {
+    return _this__u8e3s4.hv() ? Utils_instance.f1o(_this__u8e3s4.castToRule().fx(), $this.y1q_1).vv() : 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.fx();
+    var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : Utils_instance.d1o(tmp1_safe_receiver, $this.y1q_1);
+    var tmp;
+    if (tmp2_elvis_lhs == null) {
+      var message = 'The nestedArity method cannot be invoked on non-rule clauses';
+      throw IllegalStateException_init_$Create$(toString(message));
+    } else {
+      tmp = tmp2_elvis_lhs;
+    }
+    return tmp;
+  }
+  function nestedArity_0(_this__u8e3s4, $this) {
+    return Utils_instance.d1o(ensureNotNull(_this__u8e3s4.k1n().fx()), $this.y1q_1);
+  }
+  function regenerateCache_1($this) {
+    var tmp;
+    if ($this.x1q_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.z1q_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.regenerateCache.<anonymous>' call
+        var tmp$ret$0 = item.o1n();
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.z1q_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var item_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.regenerateCache.<anonymous>' call
+        var tmp$ret$3 = item_0.o1n();
+        destination_0.o(tmp$ret$3);
+      }
+      tmp = tmp_1.l1o(destination_0);
+    }
+    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.l();
+  }
+  function FunctorIndexingNode$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function FunctorIndexingNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.x1q_1 = ordered;
+    this.y1q_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.z1q_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.a1r_1 = tmp_1.np(FunctorIndexingNode$regenerateCache$ref(this));
+  }
+  protoOf(FunctorIndexingNode).l = function () {
+    var tmp = asSequence(this.z1q_1.m2());
+    return sum(map(tmp, FunctorIndexingNode$_get_size_$lambda_vcufvm));
+  };
+  protoOf(FunctorIndexingNode).k1l = function () {
+    var tmp;
+    if (this.z1q_1.z()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = this.z1q_1.m2();
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.z();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.<get-isEmpty>.<anonymous>' call
+          if (!element.k1l()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).m1n = function (clause) {
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.z1q_1;
+    var key = nestedArity_0(clause, this);
+    var value = this_0.x2(key);
+    var tmp;
+    if (value == null) {
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.assertA.<anonymous>' call
+      var answer = new FamilyArityIndexingNode(this.e1l(), this.x1q_1, this.y1q_1);
+      this_0.o2(key, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.m1n(clause.s1o(this));
+  };
+  protoOf(FunctorIndexingNode).n1n = function (clause) {
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.z1q_1;
+    var key = nestedArity_0(clause, this);
+    var value = this_0.x2(key);
+    var tmp;
+    if (value == null) {
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.assertZ.<anonymous>' call
+      var answer = new FamilyArityIndexingNode(this.e1l(), this.x1q_1, this.y1q_1);
+      this_0.o2(key, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.n1n(clause.s1o(this));
+  };
+  protoOf(FunctorIndexingNode).o1n = function () {
+    return asSequence(this.a1r_1.r2());
+  };
+  protoOf(FunctorIndexingNode).c1p = 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_instance;
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = this.z1q_1.m2();
+        // Inline function 'kotlin.collections.mapTo' call
+        var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var item = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getFirstIndexed.<anonymous>' call
+          var tmp$ret$0 = item.f1p(clause);
+          destination.o(tmp$ret$0);
+        }
+        var tmp0_iterator_0 = tmp_0.h1o(destination).r();
+        while (tmp0_iterator_0.s()) {
+          var element = tmp0_iterator_0.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getFirstIndexed.<anonymous>' call
+          if (this.e1l().match(element.k1n(), clause)) {
+            tmp$ret$4 = element;
+            break $l$block;
+          }
+        }
+        tmp$ret$4 = null;
+      }
+      tmp = tmp$ret$4;
+    } else {
+      var tmp0_safe_receiver = this.z1q_1.x2(nestedArity(clause, this));
+      tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1p(clause);
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).d1p = function (clause) {
+    var tmp;
+    if (isGlobal_1(clause, this)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.z1q_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.getIndexed.<anonymous>' call
+        var tmp$ret$0 = item.f1p(clause);
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp0_safe_receiver = this.z1q_1.x2(nestedArity(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.d1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).e1p = function (clause) {
+    var tmp;
+    if (isGlobal_1(clause, this)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.z1q_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.retractAllIndexed.<anonymous>' call
+        var tmp$ret$0 = item.f1p(clause);
+        destination.o(tmp$ret$0);
+      }
+      var tmp_1 = tmp_0.h1o(destination);
+      var partialResult = toList(filter(tmp_1, FunctorIndexingNode$retractAllIndexed$lambda(this, clause)));
+      // Inline function 'kotlin.collections.isNotEmpty' call
+      if (!partialResult.z()) {
+        this.p1n();
+        // Inline function 'kotlin.collections.forEach' call
+        var tmp0_iterator_0 = partialResult.r();
+        while (tmp0_iterator_0.s()) {
+          var element = tmp0_iterator_0.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.retractAllIndexed.<anonymous>' call
+          element.y1o();
+        }
+      }
+      tmp = asSequence(partialResult);
+    } else {
+      var tmp0_safe_receiver = this.z1q_1.x2(nestedArity(clause, this));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1p(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).f1p = function (clause) {
+    var tmp;
+    if (this.x1q_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.z1q_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.extractGlobalIndexedSequence.<anonymous>' call
+        var tmp$ret$0 = item.f1p(clause);
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = this.z1q_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var item_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.FunctorIndexingNode.extractGlobalIndexedSequence.<anonymous>' call
+        var tmp$ret$3 = item_0.f1p(clause);
+        destination_0.o(tmp$ret$3);
+      }
+      tmp = tmp_1.l1o(destination_0);
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).p1n = function () {
+    this.a1r_1.pp();
+  };
+  function FunctorNode(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  function assignHigherIndex($this, clause) {
+    var tmp = Companion_instance_7;
+    $this.h1r_1 = $this.h1r_1.qa();
+    return tmp.u1o($this.h1r_1, clause, [$this]);
+  }
+  function assignLowerIndex($this, clause) {
+    var tmp = Companion_instance_7;
+    $this.g1r_1 = $this.g1r_1.ra();
+    return tmp.u1o($this.g1r_1, clause, [$this]);
+  }
+  function regenerateCache_2($this) {
+    var tmp;
+    if ($this.c1r_1) {
+      var tmp_0 = Utils_instance.g1o([$this.f1r_1.o1n(), $this.e1r_1.o1n()]);
+      tmp = map(tmp_0, RootNode$regenerateCache$lambda);
+    } else {
+      var tmp_1 = Utils_instance;
+      var tmp_2 = $this.f1r_1.o1n();
+      var tmp_3 = map(tmp_2, RootNode$regenerateCache$lambda_0);
+      var tmp_4 = $this.e1r_1.o1n();
+      tmp = tmp_1.m1o([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.r2().castToDirective();
+  }
+  function RootNode$_get_rules_$lambda_py6utr(it) {
+    return it.r2().castToRule();
+  }
+  function RootNode$assertA$lambda($clause) {
+    return function (it) {
+      addFirst(it, $clause);
+      return Unit_instance;
+    };
+  }
+  function RootNode$assertZ$lambda($clause) {
+    return function (it) {
+      return it.o($clause);
+    };
+  }
+  function RootNode$regenerateCache$lambda(it) {
+    return it.k1n();
+  }
+  function RootNode$regenerateCache$lambda_0(it) {
+    return it.k1n();
+  }
+  function RootNode$regenerateCache$lambda_1(it) {
+    return it.k1n();
+  }
+  function RootNode(unificator, clauses, isOrdered) {
+    this.b1r_1 = unificator;
+    this.c1r_1 = isOrdered;
+    var tmp = this;
+    var tmp_0 = Companion_instance_1;
+    tmp.d1r_1 = tmp_0.np(RootNode$regenerateCache$ref(this));
+    this.e1r_1 = new RuleNode(this.b1r_1, this.c1r_1);
+    this.f1r_1 = new DirectiveIndex(this.b1r_1, this.c1r_1);
+    this.g1r_1 = new Long(0, 0);
+    this.h1r_1 = new Long(0, 0);
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = clauses.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RootNode.<anonymous>' call
+      this.s1l(element);
+    }
+  }
+  protoOf(RootNode).e1l = function () {
+    return this.b1r_1;
+  };
+  protoOf(RootNode).n1m = function () {
+    return this.c1r_1;
+  };
+  protoOf(RootNode).l = function () {
+    return this.f1r_1.l() + this.e1r_1.l() | 0;
+  };
+  protoOf(RootNode).k1l = function () {
+    return this.f1r_1.k1l() ? this.e1r_1.k1l() : false;
+  };
+  protoOf(RootNode).p1l = function () {
+    return asSequence(this.d1r_1.r2());
+  };
+  protoOf(RootNode).i1l = function () {
+    var tmp = this.f1r_1.o1n();
+    return map(tmp, RootNode$_get_directives_$lambda_9lfp1g);
+  };
+  protoOf(RootNode).j1l = function () {
+    var tmp = this.e1r_1.o1n();
+    return map(tmp, RootNode$_get_rules_$lambda_py6utr);
+  };
+  protoOf(RootNode).n1l = function (clause) {
+    var tmp;
+    if (clause.iv()) {
+      tmp = this.f1r_1.n1l(clause);
+    } else {
+      tmp = this.e1r_1.n1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).v1l = function (clause) {
+    var tmp;
+    if (clause.iv()) {
+      tmp = this.f1r_1.v1l(clause);
+    } else {
+      tmp = this.e1r_1.v1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).x1l = function (clause) {
+    var tmp;
+    if (clause.iv()) {
+      tmp = this.f1r_1.x1l(clause);
+    } else {
+      tmp = this.e1r_1.x1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).a1m = function () {
+    return new RootNode(this.b1r_1, asIterable(this.p1l()), this.c1r_1);
+  };
+  protoOf(RootNode).r1m = function (clause) {
+    var indexed = assignLowerIndex(this, clause);
+    if (this.c1r_1) {
+      this.d1r_1.qp(RootNode$assertA$lambda(clause));
+      if (clause.iv()) {
+        this.f1r_1.m1n(indexed);
+      } else {
+        this.e1r_1.m1n(indexed);
+      }
+    } else {
+      throw UnsupportedOperationException_init_$Create$('An unordered ReteTree cannot perform the assertA operation.');
+    }
+  };
+  protoOf(RootNode).s1l = function (clause) {
+    var indexed = assignHigherIndex(this, clause);
+    this.d1r_1.qp(RootNode$assertZ$lambda(clause));
+    if (clause.iv()) {
+      this.f1r_1.n1n(indexed);
+    } else {
+      this.e1r_1.n1n(indexed);
+    }
+  };
+  protoOf(RootNode).p1n = function () {
+    this.d1r_1.pp();
+  };
+  function nestedFunctor_1(_this__u8e3s4, $this) {
+    return Utils_instance.e1o(ensureNotNull(_this__u8e3s4.fx()), 0);
+  }
+  function nestedFunctor_2(_this__u8e3s4, $this) {
+    return nestedFunctor_1(_this__u8e3s4.k1n(), $this);
+  }
+  function regenerateCache_3($this) {
+    var tmp;
+    if ($this.j1r_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.k1r_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.regenerateCache.<anonymous>' call
+        var tmp$ret$0 = item.o1n();
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.k1r_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var item_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.regenerateCache.<anonymous>' call
+        var tmp$ret$3 = item_0.o1n();
+        destination_0.o(tmp$ret$3);
+      }
+      tmp = tmp_1.l1o(destination_0);
+    }
+    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.l();
+  }
+  function RuleNode(unificator, ordered) {
+    this.i1r_1 = unificator;
+    this.j1r_1 = ordered;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.k1r_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.l1r_1 = tmp_1.np(RuleNode$regenerateCache$ref(this));
+  }
+  protoOf(RuleNode).n1l = function (clause) {
+    var tmp0_safe_receiver = this.k1r_1.x2(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.n1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).m1n = function (clause) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    var it = nestedFunctor_2(clause, this);
+    var tmp;
+    if (this.j1r_1) {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.k1r_1;
+      var value = this_0.x2(it);
+      var tmp_0;
+      if (value == null) {
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.assertA.<anonymous>.<anonymous>' call
+        var answer = new TopLevelFunctorReteNode(this.i1r_1, this.j1r_1, 0);
+        this_0.o2(it, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp_0.m1n(clause.s1o(this));
+      tmp = Unit_instance;
+    } else {
+      this.n1n(clause);
+      tmp = Unit_instance;
+    }
+  };
+  protoOf(RuleNode).n1n = function (clause) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    var it = nestedFunctor_2(clause, this);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.k1r_1;
+    var value = this_0.x2(it);
+    var tmp;
+    if (value == null) {
+      // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.assertZ.<anonymous>.<anonymous>' call
+      var answer = new TopLevelFunctorReteNode(this.i1r_1, this.j1r_1, 0);
+      this_0.o2(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.n1n(clause.s1o(this));
+  };
+  protoOf(RuleNode).v1l = function (clause) {
+    var tmp0_safe_receiver = this.k1r_1.x2(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).l = function () {
+    var tmp = asSequence(this.k1r_1.m2());
+    return sum(map(tmp, RuleNode$_get_size_$lambda_xjenvf));
+  };
+  protoOf(RuleNode).k1l = function () {
+    var tmp;
+    if (this.k1r_1.z()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = this.k1r_1.m2();
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.z();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.RuleNode.<get-isEmpty>.<anonymous>' call
+          if (!element.k1l()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(RuleNode).x1l = function (clause) {
+    var tmp0_safe_receiver = this.k1r_1.x2(nestedFunctor_1(clause, this));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.x1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).o1n = function () {
+    return asSequence(this.l1r_1.r2());
+  };
+  protoOf(RuleNode).p1n = function () {
+    this.l1r_1.pp();
+  };
+  function selectArity($this, clause) {
+    return $this.p1r_1.x2(Utils_instance.d1o(ensureNotNull(clause.fx()), $this.o1r_1));
+  }
+  function chooseAssertionBranch($this, clause, op) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.chooseAssertionBranch.<anonymous>' call
+    var it = Utils_instance.d1o(ensureNotNull(clause.k1n().fx()), $this.o1r_1);
+    var tmp;
+    if (it === 0) {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = $this.p1r_1;
+      var value = this_0.x2(it);
+      var tmp_0;
+      if (value == null) {
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.chooseAssertionBranch.<anonymous>.<anonymous>' call
+        var answer = new ZeroArityReteNode($this.e1l(), $this.n1r_1);
+        this_0.o2(it, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp = tmp_0;
+    } else {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_1 = $this.p1r_1;
+      var value_0 = this_1.x2(it);
+      var tmp_1;
+      if (value_0 == null) {
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.chooseAssertionBranch.<anonymous>.<anonymous>' call
+        var answer_0 = new FamilyArityReteNode($this.e1l(), $this.n1r_1, $this.o1r_1);
+        this_1.o2(it, answer_0);
+        tmp_1 = answer_0;
+      } else {
+        tmp_1 = value_0;
+      }
+      tmp = tmp_1;
+    }
+    op(tmp, clause);
+  }
+  function regenerateCache_4($this) {
+    var tmp;
+    if ($this.n1r_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.p1r_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.r();
+      while (tmp0_iterator.s()) {
+        var item = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.regenerateCache.<anonymous>' call
+        var tmp$ret$0 = item.o1n();
+        destination.o(tmp$ret$0);
+      }
+      tmp = tmp_0.h1o(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.p1r_1.m2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var item_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.regenerateCache.<anonymous>' call
+        var tmp$ret$3 = item_0.o1n();
+        destination_0.o(tmp$ret$3);
+      }
+      tmp = tmp_1.l1o(destination_0);
+    }
+    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.l();
+  }
+  function ReteNode$assertA$ref() {
+    var l = function (p0, p1) {
+      p0.m1n(p1);
+      return Unit_instance;
+    };
+    l.callableName = 'assertA';
+    return l;
+  }
+  function ReteNode$assertZ$ref() {
+    var l = function (p0, p1) {
+      p0.n1n(p1);
+      return Unit_instance;
+    };
+    l.callableName = 'assertZ';
+    return l;
+  }
+  function TopLevelFunctorReteNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.n1r_1 = ordered;
+    this.o1r_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.p1r_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.q1r_1 = tmp_1.np(TopLevelFunctorReteNode$regenerateCache$ref(this));
+  }
+  protoOf(TopLevelFunctorReteNode).l = function () {
+    var tmp = asSequence(this.p1r_1.m2());
+    return sum(map(tmp, TopLevelFunctorReteNode$_get_size_$lambda_6i36rr));
+  };
+  protoOf(TopLevelFunctorReteNode).k1l = function () {
+    var tmp;
+    if (this.p1r_1.z()) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = this.p1r_1.m2();
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.z();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.collections.rete.custom.nodes.TopLevelFunctorReteNode.<get-isEmpty>.<anonymous>' call
+          if (!element.k1l()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(TopLevelFunctorReteNode).n1l = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.n1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).m1n = function (clause) {
+    var tmp = clause.s1o(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertA$ref());
+  };
+  protoOf(TopLevelFunctorReteNode).n1n = function (clause) {
+    var tmp = clause.s1o(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertZ$ref());
+  };
+  protoOf(TopLevelFunctorReteNode).v1l = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).x1l = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.x1l(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).o1n = function () {
+    return asSequence(this.q1r_1.r2());
+  };
+  protoOf(TopLevelFunctorReteNode).p1n = function () {
+    this.q1r_1.pp();
+  };
+  function ZeroArityReteNode$retractFirst$lambda(it) {
+    return it.k1n();
+  }
+  function ZeroArityReteNode$get$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.e1l().match(it.k1n(), $clause);
+    };
+  }
+  function ZeroArityReteNode$get$lambda_0(it) {
+    return it.k1n();
+  }
+  function ZeroArityReteNode$retractAll$lambda(it) {
+    return it.k1n();
+  }
+  function ZeroArityReteNode(unificator, ordered) {
+    ArityNode.call(this, unificator);
+    this.s1r_1 = ordered;
+    this.t1r_1 = dequeOf([]);
+  }
+  protoOf(ZeroArityReteNode).v1l = function (clause) {
+    var tmp = this.l1n(this.t1r_1, clause);
+    return buffered(take(map(tmp, ZeroArityReteNode$retractFirst$lambda), 1));
+  };
+  protoOf(ZeroArityReteNode).l = function () {
+    return this.t1r_1.l();
+  };
+  protoOf(ZeroArityReteNode).k1l = function () {
+    return this.t1r_1.z();
+  };
+  protoOf(ZeroArityReteNode).n1l = function (clause) {
+    var tmp = asSequence(this.t1r_1);
+    var tmp_0 = filter(tmp, ZeroArityReteNode$get$lambda(this, clause));
+    return map(tmp_0, ZeroArityReteNode$get$lambda_0);
+  };
+  protoOf(ZeroArityReteNode).m1n = function (clause) {
+    if (this.s1r_1) {
+      addFirst(this.t1r_1, Companion_instance_8.a1p(clause.s1o(this), this));
+    } else {
+      this.n1n(clause);
+    }
+  };
+  protoOf(ZeroArityReteNode).n1n = function (clause) {
+    this.t1r_1.o(Companion_instance_8.a1p(clause.s1o(this), this));
+  };
+  protoOf(ZeroArityReteNode).x1l = function (clause) {
+    var tmp = this.l1n(this.t1r_1, clause);
+    return buffered(map(tmp, ZeroArityReteNode$retractAll$lambda));
+  };
+  protoOf(ZeroArityReteNode).o1n = function () {
+    return asSequence(this.t1r_1);
+  };
+  protoOf(ZeroArityReteNode).p1n = function () {
+  };
+  protoOf(ZeroArityReteNode).z1o = function (indexed) {
+    this.t1r_1.p(indexed);
+  };
+  function AbstractTheory$get$lambda(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory$get$lambda_0(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory(tags) {
+    this.u1r_1 = tags;
+  }
+  protoOf(AbstractTheory).os = function () {
+    return this.u1r_1;
+  };
+  protoOf(AbstractTheory).v1r = function () {
+    return this;
+  };
+  protoOf(AbstractTheory).toImmutableTheory = function () {
+    return this.v1r();
+  };
+  protoOf(AbstractTheory).w1r = function (clause) {
+    return plus_2.call(this, TheoryUtils_instance.b1m(clause));
+  };
+  protoOf(AbstractTheory).plus = function (clause) {
+    return this.w1r(clause);
+  };
+  protoOf(AbstractTheory).m1l = function (clause) {
+    return any(this.get(clause));
+  };
+  protoOf(AbstractTheory).contains = function (clause) {
+    return this.m1l(clause);
+  };
+  protoOf(AbstractTheory).x1r = function (head) {
+    return this.m1l(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  };
+  protoOf(AbstractTheory).containsHead = function (head) {
+    return this.x1r(head);
+  };
+  protoOf(AbstractTheory).y1r = function (indicator) {
+    return any(this.z1r(indicator));
+  };
+  protoOf(AbstractTheory).containsIndicator = function (indicator) {
+    return this.y1r(indicator);
+  };
+  protoOf(AbstractTheory).a1s = function (head) {
+    var tmp = this.get(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+    return map(tmp, AbstractTheory$get$lambda);
+  };
+  protoOf(AbstractTheory).getByHead = function (head) {
+    return this.a1s(head);
+  };
+  protoOf(AbstractTheory).z1r = function (indicator) {
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!indicator.px()) {
+      // Inline function 'it.unibo.tuprolog.theory.AbstractTheory.get.<anonymous>' call
+      var message = 'The provided indicator is not well formed: ' + indicator;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    var tmp = Companion_instance_2;
+    var tmp_0 = Companion_getInstance_0();
+    var tmp_1 = ensureNotNull(indicator.iz());
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = numberRangeToNumber(1, ensureNotNull(indicator.jz()));
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.theory.AbstractTheory.get.<anonymous>' call
+      var tmp$ret$1 = Companion_getInstance().anonymous();
+      destination.o(tmp$ret$1);
+    }
+    var tmp_2 = this.get(tmp.of(tmp_0.ofList(tmp_1, destination), [Companion_getInstance().anonymous()]));
+    return map(tmp_2, AbstractTheory$get$lambda_0);
+  };
+  protoOf(AbstractTheory).getByIndicator = function (indicator) {
+    return this.z1r(indicator);
+  };
+  protoOf(AbstractTheory).b1s = function (indicator) {
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!indicator.px()) {
+      // Inline function 'it.unibo.tuprolog.theory.AbstractTheory.abolish.<anonymous>' call
+      var message = 'The provided indicator is not well formed: ' + indicator;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return this.retractAllByHead(Companion_getInstance_0().template(ensureNotNull(indicator.iz()), ensureNotNull(indicator.jz()))).c1s();
+  };
+  protoOf(AbstractTheory).abolish = function (indicator) {
+    return this.b1s(indicator);
+  };
+  protoOf(AbstractTheory).toString = function () {
+    return '' + getKClassFromExpression(this).o6() + '{ ' + joinToString(this.p1l(), '. ') + ' }';
+  };
+  protoOf(AbstractTheory).d1s = function (asPrologText) {
+    var tmp;
+    if (asPrologText) {
+      tmp = joinToString(this.p1l(), '.\n', '', '.\n');
+    } else {
+      tmp = this.toString();
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).toStringAsProlog = function (asPrologText) {
+    return this.d1s(asPrologText);
+  };
+  protoOf(AbstractTheory).r = function () {
+    return this.p1l().r();
+  };
+  protoOf(AbstractTheory).equals = function (other) {
+    if (other == null)
+      return false;
+    if (!(!(other == null) ? isInterface(other, Theory) : false))
+      return false;
+    return this.e1s(other, true);
+  };
+  protoOf(AbstractTheory).e1s = function (other, useVarCompleteName) {
+    if (this === other)
+      return true;
+    var i = this.p1l().r();
+    var j = other.p1l().r();
+    while (i.s() ? j.s() : false) {
+      if (!i.u().equalsUsingVarCompleteNames(j.u(), useVarCompleteName)) {
+        return false;
+      }
+    }
+    return i.s() === j.s();
+  };
+  protoOf(AbstractTheory).equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.e1s(other, useVarCompleteName);
+  };
+  protoOf(AbstractTheory).hashCode = function () {
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = getKClass(AbstractTheory).o6();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+    var base = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    var result = base ^ (base >>> 32 | 0);
+    var tmp0_iterator = this.p1l().r();
+    while (tmp0_iterator.s()) {
+      var clause = tmp0_iterator.u();
+      result = imul(31, result) + clause.hashCode() | 0;
+    }
+    return result;
+  };
+  protoOf(AbstractTheory).l = function () {
+    var i = new Long(0, 0);
+    var iter = this.r();
+    while (iter.s()) {
+      iter.u();
+      i = i.qa();
+    }
+    return i;
+  };
+  protoOf(AbstractTheory).k1l = function () {
+    return !this.f1s();
+  };
+  protoOf(AbstractTheory).f1s = function () {
+    return this.r().s();
+  };
+  protoOf(AbstractTheory).g1s = function (unificator) {
+    var tmp;
+    if (!equals(unificator, this.e1l())) {
+      tmp = this.h1s(asSequence(this.p1l()), VOID, unificator);
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).setUnificator = function (unificator) {
+    return this.g1s(unificator);
+  };
+  protoOf(AbstractTheory).i1s = function (theory) {
+    var tmp;
+    if (theory.f1s()) {
+      tmp = this.h1s(plus_0(asSequence(this.p1l()), TheoryUtils_instance.j1s(asSequence(theory.p1l()))));
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).plusTheory = function (theory) {
+    return this.i1s(theory);
+  };
+  protoOf(AbstractTheory).k1s = function (clause) {
+    return this.h1s(plus_0(TheoryUtils_instance.l1s([clause]), asSequence(this.p1l())));
+  };
+  protoOf(AbstractTheory).assertA = function (clause) {
+    return this.k1s(clause);
+  };
+  protoOf(AbstractTheory).m1s = function (clauses) {
+    return this.h1s(plus_0(TheoryUtils_instance.j1s(asSequence(clauses)), asSequence(this.p1l())));
+  };
+  protoOf(AbstractTheory).assertAIterable = function (clauses) {
+    return this.m1s(clauses);
+  };
+  protoOf(AbstractTheory).n1s = function (clauses) {
+    return this.h1s(plus_0(TheoryUtils_instance.j1s(clauses), asSequence(this.p1l())));
+  };
+  protoOf(AbstractTheory).assertASequence = function (clauses) {
+    return this.n1s(clauses);
+  };
+  protoOf(AbstractTheory).o1s = function (clause) {
+    return this.h1s(plus_0(asSequence(this.p1l()), TheoryUtils_instance.j1s(sequenceOf([clause]))));
+  };
+  protoOf(AbstractTheory).assertZ = function (clause) {
+    return this.o1s(clause);
+  };
+  protoOf(AbstractTheory).p1s = function (clauses) {
+    return this.h1s(plus_0(asSequence(this.p1l()), asSequence(TheoryUtils_instance.m1m(clauses))));
+  };
+  protoOf(AbstractTheory).assertZIterable = function (clauses) {
+    return this.p1s(clauses);
+  };
+  protoOf(AbstractTheory).q1s = function (clauses) {
+    return this.h1s(plus_0(asSequence(this.p1l()), TheoryUtils_instance.j1s(clauses)));
+  };
+  protoOf(AbstractTheory).assertZSequence = function (clauses) {
+    return this.q1s(clauses);
+  };
+  protoOf(AbstractTheory).h1s = function (clauses, tags, unificator, $super) {
+    tags = tags === VOID ? this.os() : tags;
+    unificator = unificator === VOID ? this.e1l() : unificator;
+    return $super === VOID ? this.r1s(clauses, tags, unificator) : $super.r1s.call(this, clauses, tags, unificator);
+  };
+  protoOf(AbstractTheory).s1s = function (clauses) {
+    return this.t1s(asIterable(clauses));
+  };
+  protoOf(AbstractTheory).retractSequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  protoOf(AbstractTheory).u1s = function () {
+    return this;
+  };
+  protoOf(AbstractTheory).clone = function () {
+    return this.u1s();
+  };
+  function Default() {
+    Default_instance = this;
+    this.w1s_1 = new IndexedTheoryFactory(Companion_getInstance_1().y1k());
+  }
+  protoOf(Default).e1l = function () {
+    return this.w1s_1.x1s_1;
+  };
+  protoOf(Default).d1l = function (unificator) {
+    return this.w1s_1.d1l(unificator);
+  };
+  protoOf(Default).emptyMutableTheory = function () {
+    return this.w1s_1.emptyMutableTheory();
+  };
+  protoOf(Default).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.w1s_1.y1s(unificator);
+  };
+  protoOf(Default).emptyTheory = function () {
+    return this.w1s_1.emptyTheory();
+  };
+  protoOf(Default).emptyTheoryWithUnificator = function (unificator) {
+    return this.w1s_1.z1s(unificator);
+  };
+  protoOf(Default).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.w1s_1.a1t(unificator, clauses);
+  };
+  protoOf(Default).mutableTheoryOf = function (clauses) {
+    return this.w1s_1.mutableTheoryOf(clauses);
+  };
+  protoOf(Default).mutableTheoryOfIterable = function (clauses) {
+    return this.w1s_1.mutableTheoryOfIterable(clauses);
+  };
+  protoOf(Default).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.w1s_1.b1t(clauses, unificator);
+  };
+  protoOf(Default).mutableTheoryOfSequence = function (clauses) {
+    return this.w1s_1.mutableTheoryOfSequence(clauses);
+  };
+  protoOf(Default).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.w1s_1.c1t(clauses, unificator);
+  };
+  protoOf(Default).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.w1s_1.d1t(unificator, clauses);
+  };
+  protoOf(Default).theoryOf = function (clauses) {
+    return this.w1s_1.theoryOf(clauses);
+  };
+  protoOf(Default).theoryOfIterable = function (clauses) {
+    return this.w1s_1.theoryOfIterable(clauses);
+  };
+  protoOf(Default).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.w1s_1.e1t(clauses, unificator);
+  };
+  protoOf(Default).theoryOfSequence = function (clauses) {
+    return this.w1s_1.theoryOfSequence(clauses);
+  };
+  protoOf(Default).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.w1s_1.f1t(clauses, unificator);
+  };
+  var Default_instance;
+  function Default_getInstance() {
+    if (Default_instance == null)
+      new Default();
+    return Default_instance;
+  }
+  function IndexedTheoryFactory(unificator) {
+    this.x1s_1 = unificator;
+  }
+  protoOf(IndexedTheoryFactory).e1l = function () {
+    return this.x1s_1;
+  };
+  protoOf(IndexedTheoryFactory).d1l = function (unificator) {
+    return new IndexedTheoryFactory(unificator);
+  };
+  protoOf(IndexedTheoryFactory).z1s = function (unificator) {
+    return IndexedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(IndexedTheoryFactory).emptyTheoryWithUnificator = function (unificator) {
+    return this.z1s(unificator);
+  };
+  protoOf(IndexedTheoryFactory).e1t = function (clauses, unificator) {
+    return IndexedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.e1t(clauses, unificator);
+  };
+  protoOf(IndexedTheoryFactory).d1t = function (unificator, clauses) {
+    return IndexedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(IndexedTheoryFactory).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.d1t(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).f1t = function (clauses, unificator) {
+    return IndexedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.f1t(clauses, unificator);
+  };
+  protoOf(IndexedTheoryFactory).y1s = function (unificator) {
+    return MutableIndexedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(IndexedTheoryFactory).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.y1s(unificator);
+  };
+  protoOf(IndexedTheoryFactory).b1t = function (clauses, unificator) {
+    return MutableIndexedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.b1t(clauses, unificator);
+  };
+  protoOf(IndexedTheoryFactory).a1t = function (unificator, clauses) {
+    return MutableIndexedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(IndexedTheoryFactory).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.a1t(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).c1t = function (clauses, unificator) {
+    return MutableIndexedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.c1t(clauses, unificator);
+  };
+  function Default_0() {
+    Default_instance_0 = this;
+    this.g1t_1 = new ListedTheoryFactory(Companion_getInstance_1().y1k());
+  }
+  protoOf(Default_0).e1l = function () {
+    return this.g1t_1.h1t_1;
+  };
+  protoOf(Default_0).d1l = function (unificator) {
+    return this.g1t_1.d1l(unificator);
+  };
+  protoOf(Default_0).emptyMutableTheory = function () {
+    return this.g1t_1.emptyMutableTheory();
+  };
+  protoOf(Default_0).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.g1t_1.y1s(unificator);
+  };
+  protoOf(Default_0).emptyTheory = function () {
+    return this.g1t_1.emptyTheory();
+  };
+  protoOf(Default_0).emptyTheoryWithUnificator = function (unificator) {
+    return this.g1t_1.z1s(unificator);
+  };
+  protoOf(Default_0).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.g1t_1.a1t(unificator, clauses);
+  };
+  protoOf(Default_0).mutableTheoryOf = function (clauses) {
+    return this.g1t_1.mutableTheoryOf(clauses);
+  };
+  protoOf(Default_0).mutableTheoryOfIterable = function (clauses) {
+    return this.g1t_1.mutableTheoryOfIterable(clauses);
+  };
+  protoOf(Default_0).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.g1t_1.b1t(clauses, unificator);
+  };
+  protoOf(Default_0).mutableTheoryOfSequence = function (clauses) {
+    return this.g1t_1.mutableTheoryOfSequence(clauses);
+  };
+  protoOf(Default_0).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.g1t_1.c1t(clauses, unificator);
+  };
+  protoOf(Default_0).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.g1t_1.d1t(unificator, clauses);
+  };
+  protoOf(Default_0).theoryOf = function (clauses) {
+    return this.g1t_1.theoryOf(clauses);
+  };
+  protoOf(Default_0).theoryOfIterable = function (clauses) {
+    return this.g1t_1.theoryOfIterable(clauses);
+  };
+  protoOf(Default_0).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.g1t_1.e1t(clauses, unificator);
+  };
+  protoOf(Default_0).theoryOfSequence = function (clauses) {
+    return this.g1t_1.theoryOfSequence(clauses);
+  };
+  protoOf(Default_0).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.g1t_1.f1t(clauses, unificator);
+  };
+  var Default_instance_0;
+  function Default_getInstance_0() {
+    if (Default_instance_0 == null)
+      new Default_0();
+    return Default_instance_0;
+  }
+  function ListedTheoryFactory(unificator) {
+    this.h1t_1 = unificator;
+  }
+  protoOf(ListedTheoryFactory).e1l = function () {
+    return this.h1t_1;
+  };
+  protoOf(ListedTheoryFactory).d1l = function (unificator) {
+    return new ListedTheoryFactory(unificator);
+  };
+  protoOf(ListedTheoryFactory).z1s = function (unificator) {
+    return ListedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(ListedTheoryFactory).emptyTheoryWithUnificator = function (unificator) {
+    return this.z1s(unificator);
+  };
+  protoOf(ListedTheoryFactory).e1t = function (clauses, unificator) {
+    return ListedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.e1t(clauses, unificator);
+  };
+  protoOf(ListedTheoryFactory).d1t = function (unificator, clauses) {
+    return ListedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(ListedTheoryFactory).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.d1t(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).f1t = function (clauses, unificator) {
+    return ListedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.f1t(clauses, unificator);
+  };
+  protoOf(ListedTheoryFactory).y1s = function (unificator) {
+    return MutableListedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(ListedTheoryFactory).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.y1s(unificator);
+  };
+  protoOf(ListedTheoryFactory).b1t = function (clauses, unificator) {
+    return MutableListedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.b1t(clauses, unificator);
+  };
+  protoOf(ListedTheoryFactory).a1t = function (unificator, clauses) {
+    return MutableListedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(ListedTheoryFactory).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.a1t(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).c1t = function (clauses, unificator) {
+    return MutableListedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.c1t(clauses, unificator);
+  };
+  function Companion_4() {
+  }
+  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) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(clauses.length);
+    var inductionVariable = 0;
+    var last = clauses.length;
+    while (inductionVariable < last) {
+      var item = clauses[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.indexedOf.<anonymous>' call
+      var tmp$ret$0 = Companion_instance.emptyWithFunction(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.indexedOfIterable(unificator, destination);
+  };
+  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) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(clause.length);
+    var inductionVariable = 0;
+    var last = clause.length;
+    while (inductionVariable < last) {
+      var item = clause[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.listedOf.<anonymous>' call
+      var tmp$ret$0 = Companion_instance.emptyWithFunction(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.listedOfIterable(unificator, destination);
+  };
+  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_9;
+  function Companion_getInstance_7() {
+    return Companion_instance_9;
+  }
+  function MutableTheory() {
+  }
+  function Success_0(theory, clauses) {
+    RetractResult.call(this);
+    this.o1t_1 = theory;
+    this.p1t_1 = clauses;
+  }
+  protoOf(Success_0).c1s = function () {
+    return this.o1t_1;
+  };
+  protoOf(Success_0).p1l = function () {
+    return this.p1t_1;
+  };
+  protoOf(Success_0).i1m = function () {
+    return first_0(this.p1t_1);
+  };
+  protoOf(Success_0).toString = function () {
+    return 'Success(theory=' + this.o1t_1 + ', clauses=' + this.p1t_1 + ')';
+  };
+  protoOf(Success_0).hashCode = function () {
+    var result = hashCode(this.o1t_1);
+    result = imul(result, 31) + hashCode(this.p1t_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.o1t_1, tmp0_other_with_cast.o1t_1))
+      return false;
+    if (!equals(this.p1t_1, tmp0_other_with_cast.p1t_1))
+      return false;
+    return true;
+  };
+  function Failure_0(theory) {
+    RetractResult.call(this);
+    this.q1t_1 = theory;
+  }
+  protoOf(Failure_0).c1s = function () {
+    return this.q1t_1;
+  };
+  protoOf(Failure_0).p1l = function () {
+    return null;
+  };
+  protoOf(Failure_0).i1m = function () {
+    return null;
+  };
+  protoOf(Failure_0).toString = function () {
+    return 'Failure(theory=' + this.q1t_1 + ')';
+  };
+  protoOf(Failure_0).hashCode = function () {
+    return hashCode(this.q1t_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.q1t_1, tmp0_other_with_cast.q1t_1))
+      return false;
+    return true;
+  };
+  function RetractResult() {
+  }
+  function Companion_5() {
+  }
+  protoOf(Companion_5).empty = function (unificator) {
+    return this.indexedOfSequence(unificator, emptySequence());
+  };
+  protoOf(Companion_5).emptyWithDefaultUnificator = function () {
+    return this.empty(Companion_getInstance_1().y1k());
+  };
+  protoOf(Companion_5).of = function (unificator, clause) {
+    return this.indexedOf(unificator, clause.slice());
+  };
+  protoOf(Companion_5).ofWithDefaultUnificator = function (clause) {
+    return this.indexedOf(Companion_getInstance_1().y1k(), 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_1().y1k(), clauses);
+  };
+  protoOf(Companion_5).ofSequence = function (unificator, clauses) {
+    return this.indexedOfSequence(unificator, clauses);
+  };
+  protoOf(Companion_5).ofSequenceWithDefaultUnificator = function (clauses) {
+    return this.indexedOfSequence(Companion_getInstance_1().y1k(), 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_1().y1k(), 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) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(clauses.length);
+    var inductionVariable = 0;
+    var last = clauses.length;
+    while (inductionVariable < last) {
+      var item = clauses[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.indexedOf.<anonymous>' call
+      var tmp$ret$0 = Companion_instance.emptyWithFunction(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.indexedOfIterable(unificator, destination);
+  };
+  protoOf(Companion_5).indexedOfSequence = function (unificator, clauses) {
+    return this.indexedOfIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_5).indexedOfIterable = function (unificator, clauses) {
+    return Default_getInstance().theoryOfIterableWithUnificator(clauses, unificator);
+  };
+  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) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(clause.length);
+    var inductionVariable = 0;
+    var last = clause.length;
+    while (inductionVariable < last) {
+      var item = clause[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.theory.Companion.listedOf.<anonymous>' call
+      var tmp$ret$0 = Companion_instance.emptyWithFunction(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.listedOfIterable(unificator, destination);
+  };
+  protoOf(Companion_5).listedOfSequence = function (unificator, clauses) {
+    return this.listedOfIterable(unificator, asIterable(clauses));
+  };
+  protoOf(Companion_5).listedOfIterable = function (unificator, clauses) {
+    return Default_getInstance_0().theoryOfIterableWithUnificator(clauses, unificator);
+  };
+  var Companion_instance_10;
+  function Companion_getInstance_8() {
+    return Companion_instance_10;
+  }
+  function Theory$_get_rules_$lambda_c39n1s(it) {
+    return it.asRule();
+  }
+  function Theory$_get_directives_$lambda_zbsn17(it) {
+    return it.asDirective();
+  }
+  function Theory() {
+  }
+  function TheoryFactory() {
+  }
+  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.r();
+      while (tmp0_iterator.s()) {
+        var element = tmp0_iterator.u();
+        // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.actualCheck.<anonymous>' call
+        if (!element.px()) {
+          tmp$ret$1 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = true;
+    }
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp$ret$1) {
+      // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.actualCheck.<anonymous>' call
+      var message = "ClauseDatabase can contain only well formed clauses: these aren't " + ('' + toList(filterNot(clauses, TheoryUtils$actualCheck$lambda)));
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  function TheoryUtils$actualCheck$lambda(it) {
+    return it.px();
+  }
+  function TheoryUtils() {
+  }
+  protoOf(TheoryUtils).b1m = function (clause) {
+    // 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
+    // Inline function 'kotlin.contracts.contract' call
+    if (!clause.px()) {
+      // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClauseCorrect.<anonymous>.<anonymous>' call
+      var message = 'ClauseDatabase can contain only well formed clauses: ' + ("this isn't " + clause);
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return clause;
+  };
+  protoOf(TheoryUtils).l1s = function (clauses) {
+    // Inline function 'kotlin.also' call
+    var this_0 = asSequence_0(clauses);
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClausesCorrect.<anonymous>' call
+    actualCheck(TheoryUtils_instance, this_0);
+    return this_0;
+  };
+  protoOf(TheoryUtils).m1m = function (clauses) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClausesCorrect.<anonymous>' call
+    actualCheck(TheoryUtils_instance, asSequence(clauses));
+    return clauses;
+  };
+  protoOf(TheoryUtils).j1s = function (clauses) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.TheoryUtils.checkClausesCorrect.<anonymous>' call
+    actualCheck(TheoryUtils_instance, clauses);
+    return clauses;
+  };
+  var TheoryUtils_instance;
+  function TheoryUtils_getInstance() {
+    return TheoryUtils_instance;
+  }
+  function _no_name_provided__qut3iv(this$0) {
+    this.r1t_1 = this$0;
+  }
+  protoOf(_no_name_provided__qut3iv).r = function () {
+    // Inline function 'it.unibo.tuprolog.theory.impl.AbstractIndexedTheory.<get-clauses>.<anonymous>' call
+    return this.r1t_1.u1t().r();
+  };
+  function AbstractIndexedTheory(queue, tags) {
+    AbstractTheory.call(this, tags);
+    this.t1t_1 = queue;
+  }
+  protoOf(AbstractIndexedTheory).e1l = function () {
+    return this.u1t().e1l();
+  };
+  protoOf(AbstractIndexedTheory).u1t = function () {
+    return this.t1t_1;
+  };
+  protoOf(AbstractIndexedTheory).i1l = function () {
+    return this.u1t().h1l();
+  };
+  protoOf(AbstractIndexedTheory).j1l = function () {
+    return this.u1t().j1l();
+  };
+  protoOf(AbstractIndexedTheory).p1l = function () {
+    // Inline function 'kotlin.collections.Iterable' call
+    return new _no_name_provided__qut3iv(this);
+  };
+  protoOf(AbstractIndexedTheory).n1l = function (clause) {
+    return this.u1t().n1l(clause);
+  };
+  protoOf(AbstractIndexedTheory).get = function (clause) {
+    return this.n1l(clause);
+  };
+  protoOf(AbstractIndexedTheory).l = function () {
+    return toLong(this.u1t().l());
+  };
+  protoOf(AbstractIndexedTheory).k1l = function () {
+    return this.u1t().isEmpty();
+  };
+  protoOf(AbstractIndexedTheory).f1s = function () {
+    return !this.k1l();
+  };
+  function AbstractListedTheory(unificator, clauses, tags) {
+    AbstractTheory.call(this, tags);
+    this.w1t_1 = clauses;
+    this.x1t_1 = unificator;
+  }
+  protoOf(AbstractListedTheory).p1l = function () {
+    return this.w1t_1;
+  };
+  protoOf(AbstractListedTheory).y1t = function (_set____db54di) {
+    this.x1t_1 = _set____db54di;
+  };
+  protoOf(AbstractListedTheory).e1l = function () {
+    return this.x1t_1;
+  };
+  protoOf(AbstractListedTheory).n1l = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var this_0 = this.p1l();
+    var destination = ArrayList_init_$Create$_0();
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.theory.impl.AbstractListedTheory.get.<anonymous>' call
+      if (this.e1l().match(element, clause)) {
+        destination.o(element);
+      }
+    }
+    return asSequence(destination);
+  };
+  protoOf(AbstractListedTheory).get = function (clause) {
+    return this.n1l(clause);
+  };
+  function IndexedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    IndexedTheory.call($this, Companion_instance_4.ofIterable(unificator, clauses), tags);
+    TheoryUtils_instance.m1m(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) {
+    // Inline function 'kotlin.getValue' call
+    var this_0 = $this.b1u_1;
+    hashCodeCache$factory_0();
+    return this_0.r2();
+  }
+  function _get_sizeCache__6eswog($this) {
+    // Inline function 'kotlin.getValue' call
+    var this_0 = $this.c1u_1;
+    sizeCache$factory();
+    return this_0.r2();
+  }
+  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).l.call(this$0);
+    };
+  }
+  function IndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    var tmp = this;
+    tmp.b1u_1 = lazy(IndexedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.c1u_1 = lazy(IndexedTheory$sizeCache$delegate$lambda(this));
+  }
+  protoOf(IndexedTheory).r1s = function (clauses, tags, unificator) {
+    return IndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(IndexedTheory).l1t = function (clause) {
+    var newTheory = Companion_instance_4.ofIterable(this.e1l(), this.p1l());
+    var retracted = newTheory.retrieveFirst(clause);
+    return retracted.j1m() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.h1m(), this.os()), ensureNotNull(retracted.p1l()));
+  };
+  protoOf(IndexedTheory).retract = function (clause) {
+    return this.l1t(clause);
+  };
+  protoOf(IndexedTheory).i1s = function (theory) {
+    return this.k1l() ? theory.toImmutableTheory() : theory.k1l() ? this : protoOf(AbstractIndexedTheory).i1s.call(this, theory);
+  };
+  protoOf(IndexedTheory).plusTheory = function (theory) {
+    return this.i1s(theory);
+  };
+  protoOf(IndexedTheory).i1t = function () {
+    return Companion_instance_9.indexedOfIterable(this.e1l(), this);
+  };
+  protoOf(IndexedTheory).toMutableTheory = function () {
+    return this.i1t();
+  };
+  protoOf(IndexedTheory).t1s = function (clauses) {
+    var newTheory = Companion_instance_5.ofIterable(this.e1l(), this.p1l());
+    var removed = dequeOf([]);
+    var tmp0_iterator = clauses.r();
+    while (tmp0_iterator.s()) {
+      var clause = tmp0_iterator.u();
+      var result = newTheory.e1m(clause);
+      if (result.d11()) {
+        removed.v(ensureNotNull(result.p1l()));
+      }
+    }
+    var tmp;
+    if (removed.z()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(new IndexedTheory(newTheory, this.os()), removed);
+    }
+    return tmp;
+  };
+  protoOf(IndexedTheory).retractIterable = function (clauses) {
+    return this.t1s(clauses);
+  };
+  protoOf(IndexedTheory).x1l = function (clause) {
+    var newTheory = Companion_instance_4.ofIterable(this.e1l(), this.p1l());
+    var retracted = newTheory.w1l(clause);
+    return retracted.j1m() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.h1m(), this.os()), ensureNotNull(retracted.p1l()));
+  };
+  protoOf(IndexedTheory).retractAll = function (clause) {
+    return this.x1l(clause);
+  };
+  protoOf(IndexedTheory).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_0(this);
+  };
+  protoOf(IndexedTheory).l = function () {
+    return _get_sizeCache__6eswog(this);
+  };
+  protoOf(IndexedTheory).b11 = function (tags) {
+    var tmp;
+    if (tags === this.os()) {
+      tmp = this;
+    } else {
+      tmp = new IndexedTheory(this.u1t(), tags);
+    }
+    return tmp;
+  };
+  protoOf(IndexedTheory).resetTags = function (tags) {
+    return this.b11(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_instance.m1m(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_instance.j1s(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) {
+    // Inline function 'kotlin.getValue' call
+    var this_0 = $this.g1u_1;
+    hashCodeCache$factory_1();
+    return this_0.r2();
+  }
+  function _get_sizeCache__6eswog_0($this) {
+    // Inline function 'kotlin.getValue' call
+    var this_0 = $this.h1u_1;
+    sizeCache$factory_0();
+    return this_0.r2();
+  }
+  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).l.call(this$0);
+    };
+  }
+  function ListedTheory(unificator, clauses, tags) {
+    AbstractListedTheory.call(this, unificator, clauses, tags);
+    var tmp = this;
+    tmp.g1u_1 = lazy(ListedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.h1u_1 = lazy(ListedTheory$sizeCache$delegate$lambda(this));
+  }
+  protoOf(ListedTheory).r1s = function (clauses, tags, unificator) {
+    return ListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(ListedTheory).l1t = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var this_0 = this.p1l();
+    var destination = ArrayList_init_$Create$_0();
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+      if (this.e1l().match(element, clause)) {
+        destination.o(element);
+      }
+    }
+    var retractability = destination;
+    var tmp;
+    if (none_0(retractability)) {
+      tmp = new Failure_0(this);
+    } else {
+      var toBeActuallyRetracted = first(retractability);
+      // Inline function 'kotlin.collections.filter' call
+      // Inline function 'kotlin.collections.filterTo' call
+      var this_1 = this.p1l();
+      var destination_0 = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var element_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+        if (!element_0.equals(toBeActuallyRetracted)) {
+          destination_0.o(element_0);
+        }
+      }
+      var newTheory = destination_0;
+      tmp = new Success_0(new ListedTheory(this.e1l(), newTheory, this.os()), listOf_0(toBeActuallyRetracted));
+    }
+    return tmp;
+  };
+  protoOf(ListedTheory).retract = function (clause) {
+    return this.l1t(clause);
+  };
+  protoOf(ListedTheory).i1t = function () {
+    return Companion_instance_9.listedOfIterable(this.e1l(), this);
+  };
+  protoOf(ListedTheory).toMutableTheory = function () {
+    return this.i1t();
+  };
+  protoOf(ListedTheory).t1s = function (clauses) {
+    var residual = dequeOf_1(this.p1l());
+    var removed = dequeOf([]);
+    var i = residual.r();
+    while (i.s()) {
+      var current = i.u();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.any' call
+        var tmp;
+        if (isInterface(clauses, Collection)) {
+          tmp = clauses.z();
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+        var tmp0_iterator = clauses.r();
+        while (tmp0_iterator.s()) {
+          var element = tmp0_iterator.u();
+          // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retract.<anonymous>' call
+          if (this.e1l().match(element, current)) {
+            tmp$ret$0 = true;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = false;
+      }
+      if (tmp$ret$0) {
+        i.t();
+        removed.o(current);
+      }
+    }
+    var tmp_0;
+    if (removed.z()) {
+      tmp_0 = new Failure_0(this);
+    } else {
+      tmp_0 = new Success_0(new ListedTheory(this.e1l(), residual, this.os()), removed);
+    }
+    return tmp_0;
+  };
+  protoOf(ListedTheory).retractIterable = function (clauses) {
+    return this.t1s(clauses);
+  };
+  protoOf(ListedTheory).x1l = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var this_0 = this.p1l();
+    var destination = ArrayList_init_$Create$_0();
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var element = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retractAll.<anonymous>' call
+      if (this.e1l().match(element, clause)) {
+        destination.o(element);
+      }
+    }
+    var retractability = destination;
+    var tmp;
+    if (none_0(retractability)) {
+      tmp = new Failure_0(this);
+    } else {
+      // Inline function 'kotlin.collections.partition' call
+      var this_1 = toList_0(this.p1l());
+      var first = ArrayList_init_$Create$_0();
+      var second = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = this_1.r();
+      while (tmp0_iterator_0.s()) {
+        var element_0 = tmp0_iterator_0.u();
+        // Inline function 'it.unibo.tuprolog.theory.impl.ListedTheory.retractAll.<anonymous>' call
+        if (this.e1l().match(element_0, clause)) {
+          first.o(element_0);
+        } else {
+          second.o(element_0);
+        }
+      }
+      var partitionedClauses = new Pair(first, second);
+      var newTheory = partitionedClauses.rd_1;
+      var toBeActuallyRetracted = partitionedClauses.qd_1;
+      tmp = new Success_0(new ListedTheory(this.e1l(), newTheory, this.os()), toBeActuallyRetracted);
+    }
+    return tmp;
+  };
+  protoOf(ListedTheory).retractAll = function (clause) {
+    return this.x1l(clause);
+  };
+  protoOf(ListedTheory).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_1(this);
+  };
+  protoOf(ListedTheory).l = function () {
+    return _get_sizeCache__6eswog_0(this);
+  };
+  protoOf(ListedTheory).b11 = function (tags) {
+    return tags === this.os() ? this : new ListedTheory(this.e1l(), this.p1l(), tags);
+  };
+  protoOf(ListedTheory).resetTags = function (tags) {
+    return this.b11(tags);
+  };
+  protoOf(ListedTheory).i1s = function (theory) {
+    return this.k1l() ? theory.toImmutableTheory() : theory.k1l() ? this : protoOf(AbstractListedTheory).i1s.call(this, theory);
+  };
+  protoOf(ListedTheory).plusTheory = function (theory) {
+    return this.i1s(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_instance_5.ofIterable(unificator, clauses), tags);
+    TheoryUtils_instance.m1m(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.d11() ? new Success_0($this, ensureNotNull(_this__u8e3s4.p1l())) : new Failure_0($this);
+  }
+  function MutableIndexedTheory$retract$lambda(this$0) {
+    return function (it) {
+      return this$0.k1u_1.u1l(it);
+    };
+  }
+  function MutableIndexedTheory$retract$lambda_0(it) {
+    return it.d11();
+  }
+  function MutableIndexedTheory$retract$lambda_1(it) {
+    return asSequence(ensureNotNull(it.p1l()));
+  }
+  function MutableIndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    this.k1u_1 = queue;
+  }
+  protoOf(MutableIndexedTheory).u1t = function () {
+    return this.k1u_1;
+  };
+  protoOf(MutableIndexedTheory).g1s = function (unificator) {
+    return protoOf(AbstractIndexedTheory).g1s.call(this, unificator).toMutableTheory();
+  };
+  protoOf(MutableIndexedTheory).setUnificator = function (unificator) {
+    return this.g1s(unificator);
+  };
+  protoOf(MutableIndexedTheory).i1t = function () {
+    return toMutableTheory.call(this);
+  };
+  protoOf(MutableIndexedTheory).toMutableTheory = function () {
+    return this.i1t();
+  };
+  protoOf(MutableIndexedTheory).p1l = function () {
+    return toList_0(this.k1u_1);
+  };
+  protoOf(MutableIndexedTheory).r = function () {
+    return this.k1u_1.r();
+  };
+  protoOf(MutableIndexedTheory).r1s = function (clauses, tags, unificator) {
+    return MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(MutableIndexedTheory).l1t = function (clause) {
+    return toRetractResult(this.k1u_1.u1l(clause), this);
+  };
+  protoOf(MutableIndexedTheory).retract = function (clause) {
+    return this.l1t(clause);
+  };
+  protoOf(MutableIndexedTheory).t1s = 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.z()) {
+      tmp_2 = new Failure_0(this);
+    } else {
+      tmp_2 = new Success_0(this, retracted);
+    }
+    return tmp_2;
+  };
+  protoOf(MutableIndexedTheory).retractIterable = function (clauses) {
+    return this.t1s(clauses);
+  };
+  protoOf(MutableIndexedTheory).x1l = function (clause) {
+    return toRetractResult(this.k1u_1.w1l(clause), this);
+  };
+  protoOf(MutableIndexedTheory).retractAll = function (clause) {
+    return this.x1l(clause);
+  };
+  protoOf(MutableIndexedTheory).w1r = function (clause) {
+    return this.o1s(TheoryUtils_instance.b1m(clause));
+  };
+  protoOf(MutableIndexedTheory).plus = function (clause) {
+    return this.w1r(clause);
+  };
+  protoOf(MutableIndexedTheory).i1s = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.p1s(toList_0(theory));
+    } else {
+      tmp = this.p1s(theory);
+    }
+    return tmp;
+  };
+  protoOf(MutableIndexedTheory).plusTheory = function (theory) {
+    return this.i1s(theory);
+  };
+  protoOf(MutableIndexedTheory).k1s = function (clause) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertA.<anonymous>' call
+    this.k1u_1.c1m(TheoryUtils_instance.b1m(clause));
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertA = function (clause) {
+    return this.k1s(clause);
+  };
+  protoOf(MutableIndexedTheory).m1s = function (clauses) {
+    // 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_instance.m1m(clauses))).r();
+    while (tmp0_iterator.s()) {
+      var clause = tmp0_iterator.u();
+      this.k1u_1.c1m(clause);
+    }
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertAIterable = function (clauses) {
+    return this.m1s(clauses);
+  };
+  protoOf(MutableIndexedTheory).n1s = function (clauses) {
+    return this.m1s(asIterable(clauses));
+  };
+  protoOf(MutableIndexedTheory).assertASequence = function (clauses) {
+    return this.n1s(clauses);
+  };
+  protoOf(MutableIndexedTheory).o1s = function (clause) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertZ.<anonymous>' call
+    this.k1u_1.d1m(TheoryUtils_instance.b1m(clause));
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertZ = function (clause) {
+    return this.o1s(clause);
+  };
+  protoOf(MutableIndexedTheory).p1s = function (clauses) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableIndexedTheory.assertZ.<anonymous>' call
+    this.k1u_1.t1l(TheoryUtils_instance.m1m(clauses));
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertZIterable = function (clauses) {
+    return this.p1s(clauses);
+  };
+  protoOf(MutableIndexedTheory).q1s = function (clauses) {
+    return this.p1s(TheoryUtils_instance.m1m(asIterable(clauses)));
+  };
+  protoOf(MutableIndexedTheory).assertZSequence = function (clauses) {
+    return this.q1s(clauses);
+  };
+  protoOf(MutableIndexedTheory).s1s = function (clauses) {
+    return this.t1s(asIterable(clauses));
+  };
+  protoOf(MutableIndexedTheory).retractSequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  protoOf(MutableIndexedTheory).b1s = function (indicator) {
+    return protoOf(AbstractIndexedTheory).b1s.call(this, indicator).toMutableTheory();
+  };
+  protoOf(MutableIndexedTheory).abolish = function (indicator) {
+    return this.b1s(indicator);
+  };
+  protoOf(MutableIndexedTheory).v1r = function () {
+    return Companion_instance_10.indexedOfIterable(this.e1l(), this);
+  };
+  protoOf(MutableIndexedTheory).toImmutableTheory = function () {
+    return this.v1r();
+  };
+  protoOf(MutableIndexedTheory).b11 = function (tags) {
+    return tags === this.os() ? this : new MutableIndexedTheory(this.k1u_1, tags);
+  };
+  protoOf(MutableIndexedTheory).resetTags = function (tags) {
+    return this.b11(tags);
+  };
+  protoOf(MutableIndexedTheory).u1s = function () {
+    return this.h1s(asSequence(this.p1l()));
+  };
+  protoOf(MutableIndexedTheory).clone = function () {
+    return this.u1s();
+  };
+  protoOf(MutableIndexedTheory).assertAFact = function (struct) {
+    return this.j1t(struct);
+  };
+  protoOf(MutableIndexedTheory).assertZFact = function (struct) {
+    return this.k1t(struct);
+  };
+  protoOf(MutableIndexedTheory).retractByHead = function (head) {
+    return this.m1t(head);
+  };
+  protoOf(MutableIndexedTheory).retractAllByHead = function (head) {
+    return this.n1t(head);
+  };
+  function MutableListedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    MutableListedTheory.call($this, unificator, toMutableList(clauses), tags);
+    TheoryUtils_instance.m1m(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_instance.j1s(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.o1u_1 = clauses;
+  }
+  protoOf(MutableListedTheory).p1l = function () {
+    return this.o1u_1;
+  };
+  protoOf(MutableListedTheory).g1s = function (unificator) {
+    this.y1t(unificator);
+    return this;
+  };
+  protoOf(MutableListedTheory).setUnificator = function (unificator) {
+    return this.g1s(unificator);
+  };
+  protoOf(MutableListedTheory).i1t = function () {
+    return toMutableTheory.call(this);
+  };
+  protoOf(MutableListedTheory).toMutableTheory = function () {
+    return this.i1t();
+  };
+  protoOf(MutableListedTheory).r1s = function (clauses, tags, unificator) {
+    return MutableListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(MutableListedTheory).l1t = function (clause) {
+    var i = this.o1u_1.z1();
+    while (i.s()) {
+      var c = i.u();
+      if (this.e1l().match(c, clause)) {
+        i.t();
+        return new Success_0(this, listOf_0(c));
+      }
+    }
+    return new Failure_0(this);
+  };
+  protoOf(MutableListedTheory).retract = function (clause) {
+    return this.l1t(clause);
+  };
+  protoOf(MutableListedTheory).t1s = function (clauses) {
+    var i = this.o1u_1.z1();
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var retracted = ArrayList_init_$Create$_0();
+    while (i.s()) {
+      var c = i.u();
+      var tmp0_iterator = clauses.r();
+      while (tmp0_iterator.s()) {
+        var clause = tmp0_iterator.u();
+        if (this.e1l().match(c, clause)) {
+          retracted.o(c);
+          i.t();
+        }
+      }
+    }
+    var tmp;
+    if (retracted.z()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).retractIterable = function (clauses) {
+    return this.t1s(clauses);
+  };
+  protoOf(MutableListedTheory).x1l = function (clause) {
+    var i = this.o1u_1.z1();
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var retracted = ArrayList_init_$Create$_0();
+    while (i.s()) {
+      var c = i.u();
+      if (this.e1l().match(c, clause)) {
+        retracted.o(c);
+        i.t();
+      }
+    }
+    var tmp;
+    if (retracted.z()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).retractAll = function (clause) {
+    return this.x1l(clause);
+  };
+  protoOf(MutableListedTheory).w1r = function (clause) {
+    return this.o1s(clause);
+  };
+  protoOf(MutableListedTheory).plus = function (clause) {
+    return this.w1r(clause);
+  };
+  protoOf(MutableListedTheory).i1s = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.p1s(toList_0(theory));
+    } else {
+      tmp = this.p1s(theory);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).plusTheory = function (theory) {
+    return this.i1s(theory);
+  };
+  protoOf(MutableListedTheory).k1s = function (clause) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertA.<anonymous>' call
+    addFirst(this.o1u_1, TheoryUtils_instance.b1m(clause));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertA = function (clause) {
+    return this.k1s(clause);
+  };
+  protoOf(MutableListedTheory).m1s = function (clauses) {
+    // 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.o1u_1, TheoryUtils_instance.m1m(clauses));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertAIterable = function (clauses) {
+    return this.m1s(clauses);
+  };
+  protoOf(MutableListedTheory).n1s = function (clauses) {
+    return this.m1s(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).assertASequence = function (clauses) {
+    return this.n1s(clauses);
+  };
+  protoOf(MutableListedTheory).o1s = function (clause) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertZ.<anonymous>' call
+    this.o1u_1.o(TheoryUtils_instance.b1m(clause));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertZ = function (clause) {
+    return this.o1s(clause);
+  };
+  protoOf(MutableListedTheory).p1s = function (clauses) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.theory.impl.MutableListedTheory.assertZ.<anonymous>' call
+    addAll(this.o1u_1, TheoryUtils_instance.m1m(clauses));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertZIterable = function (clauses) {
+    return this.p1s(clauses);
+  };
+  protoOf(MutableListedTheory).q1s = function (clauses) {
+    return this.p1s(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).assertZSequence = function (clauses) {
+    return this.q1s(clauses);
+  };
+  protoOf(MutableListedTheory).s1s = function (clauses) {
+    return this.t1s(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).retractSequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  protoOf(MutableListedTheory).b1s = function (indicator) {
+    return protoOf(AbstractListedTheory).b1s.call(this, indicator).toMutableTheory();
+  };
+  protoOf(MutableListedTheory).abolish = function (indicator) {
+    return this.b1s(indicator);
+  };
+  protoOf(MutableListedTheory).v1r = function () {
+    return Companion_instance_10.listedOfIterable(this.e1l(), this);
+  };
+  protoOf(MutableListedTheory).toImmutableTheory = function () {
+    return this.v1r();
+  };
+  protoOf(MutableListedTheory).b11 = function (tags) {
+    return tags === this.os() ? this : new MutableListedTheory(this.e1l(), this.o1u_1, tags);
+  };
+  protoOf(MutableListedTheory).resetTags = function (tags) {
+    return this.b11(tags);
+  };
+  protoOf(MutableListedTheory).u1s = function () {
+    return this.h1s(asSequence(this.o1u_1));
+  };
+  protoOf(MutableListedTheory).clone = function () {
+    return this.u1s();
+  };
+  protoOf(MutableListedTheory).assertAFact = function (struct) {
+    return this.j1t(struct);
+  };
+  protoOf(MutableListedTheory).assertZFact = function (struct) {
+    return this.k1t(struct);
+  };
+  protoOf(MutableListedTheory).retractByHead = function (head) {
+    return this.m1t(head);
+  };
+  protoOf(MutableListedTheory).retractAllByHead = function (head) {
+    return this.n1t(head);
+  };
+  function takeFirstAfterSkipping(_this__u8e3s4, n) {
+    var iter = _this__u8e3s4.r();
+    // Inline function 'kotlin.repeat' call
+    // Inline function 'kotlin.contracts.contract' call
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'it.unibo.tuprolog.collections.rete.takeFirstAfterSkipping.<anonymous>' call
+        iter.u();
+      }
+       while (inductionVariable < n);
+    return iter.u();
+  }
+  //region block: post-declaration
+  defineProp(protoOf(RetrieveResult), 'collection', function () {
+    return this.h1m();
+  });
+  defineProp(protoOf(RetrieveResult), 'clauses', function () {
+    return this.p1l();
+  });
+  defineProp(protoOf(RetrieveResult), 'firstClause', function () {
+    return this.i1m();
+  });
+  protoOf(MutableReteClauseQueue).n1l = get;
+  protoOf(ReteClauseQueue).n1l = get;
+  protoOf(IndexedClause$Companion$wrap$1).k1n = get_innerClause;
+  protoOf(IndexedClause$Companion$wrap$1).s1o = plus_1;
+  protoOf(IndexedClause$Companion$wrap$1).cs = compareTo;
+  protoOf(SituatedIndexedClause$Companion$of$1).k1n = get_innerClause;
+  protoOf(SituatedIndexedClause$Companion$of$1).s1o = plus_1;
+  protoOf(SituatedIndexedClause$Companion$of$1).cs = compareTo;
+  protoOf(AbstractTheory).v1s = get_isMutable;
+  protoOf(AbstractTheory).j1l = get_rules;
+  protoOf(AbstractTheory).i1l = 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(IndexedTheoryFactory).emptyTheory = emptyTheory;
+  protoOf(IndexedTheoryFactory).theoryOfIterable = theoryOfIterable;
+  protoOf(IndexedTheoryFactory).theoryOf = theoryOf;
+  protoOf(IndexedTheoryFactory).theoryOfSequence = theoryOfSequence;
+  protoOf(IndexedTheoryFactory).emptyMutableTheory = emptyMutableTheory;
+  protoOf(IndexedTheoryFactory).mutableTheoryOfIterable = mutableTheoryOfIterable;
+  protoOf(IndexedTheoryFactory).mutableTheoryOf = mutableTheoryOf;
+  protoOf(IndexedTheoryFactory).mutableTheoryOfSequence = mutableTheoryOfSequence;
+  protoOf(ListedTheoryFactory).emptyTheory = emptyTheory;
+  protoOf(ListedTheoryFactory).theoryOfIterable = theoryOfIterable;
+  protoOf(ListedTheoryFactory).theoryOf = theoryOf;
+  protoOf(ListedTheoryFactory).theoryOfSequence = theoryOfSequence;
+  protoOf(ListedTheoryFactory).emptyMutableTheory = emptyMutableTheory;
+  protoOf(ListedTheoryFactory).mutableTheoryOfIterable = mutableTheoryOfIterable;
+  protoOf(ListedTheoryFactory).mutableTheoryOf = mutableTheoryOf;
+  protoOf(ListedTheoryFactory).mutableTheoryOfSequence = mutableTheoryOfSequence;
+  defineProp(protoOf(RetractResult), 'theory', function () {
+    return this.c1s();
+  });
+  defineProp(protoOf(RetractResult), 'clauses', function () {
+    return this.p1l();
+  });
+  defineProp(protoOf(RetractResult), 'firstClause', function () {
+    return this.i1m();
+  });
+  protoOf(MutableIndexedTheory).j1t = assertAFact_0;
+  protoOf(MutableIndexedTheory).k1t = assertZFact_0;
+  protoOf(MutableIndexedTheory).m1t = retractByHead_0;
+  protoOf(MutableIndexedTheory).v1s = get_isMutable_0;
+  protoOf(MutableIndexedTheory).n1t = retractAllByHead_0;
+  protoOf(MutableListedTheory).j1t = assertAFact_0;
+  protoOf(MutableListedTheory).k1t = assertZFact_0;
+  protoOf(MutableListedTheory).m1t = retractByHead_0;
+  protoOf(MutableListedTheory).v1s = get_isMutable_0;
+  protoOf(MutableListedTheory).n1t = retractAllByHead_0;
+  //endregion
+  //region block: init
+  Companion_instance_4 = new Companion();
+  Companion_instance_5 = new Companion_0();
+  Companion_instance_6 = new Companion_1();
+  Utils_instance = new Utils();
+  Companion_instance_7 = new Companion_2();
+  Companion_instance_8 = new Companion_3();
+  Companion_instance_9 = new Companion_4();
+  Companion_instance_10 = new Companion_5();
+  TheoryUtils_instance = new TheoryUtils();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_instance_9;
+  _.$_$.b = Companion_instance_10;
+  _.$_$.c = IndexedTheoryFactory;
+  _.$_$.d = MutableTheory;
+  _.$_$.e = Success_0;
+  _.$_$.f = TheoryFactory;
+  _.$_$.g = Theory;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-theory.js.map