@jakta/jakta-prolog-incarnation 0.0.0-bootstrap

package/2p-theory.js

@@ -0,0 +1,4837 @@
+(function (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 globalThis['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 globalThis['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 globalThis['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 globalThis['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'.");
+    }
+    globalThis['2p-theory'] = factory(typeof globalThis['2p-theory'] === 'undefined' ? {} : globalThis['2p-theory'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-core'], globalThis['2p-utils'], globalThis['2p-unify']);
+  }
+}(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.$_$.n6;
+  var asIterable = kotlin_kotlin.$_$.j7;
+  var any = kotlin_kotlin.$_$.i7;
+  var asSequence = kotlin_kotlin.$_$.z1;
+  var getKClassFromExpression = kotlin_kotlin.$_$.d7;
+  var joinToString = kotlin_kotlin.$_$.q2;
+  var initMetadataForClass = kotlin_kotlin.$_$.y5;
+  var Unit_instance = kotlin_kotlin.$_$.m;
+  var toList = kotlin_kotlin.$_$.q8;
+  var none = kotlin_kotlin.$_$.f8;
+  var VOID = kotlin_kotlin.$_$.b;
+  var emptyList = kotlin_kotlin.$_$.i2;
+  var asIterable_0 = kotlin_kotlin.$_$.v1;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.n;
+  var Companion_instance = kotlin_it_unibo_tuprolog_core.$_$.m;
+  var itemWiseEquals = kotlin_it_unibo_tuprolog_utils.$_$.c1;
+  var getKClass = kotlin_kotlin.$_$.e7;
+  var itemWiseHashCode = kotlin_it_unibo_tuprolog_utils.$_$.d1;
+  var itemWiseHashCode_0 = kotlin_it_unibo_tuprolog_utils.$_$.e1;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.z5;
+  var initMetadataForInterface = kotlin_kotlin.$_$.a6;
+  var first = kotlin_kotlin.$_$.m2;
+  var toString = kotlin_kotlin.$_$.q6;
+  var hashCode = kotlin_kotlin.$_$.x5;
+  var equals = kotlin_kotlin.$_$.t5;
+  var defineProp = kotlin_kotlin.$_$.s5;
+  var objectCreate = kotlin_kotlin.$_$.m6;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var asReversed = kotlin_kotlin.$_$.w1;
+  var isInterface = kotlin_kotlin.$_$.f6;
+  var KProperty1 = kotlin_kotlin.$_$.f7;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.v5;
+  var constructCallableReference = kotlin_kotlin.$_$.r5;
+  var lazy = kotlin_kotlin.$_$.na;
+  var CoroutineImpl = kotlin_kotlin.$_$.j4;
+  var THROW_CCE = kotlin_kotlin.$_$.ha;
+  var SequenceScope = kotlin_kotlin.$_$.g7;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.i4;
+  var initMetadataForLambda = kotlin_kotlin.$_$.b6;
+  var sequence = kotlin_kotlin.$_$.k8;
+  var listOf = kotlin_kotlin.$_$.y2;
+  var mergeSequences = kotlin_it_unibo_tuprolog_utils.$_$.g1;
+  var sequenceOf = kotlin_kotlin.$_$.i8;
+  var flatten = kotlin_kotlin.$_$.w7;
+  var initMetadataForObject = kotlin_kotlin.$_$.c6;
+  var compareTo = kotlin_it_unibo_tuprolog_utils.$_$.i;
+  var LongIndexed = kotlin_it_unibo_tuprolog_utils.$_$.j;
+  var component1 = kotlin_it_unibo_tuprolog_utils.$_$.g;
+  var component2 = kotlin_it_unibo_tuprolog_utils.$_$.h;
+  var Companion_instance_0 = kotlin_it_unibo_tuprolog_utils.$_$.d;
+  var copyToArray = kotlin_kotlin.$_$.g2;
+  var plus = kotlin_kotlin.$_$.q3;
+  var equalsLong = kotlin_kotlin.$_$.w4;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.o;
+  var minOrNull = kotlin_kotlin.$_$.c3;
+  var map = kotlin_kotlin.$_$.d8;
+  var ensureNotNull = kotlin_kotlin.$_$.la;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.q;
+  var sum = kotlin_kotlin.$_$.l8;
+  var Collection = kotlin_kotlin.$_$.o1;
+  var filter = kotlin_kotlin.$_$.s7;
+  var emptySequence = kotlin_kotlin.$_$.p7;
+  var dequeOf = kotlin_it_unibo_tuprolog_utils.$_$.x;
+  var addFirst = kotlin_it_unibo_tuprolog_utils.$_$.p;
+  var buffered = kotlin_it_unibo_tuprolog_utils.$_$.q;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.b2;
+  var dequeOf_0 = kotlin_it_unibo_tuprolog_utils.$_$.v;
+  var Companion_instance_1 = kotlin_it_unibo_tuprolog_utils.$_$.b;
+  var flatMap = kotlin_kotlin.$_$.v7;
+  var sequenceOf_0 = kotlin_kotlin.$_$.j8;
+  var firstOrNull = kotlin_kotlin.$_$.t7;
+  var NotImplementedError = kotlin_kotlin.$_$.ca;
+  var take = kotlin_kotlin.$_$.n8;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.e1;
+  var get_ONE = kotlin_kotlin.$_$.m4;
+  var add = kotlin_kotlin.$_$.n4;
+  var subtract = kotlin_kotlin.$_$.g5;
+  var Long = kotlin_kotlin.$_$.ba;
+  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.n1;
+  var Companion_instance_2 = kotlin_it_unibo_tuprolog_core.$_$.l;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.r;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.n;
+  var numberRangeToNumber = kotlin_kotlin.$_$.j6;
+  var plus_0 = kotlin_kotlin.$_$.h8;
+  var getTag = kotlin_it_unibo_tuprolog_utils.$_$.m;
+  var containsTag = kotlin_it_unibo_tuprolog_utils.$_$.l;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_unify.$_$.a;
+  var Companion_instance_3 = kotlin_it_unibo_tuprolog_core.$_$.f;
+  var first_0 = kotlin_kotlin.$_$.n2;
+  var filterNotNull = kotlin_kotlin.$_$.q7;
+  var Taggable = kotlin_it_unibo_tuprolog_utils.$_$.n;
+  var filterNot = kotlin_kotlin.$_$.r7;
+  var asSequence_0 = kotlin_kotlin.$_$.a2;
+  var fromInt = kotlin_kotlin.$_$.x4;
+  var emptyMap = kotlin_kotlin.$_$.j2;
+  var toList_0 = kotlin_kotlin.$_$.y3;
+  var listOf_0 = kotlin_kotlin.$_$.x2;
+  var none_0 = kotlin_kotlin.$_$.l3;
+  var dequeOf_1 = kotlin_it_unibo_tuprolog_utils.$_$.w;
+  var Pair = kotlin_kotlin.$_$.fa;
+  var toMutableList = kotlin_kotlin.$_$.e4;
+  var toMutableList_0 = kotlin_kotlin.$_$.r8;
+  var addFirst_0 = kotlin_it_unibo_tuprolog_utils.$_$.o;
+  var addAll = kotlin_kotlin.$_$.s1;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(AbstractClauseCollection, 'AbstractClauseCollection');
+  initMetadataForClass(AbstractMutableReteClauseCollection, 'AbstractMutableReteClauseCollection', VOID, AbstractClauseCollection);
+  initMetadataForClass(AbstractReteClauseCollection, 'AbstractReteClauseCollection', VOID, AbstractClauseCollection);
+  initMetadataForCompanion(Companion);
+  function get(clause) {
+    return this.getFifoOrdered(clause);
+  }
+  function add_0(clause) {
+    return this.addLast(clause);
+  }
+  function add_1(clause) {
+    return this.j1i(clause);
+  }
+  function retrieve(clause) {
+    return this.retrieveFirst(clause);
+  }
+  function retrieve_0(clause) {
+    return this.m1i(clause);
+  }
+  initMetadataForInterface(ClauseQueue, 'ClauseQueue');
+  initMetadataForCompanion(Companion_0);
+  initMetadataForInterface(MutableClauseQueue, 'MutableClauseQueue', VOID, VOID, [ClauseQueue]);
+  initMetadataForClass(RetrieveResult, 'RetrieveResult');
+  initMetadataForClass(Success, 'Success', VOID, RetrieveResult);
+  initMetadataForClass(Failure, 'Failure', VOID, RetrieveResult);
+  initMetadataForClass(MutableReteClauseQueue, 'MutableReteClauseQueue', VOID, AbstractMutableReteClauseCollection, [MutableClauseQueue]);
+  initMetadataForClass(ReteClauseQueue, 'ReteClauseQueue', VOID, AbstractReteClauseCollection, [ClauseQueue]);
+  initMetadataForLambda(AbstractReteNode$removeAllLazily$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForClass(AbstractReteNode, 'AbstractReteNode');
+  initMetadataForCompanion(Companion_1);
+  initMetadataForLambda(Utils$firstArguments$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForObject(Utils, 'Utils');
+  function get_innerClause() {
+    return this.c2();
+  }
+  function plus_1(traversed) {
+    return Companion_instance_7.n1l(this.wo(), this.b1k(), plus(this.j1l(), traversed));
+  }
+  initMetadataForInterface(IndexedClause, 'IndexedClause', VOID, VOID, [LongIndexed]);
+  initMetadataForClass(IndexedClause$Companion$wrap$1, VOID, VOID, VOID, [IndexedClause]);
+  initMetadataForCompanion(Companion_2);
+  initMetadataForInterface(SituatedIndexedClause, 'SituatedIndexedClause', VOID, VOID, [IndexedClause]);
+  initMetadataForClass(SituatedIndexedClause$Companion$of$1, VOID, VOID, VOID, [SituatedIndexedClause]);
+  initMetadataForCompanion(Companion_3);
+  initMetadataForClass(AbstractIndexingLeaf, 'AbstractIndexingLeaf', VOID, AbstractReteNode);
+  initMetadataForClass(AtomIndex, 'AtomIndex', VOID, AbstractIndexingLeaf);
+  initMetadataForClass(CompoundIndex, 'CompoundIndex', VOID, AbstractReteNode);
+  initMetadataForClass(DirectiveIndex$getCache$1$1);
+  initMetadataForClass(DirectiveIndex, 'DirectiveIndex', VOID, AbstractReteNode);
+  initMetadataForClass(NumericIndex, 'NumericIndex', VOID, AbstractIndexingLeaf);
+  initMetadataForClass(VariableIndex, 'VariableIndex', VOID, AbstractIndexingLeaf);
+  initMetadataForClass(ArityNode, 'ArityNode', VOID, AbstractReteNode);
+  initMetadataForClass(FamilyArityReteNode, 'FamilyArityReteNode', VOID, ArityNode);
+  initMetadataForClass(FamilyArityIndexingNode, 'FamilyArityIndexingNode', VOID, FamilyArityReteNode);
+  initMetadataForClass(FunctorNode, 'FunctorNode', VOID, AbstractReteNode);
+  initMetadataForClass(FunctorIndexingNode, 'FunctorIndexingNode', VOID, FunctorNode);
+  initMetadataForClass(RootNode, 'RootNode');
+  initMetadataForClass(RuleNode, 'RuleNode');
+  initMetadataForClass(TopLevelFunctorReteNode, 'TopLevelFunctorReteNode', VOID, FunctorNode);
+  initMetadataForClass(ZeroArityReteNode, 'ZeroArityReteNode', VOID, ArityNode);
+  function get_isMutable() {
+    return false;
+  }
+  function get_rules() {
+    var tmp = asSequence(this.h1i());
+    return asIterable(filterNotNull(map(tmp, Theory$_get_rules_$lambda_c39n1s)));
+  }
+  function get_directives() {
+    var tmp = asSequence(this.h1i());
+    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()]));
+  }
+  initMetadataForInterface(Theory, 'Theory', VOID, VOID, [Taggable]);
+  initMetadataForClass(AbstractTheory, 'AbstractTheory', VOID, VOID, [Theory]);
+  function emptyTheory() {
+    return this.emptyTheoryWithUnificator(this.x1h());
+  }
+  function theoryOfIterable(clauses) {
+    return this.theoryOfIterableWithUnificator(clauses, this.x1h());
+  }
+  function theoryOf(clauses) {
+    return this.theoryOfWithUnificator(this.x1h(), clauses.slice());
+  }
+  function theoryOfSequence(clauses) {
+    return this.theoryOfSequenceWithUnificator(clauses, this.x1h());
+  }
+  function emptyMutableTheory() {
+    return this.emptyMutableTheoryWithUnificator(this.x1h());
+  }
+  function mutableTheoryOfIterable(clauses) {
+    return this.mutableTheoryOfIterableWithUnificator(clauses, this.x1h());
+  }
+  function mutableTheoryOf(clauses) {
+    return this.mutableTheoryOfWithUnificator(this.x1h(), clauses.slice());
+  }
+  function mutableTheoryOfSequence(clauses) {
+    return this.mutableTheoryOfSequenceWithUnificator(clauses, this.x1h());
+  }
+  initMetadataForInterface(TheoryFactory, 'TheoryFactory');
+  initMetadataForObject(Default, 'Default', VOID, VOID, [TheoryFactory]);
+  initMetadataForClass(IndexedTheoryFactory, 'IndexedTheoryFactory', VOID, VOID, [TheoryFactory]);
+  initMetadataForObject(Default_0, 'Default', VOID, VOID, [TheoryFactory]);
+  initMetadataForClass(ListedTheoryFactory, 'ListedTheoryFactory', VOID, VOID, [TheoryFactory]);
+  initMetadataForCompanion(Companion_4);
+  function get_isMutable_0() {
+    return true;
+  }
+  function toMutableTheory() {
+    return this;
+  }
+  function assertAFact_0(struct) {
+    return this.c1p(Companion_instance_3.of(struct));
+  }
+  function assertZFact_0(struct) {
+    return this.g1p(Companion_instance_3.of(struct));
+  }
+  function retractByHead_0(head) {
+    return this.d1q(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  }
+  function retractAllByHead_0(head) {
+    return this.p1i(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  }
+  initMetadataForInterface(MutableTheory, 'MutableTheory', VOID, VOID, [Theory]);
+  initMetadataForClass(RetractResult, 'RetractResult');
+  initMetadataForClass(Success_0, 'Success', VOID, RetractResult);
+  initMetadataForClass(Failure_0, 'Failure', VOID, RetractResult);
+  initMetadataForCompanion(Companion_5);
+  initMetadataForObject(TheoryUtils, 'TheoryUtils');
+  initMetadataForClass(AbstractIndexedTheory$clauses$$inlined$Iterable$1);
+  initMetadataForClass(AbstractIndexedTheory, 'AbstractIndexedTheory', VOID, AbstractTheory);
+  initMetadataForClass(AbstractListedTheory, 'AbstractListedTheory', VOID, AbstractTheory);
+  initMetadataForClass(IndexedTheory, 'IndexedTheory', VOID, AbstractIndexedTheory);
+  initMetadataForClass(ListedTheory, 'ListedTheory', VOID, AbstractListedTheory);
+  initMetadataForClass(MutableIndexedTheory, 'MutableIndexedTheory', VOID, AbstractIndexedTheory, [MutableTheory]);
+  initMetadataForClass(MutableListedTheory, 'MutableListedTheory', VOID, AbstractListedTheory, [MutableTheory]);
+  //endregion
+  function AbstractClauseCollection(rete) {
+    this.w1h_1 = rete;
+  }
+  protoOf(AbstractClauseCollection).x1h = function () {
+    return this.w1h_1.x1h();
+  };
+  protoOf(AbstractClauseCollection).s = function () {
+    return this.w1h_1.s();
+  };
+  protoOf(AbstractClauseCollection).z1h = function () {
+    return asIterable(this.w1h_1.a1i());
+  };
+  protoOf(AbstractClauseCollection).b1i = function () {
+    return asIterable(this.w1h_1.b1i());
+  };
+  protoOf(AbstractClauseCollection).g = function () {
+    return this.w1h_1.c1i();
+  };
+  protoOf(AbstractClauseCollection).isEmpty = function () {
+    return this.g();
+  };
+  protoOf(AbstractClauseCollection).d1i = function () {
+    return !this.g();
+  };
+  protoOf(AbstractClauseCollection).isNonEmpty = function () {
+    return this.d1i();
+  };
+  protoOf(AbstractClauseCollection).e1i = function (element) {
+    return any(this.w1h_1.f1i(element));
+  };
+  protoOf(AbstractClauseCollection).contains = function (element) {
+    return this.e1i(element);
+  };
+  protoOf(AbstractClauseCollection).g1i = function (elements) {
+    var tmp0 = asSequence(elements);
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var _iterator__ex2g4s = tmp0.m();
+      while (_iterator__ex2g4s.p()) {
+        var element = _iterator__ex2g4s.q();
+        if (!this.e1i(element)) {
+          tmp$ret$0 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  };
+  protoOf(AbstractClauseCollection).containsAll = function (elements) {
+    return this.g1i(elements);
+  };
+  protoOf(AbstractClauseCollection).m = function () {
+    return this.w1h_1.h1i().m();
+  };
+  protoOf(AbstractClauseCollection).toString = function () {
+    return '' + getKClassFromExpression(this).g9() + '(' + joinToString(this, ', ') + ')';
+  };
+  function AbstractMutableReteClauseCollection_init_$Init$(rete, $this) {
+    AbstractClauseCollection.call($this, rete);
+    AbstractMutableReteClauseCollection.call($this);
+    return $this;
+  }
+  protoOf(AbstractMutableReteClauseCollection).j1i = function (clause) {
+    this.w1h_1.k1i(clause);
+    return this.y1h();
+  };
+  protoOf(AbstractMutableReteClauseCollection).add = function (clause) {
+    return this.j1i(clause);
+  };
+  protoOf(AbstractMutableReteClauseCollection).l1i = function (clauses) {
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = clauses.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      this.w1h_1.k1i(element);
+    }
+    return this.y1h();
+  };
+  protoOf(AbstractMutableReteClauseCollection).addAll = function (clauses) {
+    return this.l1i(clauses);
+  };
+  protoOf(AbstractMutableReteClauseCollection).m1i = function (clause) {
+    var retracted = this.w1h_1.n1i(clause);
+    return none(retracted) ? new Failure(this.y1h()) : new Success(this.y1h(), toList(retracted));
+  };
+  protoOf(AbstractMutableReteClauseCollection).retrieve = function (clause) {
+    return this.m1i(clause);
+  };
+  protoOf(AbstractMutableReteClauseCollection).o1i = function (clause) {
+    var retracted = this.w1h_1.p1i(clause);
+    return none(retracted) ? new Failure(this.y1h()) : new Success(this.y1h(), toList(retracted));
+  };
+  protoOf(AbstractMutableReteClauseCollection).retrieveAll = function (clause) {
+    return this.o1i(clause);
+  };
+  function AbstractMutableReteClauseCollection() {
+  }
+  function AbstractReteClauseCollection(rete) {
+    AbstractClauseCollection.call(this, rete);
+  }
+  protoOf(AbstractReteClauseCollection).j1i = function (clause) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.w1h_1.s1i();
+    this_0.k1i(TheoryUtils_instance.t1i(clause));
+    return this.r1i(this_0);
+  };
+  protoOf(AbstractReteClauseCollection).add = function (clause) {
+    return this.j1i(clause);
+  };
+  protoOf(AbstractReteClauseCollection).l1i = function (clauses) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.w1h_1.s1i();
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = clauses.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      this_0.k1i(TheoryUtils_instance.t1i(element));
+    }
+    return this.r1i(this_0);
+  };
+  protoOf(AbstractReteClauseCollection).addAll = function (clauses) {
+    return this.l1i(clauses);
+  };
+  protoOf(AbstractReteClauseCollection).m1i = function (clause) {
+    var newTheory = this.w1h_1.s1i();
+    var retracted = newTheory.n1i(clause);
+    return none(retracted) ? new Failure(this.y1h()) : new Success(this.r1i(newTheory), toList(retracted));
+  };
+  protoOf(AbstractReteClauseCollection).retrieve = function (clause) {
+    return this.m1i(clause);
+  };
+  protoOf(AbstractReteClauseCollection).o1i = function (clause) {
+    var newTheory = this.w1h_1.s1i();
+    var retracted = newTheory.p1i(clause);
+    return none(retracted) ? new Failure(this.y1h()) : new Success(this.r1i(newTheory), toList(retracted));
+  };
+  protoOf(AbstractReteClauseCollection).retrieveAll = function (clause) {
+    return this.o1i(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;
+      var tmp$ret$2 = Companion_instance.emptyWithFunction(item);
+      destination.j(tmp$ret$2);
+    }
+    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;
+      var tmp$ret$2 = Companion_instance.emptyWithFunction(item);
+      destination.j(tmp$ret$2);
+    }
+    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.x1i_1 = collection;
+    this.y1i_1 = clauses;
+  }
+  protoOf(Success).z1i = function () {
+    return this.x1i_1;
+  };
+  protoOf(Success).h1i = function () {
+    return this.y1i_1;
+  };
+  protoOf(Success).lz = function () {
+    return true;
+  };
+  protoOf(Success).a1j = function () {
+    return first(this.y1i_1);
+  };
+  protoOf(Success).toString = function () {
+    return 'Success(collection=' + toString(this.x1i_1) + ', clauses=' + toString(this.y1i_1) + ')';
+  };
+  protoOf(Success).hashCode = function () {
+    var result = hashCode(this.x1i_1);
+    result = imul(result, 31) + hashCode(this.y1i_1) | 0;
+    return result;
+  };
+  protoOf(Success).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Success))
+      return false;
+    if (!equals(this.x1i_1, other.x1i_1))
+      return false;
+    if (!equals(this.y1i_1, other.y1i_1))
+      return false;
+    return true;
+  };
+  function Failure(collection) {
+    RetrieveResult.call(this);
+    this.c1j_1 = collection;
+  }
+  protoOf(Failure).z1i = function () {
+    return this.c1j_1;
+  };
+  protoOf(Failure).b1j = function () {
+    return true;
+  };
+  protoOf(Failure).h1i = function () {
+    return null;
+  };
+  protoOf(Failure).a1j = function () {
+    return null;
+  };
+  protoOf(Failure).toString = function () {
+    return 'Failure(collection=' + toString(this.c1j_1) + ')';
+  };
+  protoOf(Failure).hashCode = function () {
+    return hashCode(this.c1j_1);
+  };
+  protoOf(Failure).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Failure))
+      return false;
+    if (!equals(this.c1j_1, other.c1j_1))
+      return false;
+    return true;
+  };
+  function RetrieveResult() {
+  }
+  protoOf(RetrieveResult).lz = function () {
+    return false;
+  };
+  protoOf(RetrieveResult).b1j = function () {
+    return false;
+  };
+  function MutableReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    MutableReteClauseQueue.call($this, Companion_instance_6.d1j(unificator, clauses));
+    TheoryUtils_instance.e1j(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.require' call
+    if (!rete.f1j()) {
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(MutableReteClauseQueue).h1j = function (clause) {
+    return this.w1h_1.f1i(clause);
+  };
+  protoOf(MutableReteClauseQueue).getFifoOrdered = function (clause) {
+    return this.h1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).i1j = function (clause) {
+    return asSequence(asReversed(toList(this.h1j(clause))));
+  };
+  protoOf(MutableReteClauseQueue).getLifoOrdered = function (clause) {
+    return this.i1j(clause);
+  };
+  protoOf(MutableReteClauseQueue).u1i = function (clause) {
+    this.w1h_1.j1j(clause);
+    return this;
+  };
+  protoOf(MutableReteClauseQueue).addFirst = function (clause) {
+    return this.u1i(clause);
+  };
+  protoOf(MutableReteClauseQueue).v1i = function (clause) {
+    this.w1h_1.k1i(clause);
+    return this;
+  };
+  protoOf(MutableReteClauseQueue).addLast = function (clause) {
+    return this.v1i(clause);
+  };
+  protoOf(MutableReteClauseQueue).w1i = function (clause) {
+    var retracted = this.w1h_1.n1i(clause);
+    return none(retracted) ? new Failure(this) : new Success(this, toList(retracted));
+  };
+  protoOf(MutableReteClauseQueue).retrieveFirst = function (clause) {
+    return this.w1i(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).y1h = function () {
+    return this;
+  };
+  function _get_hashCodeCache__ny3r0q($this) {
+    var tmp0 = $this.l1j_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('hashCodeCache', 1, tmp, ReteClauseQueue$_get_hashCodeCache_$ref_rnll9p(), null);
+    return tmp0.c2();
+  }
+  function ReteClauseQueue_init_$Init$(unificator, clauses, $this) {
+    ReteClauseQueue.call($this, Companion_instance_6.d1j(unificator, clauses));
+    TheoryUtils_instance.e1j(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$_get_hashCodeCache_$ref_rnll9p() {
+    return constructCallableReference(function (p0) {
+      return _get_hashCodeCache__ny3r0q(p0);
+    }, 1, 0, 29);
+  }
+  function ReteClauseQueue(rete) {
+    AbstractReteClauseCollection.call(this, rete);
+    var tmp = this;
+    tmp.l1j_1 = lazy(ReteClauseQueue$hashCodeCache$delegate$lambda(this));
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!rete.f1j()) {
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(ReteClauseQueue).u1i = function (clause) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.w1h_1.s1i();
+    this_0.j1j(TheoryUtils_instance.t1i(clause));
+    return new ReteClauseQueue(this_0);
+  };
+  protoOf(ReteClauseQueue).addFirst = function (clause) {
+    return this.u1i(clause);
+  };
+  protoOf(ReteClauseQueue).v1i = function (clause) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.w1h_1.s1i();
+    this_0.k1i(TheoryUtils_instance.t1i(clause));
+    return new ReteClauseQueue(this_0);
+  };
+  protoOf(ReteClauseQueue).addLast = function (clause) {
+    return this.v1i(clause);
+  };
+  protoOf(ReteClauseQueue).h1j = function (clause) {
+    return this.w1h_1.f1i(clause);
+  };
+  protoOf(ReteClauseQueue).getFifoOrdered = function (clause) {
+    return this.h1j(clause);
+  };
+  protoOf(ReteClauseQueue).i1j = function (clause) {
+    return asSequence(asReversed(toList(this.h1j(clause))));
+  };
+  protoOf(ReteClauseQueue).getLifoOrdered = function (clause) {
+    return this.i1j(clause);
+  };
+  protoOf(ReteClauseQueue).j1i = function (clause) {
+    return this.v1i(clause);
+  };
+  protoOf(ReteClauseQueue).add = function (clause) {
+    return this.j1i(clause);
+  };
+  protoOf(ReteClauseQueue).m1i = function (clause) {
+    return protoOf(AbstractReteClauseCollection).m1i.call(this, clause);
+  };
+  protoOf(ReteClauseQueue).retrieve = function (clause) {
+    return this.m1i(clause);
+  };
+  protoOf(ReteClauseQueue).w1i = function (clause) {
+    return protoOf(AbstractReteClauseCollection).m1i.call(this, clause);
+  };
+  protoOf(ReteClauseQueue).retrieveFirst = function (clause) {
+    return this.w1i(clause);
+  };
+  protoOf(ReteClauseQueue).r1i = 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 = !isInterface(other, MutableClauseQueue);
+    } 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).y1h = function () {
+    return this;
+  };
+  function AbstractReteNode$removeAllLazily$slambda($source, this$0, $clause, resultContinuation) {
+    this.u1j_1 = $source;
+    this.v1j_1 = this$0;
+    this.w1j_1 = $clause;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(AbstractReteNode$removeAllLazily$slambda).lp = function ($this$sequence, $completion) {
+    var tmp = this.mp($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).f9 = function (p1, $completion) {
+    return this.lp(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 5;
+            this.y1j_1 = this.u1j_1.m();
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.y1j_1.p()) {
+              this.g8_1 = 4;
+              continue $sm;
+            }
+
+            var it = this.y1j_1.q();
+            if (this.v1j_1.x1h().match(it.b1k(), this.w1j_1)) {
+              it.z1j();
+              this.y1j_1.g3();
+              this.g8_1 = 2;
+              suspendResult = this.x1j_1.nc(it, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.g8_1 = 3;
+              continue $sm;
+            }
+
+          case 2:
+            this.g8_1 = 3;
+            continue $sm;
+          case 3:
+            this.g8_1 = 1;
+            continue $sm;
+          case 4:
+            return Unit_instance;
+          case 5:
+            throw this.j8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 5) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(AbstractReteNode$removeAllLazily$slambda).mp = function ($this$sequence, completion) {
+    var i = new AbstractReteNode$removeAllLazily$slambda(this.u1j_1, this.v1j_1, this.w1j_1, completion);
+    i.x1j_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);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.lp($this$sequence, $completion);
+    }, 1);
+  }
+  function AbstractReteNode(unificator) {
+    this.a1k_1 = unificator;
+  }
+  protoOf(AbstractReteNode).x1h = function () {
+    return this.a1k_1;
+  };
+  protoOf(AbstractReteNode).c1k = function (source, clause) {
+    return sequence(AbstractReteNode$removeAllLazily$slambda_0(source, this, clause, null));
+  };
+  function ReteNode$assertA$ref() {
+    return constructCallableReference(function (p0, p1) {
+      p0.d1k(p1);
+      return Unit_instance;
+    }, 2, 0, 30, 'assertA');
+  }
+  function ReteNode$assertZ$ref() {
+    return constructCallableReference(function (p0, p1) {
+      p0.e1k(p1);
+      return Unit_instance;
+    }, 2, 0, 31, 'assertZ');
+  }
+  function Companion_1() {
+  }
+  protoOf(Companion_1).d1j = function (unificator, clauses) {
+    return new RootNode(unificator, clauses, true);
+  };
+  var Companion_instance_6;
+  function Companion_getInstance_4() {
+    return Companion_instance_6;
+  }
+  function firstArguments($this, $receiver) {
+    return sequence(Utils$firstArguments$slambda_0($receiver, null));
+  }
+  function Utils$firstArguments$slambda($this_firstArguments, resultContinuation) {
+    this.p1k_1 = $this_firstArguments;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(Utils$firstArguments$slambda).s1k = function ($this$sequence, $completion) {
+    var tmp = this.t1k($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(Utils$firstArguments$slambda).f9 = function (p1, $completion) {
+    return this.s1k(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(Utils$firstArguments$slambda).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 5;
+            this.r1k_1 = this.p1k_1;
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.r1k_1.nt()) {
+              this.g8_1 = 3;
+              continue $sm;
+            }
+
+            this.g8_1 = 2;
+            suspendResult = this.q1k_1.nc(this.r1k_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.r1k_1 = this.r1k_1.castToStruct().getArgAt(0);
+            this.g8_1 = 1;
+            continue $sm;
+          case 3:
+            this.g8_1 = 4;
+            suspendResult = this.q1k_1.nc(this.r1k_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 4:
+            return Unit_instance;
+          case 5:
+            throw this.j8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 5) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(Utils$firstArguments$slambda).t1k = function ($this$sequence, completion) {
+    var i = new Utils$firstArguments$slambda(this.p1k_1, completion);
+    i.q1k_1 = $this$sequence;
+    return i;
+  };
+  function Utils$firstArguments$slambda_0($this_firstArguments, resultContinuation) {
+    var i = new Utils$firstArguments$slambda($this_firstArguments, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.s1k($this$sequence, $completion);
+    }, 1);
+  }
+  function Utils() {
+  }
+  protoOf(Utils).u1k = function (_this__u8e3s4, nestingLevel) {
+    // Inline function 'kotlin.let' call
+    return takeFirstAfterSkipping(firstArguments(this, _this__u8e3s4), nestingLevel).castToStruct().bt();
+  };
+  protoOf(Utils).v1k = function (_this__u8e3s4, nestingLevel) {
+    // Inline function 'kotlin.let' call
+    return takeFirstAfterSkipping(firstArguments(this, _this__u8e3s4), nestingLevel).castToStruct().ht();
+  };
+  protoOf(Utils).w1k = function (_this__u8e3s4, nestingLevel) {
+    return takeFirstAfterSkipping(firstArguments(this, _this__u8e3s4), nestingLevel);
+  };
+  protoOf(Utils).x1k = function (args) {
+    return this.y1k(listOf(args.slice()));
+  };
+  protoOf(Utils).z1k = function (sequence) {
+    return this.y1k(asIterable(sequence));
+  };
+  protoOf(Utils).y1k = function (iterable) {
+    return mergeSequences(iterable, SituatedIndexedClause$compareTo$ref());
+  };
+  protoOf(Utils).a1l = function (args) {
+    return this.b1l(sequenceOf(args.slice()));
+  };
+  protoOf(Utils).b1l = function (sequence) {
+    return flatten(sequence);
+  };
+  protoOf(Utils).c1l = function (iterable) {
+    return this.b1l(asSequence(iterable));
+  };
+  protoOf(Utils).d1l = function (args) {
+    return this.e1l(sequenceOf(args.slice()));
+  };
+  protoOf(Utils).e1l = function (sequence) {
+    return flatten(sequence);
+  };
+  protoOf(Utils).f1l = function (iterable) {
+    return this.e1l(asSequence(iterable));
+  };
+  protoOf(Utils).g1l = function (a, b) {
+    return a == null && b == null ? null : a == null ? b : b == null ? a : a.rq(b) < 0 ? a : b;
+  };
+  var Utils_instance;
+  function Utils_getInstance() {
+    return Utils_instance;
+  }
+  function IndexedClause$Companion$wrap$1($traversed, $indexedClause) {
+    this.i1l_1 = $indexedClause;
+    this.h1l_1 = listOf($traversed.slice());
+  }
+  protoOf(IndexedClause$Companion$wrap$1).wo = function () {
+    return this.i1l_1.wo();
+  };
+  protoOf(IndexedClause$Companion$wrap$1).c2 = function () {
+    return this.i1l_1.c2();
+  };
+  protoOf(IndexedClause$Companion$wrap$1).j1l = function () {
+    return this.h1l_1;
+  };
+  protoOf(IndexedClause$Companion$wrap$1).z1j = function () {
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = this.h1l_1.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      element.g1k();
+    }
+  };
+  protoOf(IndexedClause$Companion$wrap$1).y1 = function (other) {
+    return this.rq((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_2() {
+  }
+  protoOf(Companion_2).l1l = function (indexedClause, traversed) {
+    return new IndexedClause$Companion$wrap$1(traversed, indexedClause);
+  };
+  protoOf(Companion_2).m1l = function (index, clause, traversed) {
+    return this.l1l(Companion_instance_0.qq(index, clause), traversed.slice());
+  };
+  protoOf(Companion_2).n1l = function (index, clause, traversed) {
+    var tmp = Companion_instance_0.qq(index, clause);
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var tmp$ret$0 = copyToArray(traversed);
+    return this.l1l(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.o1l_1 = $indexed;
+    this.p1l_1 = $index;
+  }
+  protoOf(SituatedIndexedClause$Companion$of$1).wo = function () {
+    return this.o1l_1.wo();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).c2 = function () {
+    return this.o1l_1.c2();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).q1l = function () {
+    this.p1l_1.r1l(this);
+    this.z1j();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).j1l = function () {
+    return this.o1l_1.j1l();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).z1j = function () {
+    this.o1l_1.z1j();
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(!(other == null) ? isInterface(other, SituatedIndexedClause) : false))
+      return false;
+    if (!equalsLong(this.wo(), other.wo()))
+      return false;
+    return true;
+  };
+  protoOf(SituatedIndexedClause$Companion$of$1).y1 = function (other) {
+    return this.rq((!(other == null) ? isInterface(other, LongIndexed) : false) ? other : THROW_CCE());
+  };
+  function Companion_3() {
+  }
+  protoOf(Companion_3).s1l = 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 SituatedIndexedClause$compareTo$ref() {
+    return constructCallableReference(function (p0, p1) {
+      return p0.rq(p1);
+    }, 2, 0, 32, 'compareTo');
+  }
+  function AbstractIndexingLeaf(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  protoOf(AbstractIndexingLeaf).g1k = function () {
+  };
+  function extractFirst($this, clause) {
+    // Inline function 'kotlin.collections.mapNotNull' call
+    var tmp0 = $this.b1m_1.h2();
+    // Inline function 'kotlin.collections.mapNotNullTo' call
+    var destination = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = tmp0.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      var tmp0_safe_receiver = extractFirst_0($this, clause, element);
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        destination.j(tmp0_safe_receiver);
+      }
+    }
+    return minOrNull(destination);
+  }
+  function extractFirst_0($this, clause, index) {
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index_0 = 0;
+      var _iterator__ex2g4s = index.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        if ($this.x1h().match(item.b1k(), clause)) {
+          tmp$ret$0 = index_0;
+          break $l$block;
+        }
+        index_0 = index_0 + 1 | 0;
+      }
+      tmp$ret$0 = -1;
+    }
+    var actualIndex = tmp$ret$0;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.t(actualIndex);
+    }
+    return tmp;
+  }
+  function extractGlobalSequence($this, clause) {
+    var tmp = $this.x1l(clause);
+    return map(tmp, AtomIndex$extractGlobalSequence$lambda);
+  }
+  function nestedFirstArgument($this, $receiver) {
+    return Utils_instance.w1k(ensureNotNull($receiver.nv()), $this.a1m_1 + 1 | 0);
+  }
+  function asInnerAtom($this, $receiver) {
+    return nestedFirstArgument($this, $receiver).castToAtom();
+  }
+  function asInnerAtom_0($this, $receiver) {
+    return nestedFirstArgument($this, $receiver.b1k()).castToAtom();
+  }
+  function asInnerAtom_1($this, $receiver) {
+    return nestedFirstArgument($this, $receiver.b1k()).castToAtom();
+  }
+  function AtomIndex$_get_size_$lambda_ygjfwe(it) {
+    return it.s();
+  }
+  function AtomIndex$get$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function AtomIndex$get$lambda_0(it) {
+    return it.b1k();
+  }
+  function AtomIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function AtomIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.c1k(it, $clause);
+    };
+  }
+  function AtomIndex$retractAll$lambda(it) {
+    return it.b1k();
+  }
+  function AtomIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function AtomIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function AtomIndex$extractGlobalSequence$lambda(it) {
+    return it.b1k();
+  }
+  function AtomIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.z1l_1 = ordered;
+    this.a1m_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.b1m_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(AtomIndex).s = function () {
+    var tmp = asSequence(this.b1m_1.h2());
+    return sum(map(tmp, AtomIndex$_get_size_$lambda_ygjfwe));
+  };
+  protoOf(AtomIndex).c1i = function () {
+    var tmp;
+    if (this.b1m_1.g()) {
+      tmp = true;
+    } else {
+      var tmp0 = this.b1m_1.h2();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp_0;
+        if (isInterface(tmp0, Collection)) {
+          tmp_0 = tmp0.g();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (!element.g()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).f1i = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(this, clause).ct()) {
+      var tmp0_safe_receiver = this.b1m_1.f2(asInnerAtom(this, clause));
+      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$get$lambda(this, clause));
+      }
+      var tmp2_safe_receiver = tmp_0;
+      var tmp_1;
+      if (tmp2_safe_receiver == null) {
+        tmp_1 = null;
+      } else {
+        tmp_1 = map(tmp2_safe_receiver, AtomIndex$get$lambda_0);
+      }
+      var tmp3_elvis_lhs = tmp_1;
+      tmp = tmp3_elvis_lhs == null ? emptySequence() : tmp3_elvis_lhs;
+    } else {
+      tmp = extractGlobalSequence(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).d1k = function (clause) {
+    if (this.z1l_1) {
+      // Inline function 'kotlin.let' call
+      var it = asInnerAtom_1(this, clause);
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.b1m_1;
+      var value = this_0.f2(it);
+      var tmp;
+      if (value == null) {
+        var answer = dequeOf([]);
+        this_0.p4(it, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      var tmp$ret$2 = tmp;
+      addFirst(tmp$ret$2, Companion_instance_8.s1l(clause.k1l(this), this));
+    } else {
+      this.e1k(clause);
+    }
+  };
+  protoOf(AtomIndex).e1k = function (clause) {
+    // Inline function 'kotlin.let' call
+    var it = asInnerAtom_1(this, clause);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.b1m_1;
+    var value = this_0.f2(it);
+    var tmp;
+    if (value == null) {
+      var answer = dequeOf([]);
+      this_0.p4(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.j(Companion_instance_8.s1l(clause.k1l(this), this));
+  };
+  protoOf(AtomIndex).u1l = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(this, clause).ct()) {
+      // Inline function 'kotlin.let' call
+      var it = this.b1m_1.f2(asInnerAtom(this, clause));
+      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).v1l = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(this, clause).ct()) {
+      var tmp0_safe_receiver = this.b1m_1.f2(asInnerAtom(this, clause));
+      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.x1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(AtomIndex).r1l = function (indexed) {
+    ensureNotNull(this.b1m_1.f2(asInnerAtom_0(this, indexed))).e3(indexed);
+  };
+  protoOf(AtomIndex).w1l = function (clause) {
+    var tmp;
+    if (nestedFirstArgument(this, clause).ct()) {
+      var partialIndex = this.b1m_1.f2(asInnerAtom(this, clause));
+      tmp = partialIndex == null ? emptySequence() : this.c1k(partialIndex, clause);
+    } else {
+      var tmp_0 = Utils_instance;
+      var tmp_1 = asSequence(this.b1m_1.h2());
+      tmp = tmp_0.z1k(map(tmp_1, AtomIndex$retractAllIndexed$lambda(this, clause)));
+    }
+    return buffered(tmp);
+  };
+  protoOf(AtomIndex).p1i = function (clause) {
+    var tmp = this.w1l(clause);
+    return map(tmp, AtomIndex$retractAll$lambda);
+  };
+  protoOf(AtomIndex).f1k = function () {
+    var tmp = Utils_instance;
+    var tmp_0 = asSequence(this.b1m_1.h2());
+    return tmp.z1k(map(tmp_0, AtomIndex$getCache$lambda));
+  };
+  protoOf(AtomIndex).x1l = function (clause) {
+    var tmp = this.f1k();
+    return filter(tmp, AtomIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function retractAllOrdered($this, clause) {
+    var tmp;
+    if (isGlobal($this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.w1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      var tmp_1 = tmp_0.y1k(destination);
+      tmp = map(tmp_1, CompoundIndex$retractAllOrdered$lambda);
+    } else {
+      var tmp0_safe_receiver = $this.f1m_1.f2(nestedFunctor($this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1i(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  }
+  function retractAllUnordered($this, clause) {
+    var tmp;
+    if (isGlobal($this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.p1i(clause);
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.f1l(destination);
+    } else {
+      var tmp0_safe_receiver = $this.f1m_1.f2(nestedFunctor($this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1i(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  }
+  function nestedFunctor($this, $receiver) {
+    return Utils_instance.v1k(ensureNotNull($receiver.nv()), $this.e1m_1);
+  }
+  function nestedFunctor_0($this, $receiver) {
+    return Utils_instance.v1k(ensureNotNull($receiver.b1k().nv()), $this.e1m_1);
+  }
+  function isGlobal($this, $receiver) {
+    return Utils_instance.w1k(ensureNotNull($receiver.nv()), $this.e1m_1).du();
+  }
+  function regenerateCache($this) {
+    var tmp;
+    if ($this.d1m_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.f1k();
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s_0 = this_1.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var item_0 = _iterator__ex2g4s_0.q();
+        var tmp$ret$5 = item_0.f1k();
+        destination_0.j(tmp$ret$5);
+      }
+      tmp = tmp_1.c1l(destination_0);
+    }
+    return dequeOf_0(tmp);
+  }
+  function CompoundIndex$regenerateCache$ref(p0) {
+    return constructCallableReference(function () {
+      var tmp0 = p0;
+      return regenerateCache(tmp0);
+    }, 0, 0, 33, 'regenerateCache', [p0]);
+  }
+  function CompoundIndex$_get_size_$lambda_91vt0k(it) {
+    return it.s();
+  }
+  function CompoundIndex$get$lambda($clause) {
+    return function (it) {
+      return it.v1l($clause);
+    };
+  }
+  function CompoundIndex$get$lambda_0(it) {
+    return it.b1k();
+  }
+  function CompoundIndex$get$lambda_1($clause) {
+    return function (it) {
+      return it.f1i($clause);
+    };
+  }
+  function CompoundIndex$retractAllOrdered$lambda(it) {
+    return it.b1k();
+  }
+  function CompoundIndex(unificator, ordered, nestingLevel) {
+    AbstractReteNode.call(this, unificator);
+    this.d1m_1 = ordered;
+    this.e1m_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.f1m_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.g1m_1 = tmp_1.io(CompoundIndex$regenerateCache$ref(this));
+  }
+  protoOf(CompoundIndex).s = function () {
+    var tmp = asSequence(this.f1m_1.h2());
+    return sum(map(tmp, CompoundIndex$_get_size_$lambda_91vt0k));
+  };
+  protoOf(CompoundIndex).c1i = function () {
+    var tmp;
+    if (this.f1m_1.g()) {
+      tmp = true;
+    } else {
+      var tmp0 = this.f1m_1.h2();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp_0;
+        if (isInterface(tmp0, Collection)) {
+          tmp_0 = tmp0.g();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (!element.c1i()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).f1i = function (clause) {
+    var tmp;
+    if (isGlobal(this, clause)) {
+      var tmp_0;
+      if (this.d1m_1) {
+        var tmp_1 = Utils_instance;
+        var tmp_2 = asSequence(this.f1m_1.h2());
+        var tmp_3 = tmp_1.x1k([flatMap(tmp_2, CompoundIndex$get$lambda(clause))]);
+        tmp_0 = map(tmp_3, CompoundIndex$get$lambda_0);
+      } else {
+        var tmp_4 = Utils_instance;
+        var tmp_5 = asSequence(this.f1m_1.h2());
+        tmp_0 = tmp_4.d1l([flatMap(tmp_5, CompoundIndex$get$lambda_1(clause))]);
+      }
+      tmp = tmp_0;
+    } else {
+      var tmp0_safe_receiver = this.f1m_1.f2(nestedFunctor(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.f1i(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).d1k = function (clause) {
+    // Inline function 'kotlin.let' call
+    var it = nestedFunctor_0(this, clause);
+    if (this.d1m_1) {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.f1m_1;
+      var value = this_0.f2(it);
+      var tmp;
+      if (value == null) {
+        var answer = new FunctorIndexingNode(this.x1h(), this.d1m_1, this.e1m_1);
+        this_0.p4(it, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      tmp.d1k(clause.k1l(this));
+    } else {
+      this.e1k(clause);
+    }
+    return Unit_instance;
+  };
+  protoOf(CompoundIndex).e1k = function (clause) {
+    // Inline function 'kotlin.let' call
+    var it = nestedFunctor_0(this, clause);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.f1m_1;
+    var value = this_0.f2(it);
+    var tmp;
+    if (value == null) {
+      var answer = new FunctorIndexingNode(this.x1h(), this.d1m_1, this.e1m_1);
+      this_0.p4(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.e1k(clause.k1l(this));
+    return Unit_instance;
+  };
+  protoOf(CompoundIndex).p1i = function (clause) {
+    var tmp;
+    if (this.d1m_1) {
+      tmp = retractAllOrdered(this, clause);
+    } else {
+      tmp = retractAllUnordered(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).f1k = function () {
+    return asSequence(this.g1m_1.c2());
+  };
+  protoOf(CompoundIndex).u1l = function (clause) {
+    var tmp;
+    if (isGlobal(this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.mapNotNull' call
+      var tmp0 = this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapNotNullTo' call
+      var destination = ArrayList_init_$Create$_0();
+      // Inline function 'kotlin.collections.forEach' call
+      var _iterator__ex2g4s = tmp0.m();
+      while (_iterator__ex2g4s.p()) {
+        var element = _iterator__ex2g4s.q();
+        var tmp0_safe_receiver = element.u1l(clause);
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          destination.j(tmp0_safe_receiver);
+        }
+      }
+      tmp = firstOrNull(tmp_0.z1k(sequenceOf_0(asSequence(destination))));
+    } else {
+      var tmp0_safe_receiver_0 = this.f1m_1.f2(nestedFunctor(this, clause));
+      tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.u1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).v1l = function (clause) {
+    var tmp;
+    if (isGlobal(this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.x1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp0_safe_receiver = this.f1m_1.f2(nestedFunctor(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v1l(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).w1l = function (clause) {
+    var tmp;
+    if (isGlobal(this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.w1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp0_safe_receiver = this.f1m_1.f2(nestedFunctor(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.w1l(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).x1l = function (clause) {
+    var tmp;
+    if (this.d1m_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.x1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = this.f1m_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s_0 = this_1.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var item_0 = _iterator__ex2g4s_0.q();
+        var tmp$ret$5 = item_0.x1l(clause);
+        destination_0.j(tmp$ret$5);
+      }
+      tmp = tmp_1.c1l(destination_0);
+    }
+    return tmp;
+  };
+  protoOf(CompoundIndex).g1k = function () {
+    this.g1m_1.ko();
+  };
+  function DirectiveIndex$retractFirst$lambda(it) {
+    return it.b1k();
+  }
+  function DirectiveIndex$retractAll$lambda(it) {
+    return it.b1k();
+  }
+  function DirectiveIndex$getCache$lambda(it) {
+    var tmp = Companion_instance_8;
+    return tmp.s1l(it, new DirectiveIndex$getCache$1$1());
+  }
+  function DirectiveIndex$getCache$1$1() {
+  }
+  protoOf(DirectiveIndex$getCache$1$1).r1l = 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.i1m_1 = ordered;
+    this.j1m_1 = dequeOf([]);
+  }
+  protoOf(DirectiveIndex).s = function () {
+    return this.j1m_1.s();
+  };
+  protoOf(DirectiveIndex).c1i = function () {
+    return this.j1m_1.g();
+  };
+  protoOf(DirectiveIndex).f1i = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = this.j1m_1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      if (this.x1h().match(element.b1k(), clause)) {
+        destination.j(element);
+      }
+    }
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(destination, 10));
+    var _iterator__ex2g4s_0 = destination.m();
+    while (_iterator__ex2g4s_0.p()) {
+      var item = _iterator__ex2g4s_0.q();
+      var tmp$ret$5 = item.b1k();
+      destination_0.j(tmp$ret$5);
+    }
+    return asSequence(destination_0);
+  };
+  protoOf(DirectiveIndex).d1k = function (clause) {
+    if (this.i1m_1) {
+      addFirst(this.j1m_1, clause.k1l(this));
+    } else {
+      this.e1k(clause);
+    }
+  };
+  protoOf(DirectiveIndex).e1k = function (clause) {
+    this.j1m_1.j(clause.k1l(this));
+  };
+  protoOf(DirectiveIndex).n1i = function (clause) {
+    var tmp = this.c1k(this.j1m_1, clause);
+    return buffered(take(map(tmp, DirectiveIndex$retractFirst$lambda), 1));
+  };
+  protoOf(DirectiveIndex).p1i = function (clause) {
+    var tmp = this.c1k(this.j1m_1, clause);
+    return buffered(map(tmp, DirectiveIndex$retractAll$lambda));
+  };
+  protoOf(DirectiveIndex).f1k = function () {
+    var tmp = asSequence(this.j1m_1);
+    return map(tmp, DirectiveIndex$getCache$lambda);
+  };
+  protoOf(DirectiveIndex).g1k = function () {
+  };
+  function extractFirst_1($this, clause) {
+    // Inline function 'kotlin.collections.mapNotNull' call
+    var tmp0 = $this.n1m_1.h2();
+    // Inline function 'kotlin.collections.mapNotNullTo' call
+    var destination = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = tmp0.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      var tmp0_safe_receiver = extractFirst_2($this, clause, element);
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        destination.j(tmp0_safe_receiver);
+      }
+    }
+    return minOrNull(destination);
+  }
+  function extractFirst_2($this, clause, index) {
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index_0 = 0;
+      var _iterator__ex2g4s = index.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        if ($this.x1h().match(item.b1k(), clause)) {
+          tmp$ret$0 = index_0;
+          break $l$block;
+        }
+        index_0 = index_0 + 1 | 0;
+      }
+      tmp$ret$0 = -1;
+    }
+    var actualIndex = tmp$ret$0;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.t(actualIndex);
+    }
+    return tmp;
+  }
+  function extractGlobalSequence_0($this, clause) {
+    var tmp = $this.x1l(clause);
+    return map(tmp, NumericIndex$extractGlobalSequence$lambda);
+  }
+  function nestedFirstArgument_0($this, $receiver) {
+    return Utils_instance.w1k(ensureNotNull($receiver.nv()), $this.m1m_1 + 1 | 0);
+  }
+  function asInnerNumeric($this, $receiver) {
+    return nestedFirstArgument_0($this, $receiver).castToNumeric();
+  }
+  function asInnerNumeric_0($this, $receiver) {
+    return nestedFirstArgument_0($this, $receiver.b1k()).castToNumeric();
+  }
+  function asInnerNumeric_1($this, $receiver) {
+    return nestedFirstArgument_0($this, $receiver.b1k()).castToNumeric();
+  }
+  function NumericIndex$_get_size_$lambda_exo30i(it) {
+    return it.s();
+  }
+  function NumericIndex$get$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function NumericIndex$get$lambda_0(it) {
+    return it.b1k();
+  }
+  function NumericIndex$getIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function NumericIndex$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.c1k(it, $clause);
+    };
+  }
+  function NumericIndex$retractAll$lambda(it) {
+    return it.b1k();
+  }
+  function NumericIndex$getCache$lambda(it) {
+    return asSequence(it);
+  }
+  function NumericIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function NumericIndex$extractGlobalSequence$lambda(it) {
+    return it.b1k();
+  }
+  function NumericIndex(unificator, ordered, nestingLevel) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.l1m_1 = ordered;
+    this.m1m_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.n1m_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(NumericIndex).s = function () {
+    var tmp = asSequence(this.n1m_1.h2());
+    return sum(map(tmp, NumericIndex$_get_size_$lambda_exo30i));
+  };
+  protoOf(NumericIndex).c1i = function () {
+    var tmp;
+    if (this.n1m_1.g()) {
+      tmp = true;
+    } else {
+      var tmp0 = this.n1m_1.h2();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp_0;
+        if (isInterface(tmp0, Collection)) {
+          tmp_0 = tmp0.g();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (!element.g()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).f1i = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(this, clause).hu()) {
+      var tmp0_safe_receiver = this.n1m_1.f2(asInnerNumeric(this, clause));
+      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$get$lambda(this, clause));
+      }
+      var tmp2_safe_receiver = tmp_0;
+      var tmp_1;
+      if (tmp2_safe_receiver == null) {
+        tmp_1 = null;
+      } else {
+        tmp_1 = map(tmp2_safe_receiver, NumericIndex$get$lambda_0);
+      }
+      var tmp3_elvis_lhs = tmp_1;
+      tmp = tmp3_elvis_lhs == null ? emptySequence() : tmp3_elvis_lhs;
+    } else {
+      tmp = extractGlobalSequence_0(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).d1k = function (clause) {
+    if (this.l1m_1) {
+      // Inline function 'kotlin.let' call
+      var it = asInnerNumeric_1(this, clause);
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.n1m_1;
+      var value = this_0.f2(it);
+      var tmp;
+      if (value == null) {
+        var answer = dequeOf([]);
+        this_0.p4(it, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      var tmp$ret$2 = tmp;
+      addFirst(tmp$ret$2, Companion_instance_8.s1l(clause.k1l(this), this));
+    } else {
+      this.e1k(clause);
+    }
+  };
+  protoOf(NumericIndex).e1k = function (clause) {
+    // Inline function 'kotlin.let' call
+    var it = asInnerNumeric_1(this, clause);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.n1m_1;
+    var value = this_0.f2(it);
+    var tmp;
+    if (value == null) {
+      var answer = dequeOf([]);
+      this_0.p4(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.j(Companion_instance_8.s1l(clause.k1l(this), this));
+  };
+  protoOf(NumericIndex).u1l = function (clause) {
+    if (nestedFirstArgument_0(this, clause).hu()) {
+      // Inline function 'kotlin.let' call
+      var it = this.n1m_1.f2(asInnerNumeric(this, clause));
+      var tmp;
+      if (it == null) {
+        tmp = null;
+      } else {
+        tmp = extractFirst_2(this, clause, it);
+      }
+      return tmp;
+    } else {
+      return extractFirst_1(this, clause);
+    }
+  };
+  protoOf(NumericIndex).v1l = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(this, clause).hu()) {
+      var tmp0_safe_receiver = this.n1m_1.f2(asInnerNumeric(this, clause));
+      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.x1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).r1l = function (indexed) {
+    ensureNotNull(this.n1m_1.f2(asInnerNumeric_0(this, indexed))).e3(indexed);
+  };
+  protoOf(NumericIndex).w1l = function (clause) {
+    var tmp;
+    if (nestedFirstArgument_0(this, clause).hu()) {
+      var partialIndex = this.n1m_1.f2(asInnerNumeric(this, clause));
+      tmp = partialIndex == null ? emptySequence() : buffered(this.c1k(partialIndex, clause));
+    } else {
+      var tmp_0 = Utils_instance;
+      var tmp_1 = asSequence(this.n1m_1.h2());
+      tmp = buffered(tmp_0.z1k(map(tmp_1, NumericIndex$retractAllIndexed$lambda(this, clause))));
+    }
+    return tmp;
+  };
+  protoOf(NumericIndex).p1i = function (clause) {
+    var tmp = this.w1l(clause);
+    return map(tmp, NumericIndex$retractAll$lambda);
+  };
+  protoOf(NumericIndex).f1k = function () {
+    var tmp = Utils_instance;
+    var tmp_0 = asSequence(this.n1m_1.h2());
+    return tmp.z1k(map(tmp_0, NumericIndex$getCache$lambda));
+  };
+  protoOf(NumericIndex).x1l = function (clause) {
+    var tmp = this.f1k();
+    return filter(tmp, NumericIndex$extractGlobalIndexedSequence$lambda(this, clause));
+  };
+  function extractFirst_3($this, clause, index) {
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index_0 = 0;
+      var _iterator__ex2g4s = index.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        if ($this.x1h().match(item.b1k(), clause)) {
+          tmp$ret$0 = index_0;
+          break $l$block;
+        }
+        index_0 = index_0 + 1 | 0;
+      }
+      tmp$ret$0 = -1;
+    }
+    var actualIndex = tmp$ret$0;
+    var tmp;
+    if (actualIndex === -1) {
+      tmp = null;
+    } else {
+      tmp = index.t(actualIndex);
+    }
+    return tmp;
+  }
+  function extractGlobalSequence_1($this, clause) {
+    var tmp = $this.x1l(clause);
+    return map(tmp, VariableIndex$extractGlobalSequence$lambda);
+  }
+  function VariableIndex$retractAll$lambda(it) {
+    return it.b1k();
+  }
+  function VariableIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function VariableIndex$extractGlobalSequence$lambda(it) {
+    return it.b1k();
+  }
+  function VariableIndex(unificator, ordered) {
+    AbstractIndexingLeaf.call(this, unificator);
+    this.p1m_1 = ordered;
+    this.q1m_1 = dequeOf([]);
+  }
+  protoOf(VariableIndex).s = function () {
+    return this.q1m_1.s();
+  };
+  protoOf(VariableIndex).c1i = function () {
+    return this.q1m_1.g();
+  };
+  protoOf(VariableIndex).f1i = function (clause) {
+    return extractGlobalSequence_1(this, clause);
+  };
+  protoOf(VariableIndex).d1k = function (clause) {
+    var tmp;
+    if (this.p1m_1) {
+      addFirst(this.q1m_1, Companion_instance_8.s1l(clause.k1l(this), this));
+      tmp = Unit_instance;
+    } else {
+      this.e1k(clause);
+      tmp = Unit_instance;
+    }
+    return tmp;
+  };
+  protoOf(VariableIndex).e1k = function (clause) {
+    this.q1m_1.j(Companion_instance_8.s1l(clause.k1l(this), this));
+  };
+  protoOf(VariableIndex).p1i = function (clause) {
+    var tmp = this.w1l(clause);
+    return map(tmp, VariableIndex$retractAll$lambda);
+  };
+  protoOf(VariableIndex).f1k = function () {
+    return asSequence(this.q1m_1);
+  };
+  protoOf(VariableIndex).u1l = function (clause) {
+    return extractFirst_3(this, clause, this.q1m_1);
+  };
+  protoOf(VariableIndex).v1l = function (clause) {
+    return this.x1l(clause);
+  };
+  protoOf(VariableIndex).r1l = function (indexed) {
+    this.q1m_1.e3(indexed);
+  };
+  protoOf(VariableIndex).w1l = function (clause) {
+    return buffered(this.c1k(this.q1m_1, clause));
+  };
+  protoOf(VariableIndex).x1l = function (clause) {
+    var tmp = asSequence(this.q1m_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.z1m_1 = ordered;
+  }
+  protoOf(FamilyArityIndexingNode).u1l = function (clause) {
+    var tmp;
+    if (this.z1m_1) {
+      tmp = this.j1n(clause);
+    } else {
+      tmp = this.i1n(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).v1l = function (clause) {
+    var tmp;
+    if (this.z1m_1) {
+      tmp = this.l1n(clause);
+    } else {
+      tmp = this.k1n(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).w1l = function (clause) {
+    var tmp;
+    if (this.z1m_1) {
+      tmp = this.n1n(clause);
+    } else {
+      tmp = this.m1n(clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityIndexingNode).x1l = function (clause) {
+    var tmp;
+    if (this.z1m_1) {
+      tmp = Utils_instance.x1k([this.e1n_1.x1l(clause), this.d1n_1.x1l(clause), this.f1n_1.x1l(clause), this.g1n_1.x1l(clause)]);
+    } else {
+      tmp = Utils_instance.a1l([this.e1n_1.x1l(clause), this.d1n_1.x1l(clause), this.f1n_1.x1l(clause), this.g1n_1.x1l(clause)]);
+    }
+    return tmp;
+  };
+  function retractAllOrdered_0($this, clause) {
+    var tmp = $this.n1n(clause);
+    return map(tmp, FamilyArityReteNode$retractAllOrdered$lambda);
+  }
+  function getOrdered($this, clause) {
+    var tmp = $this.l1n(clause);
+    return map(tmp, FamilyArityReteNode$getOrdered$lambda);
+  }
+  function retractAllUnordered_0($this, clause) {
+    var tmp = $this.m1n(clause);
+    return map(tmp, FamilyArityReteNode$retractAllUnordered$lambda);
+  }
+  function getUnordered($this, clause) {
+    var tmp = $this.k1n(clause);
+    return map(tmp, FamilyArityReteNode$getUnordered$lambda);
+  }
+  function regenerateCache_0($this) {
+    var tmp;
+    if ($this.b1n_1) {
+      tmp = Utils_instance.x1k([$this.e1n_1.f1k(), $this.d1n_1.f1k(), $this.f1n_1.f1k(), $this.g1n_1.f1k()]);
+    } else {
+      tmp = Utils_instance.a1l([$this.e1n_1.f1k(), $this.d1n_1.f1k(), $this.f1n_1.f1k(), $this.g1n_1.f1k()]);
+    }
+    return dequeOf_0(tmp);
+  }
+  function nestedFirstArgument_1($this, $receiver) {
+    return Utils_instance.w1k(ensureNotNull($receiver.nv()), $this.c1n_1 + 1 | 0);
+  }
+  function assertByFirstParameter($this, clause) {
+    var innerFirst = nestedFirstArgument_1($this, clause.b1k());
+    return innerFirst.hu() ? $this.d1n_1 : innerFirst.ct() ? $this.e1n_1 : innerFirst.du() ? $this.f1n_1 : $this.g1n_1;
+  }
+  function isGlobal_0($this, $receiver) {
+    return Utils_instance.w1k(ensureNotNull($receiver.nv()), $this.c1n_1 + 1 | 0).du();
+  }
+  function FamilyArityReteNode$regenerateCache$ref(p0) {
+    return constructCallableReference(function () {
+      var tmp0 = p0;
+      return regenerateCache_0(tmp0);
+    }, 0, 0, 34, 'regenerateCache', [p0]);
+  }
+  function FamilyArityReteNode$_get_size_$lambda_sxz8zo(it) {
+    return it.s();
+  }
+  function FamilyArityReteNode$get$lambda(it) {
+    return it.b1k();
+  }
+  function FamilyArityReteNode$get$lambda_0(it) {
+    return it.b1k();
+  }
+  function FamilyArityReteNode$retractAllOrdered$lambda(it) {
+    return it.b1k();
+  }
+  function FamilyArityReteNode$getOrdered$lambda(it) {
+    return it.b1k();
+  }
+  function FamilyArityReteNode$retractAllUnordered$lambda(it) {
+    return it.b1k();
+  }
+  function FamilyArityReteNode$getUnordered$lambda(it) {
+    return it.b1k();
+  }
+  function FamilyArityReteNode(unificator, ordered, nestingLevel) {
+    ArityNode.call(this, unificator);
+    this.b1n_1 = ordered;
+    this.c1n_1 = nestingLevel;
+    this.d1n_1 = new NumericIndex(unificator, this.b1n_1, this.c1n_1);
+    this.e1n_1 = new AtomIndex(unificator, this.b1n_1, this.c1n_1);
+    this.f1n_1 = new VariableIndex(unificator, this.b1n_1);
+    this.g1n_1 = new CompoundIndex(unificator, this.b1n_1, this.c1n_1 + 1 | 0);
+    var tmp = this;
+    var tmp_0 = Companion_instance_1;
+    tmp.h1n_1 = tmp_0.io(FamilyArityReteNode$regenerateCache$ref(this));
+  }
+  protoOf(FamilyArityReteNode).n1i = function (clause) {
+    var tmp;
+    if (this.b1n_1) {
+      tmp = this.j1n(clause);
+    } else {
+      tmp = this.i1n(clause);
+    }
+    var result = tmp;
+    var tmp_0;
+    if (result == null) {
+      tmp_0 = emptySequence();
+    } else {
+      result.q1l();
+      this.g1k();
+      tmp_0 = sequenceOf_0(result.b1k());
+    }
+    return tmp_0;
+  };
+  protoOf(FamilyArityReteNode).s = function () {
+    var tmp = sequenceOf([this.d1n_1, this.e1n_1, this.f1n_1, this.g1n_1]);
+    return sum(map(tmp, FamilyArityReteNode$_get_size_$lambda_sxz8zo));
+  };
+  protoOf(FamilyArityReteNode).c1i = function () {
+    var tmp0 = sequenceOf([this.d1n_1, this.e1n_1, this.f1n_1, this.g1n_1]);
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var _iterator__ex2g4s = tmp0.m();
+      while (_iterator__ex2g4s.p()) {
+        var element = _iterator__ex2g4s.q();
+        if (!element.c1i()) {
+          tmp$ret$0 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  };
+  protoOf(FamilyArityReteNode).f1i = function (clause) {
+    var tmp;
+    if (isGlobal_0(this, clause)) {
+      var tmp_0;
+      if (this.b1n_1) {
+        var tmp_1 = Utils_instance.x1k([this.e1n_1.x1l(clause), this.f1n_1.x1l(clause), this.d1n_1.x1l(clause), this.g1n_1.x1l(clause)]);
+        tmp_0 = map(tmp_1, FamilyArityReteNode$get$lambda);
+      } else {
+        var tmp_2 = Utils_instance.a1l([this.e1n_1.x1l(clause), this.f1n_1.x1l(clause), this.d1n_1.x1l(clause), this.g1n_1.x1l(clause)]);
+        tmp_0 = map(tmp_2, FamilyArityReteNode$get$lambda_0);
+      }
+      tmp = tmp_0;
+    } else {
+      var tmp_3;
+      if (this.b1n_1) {
+        tmp_3 = getOrdered(this, clause);
+      } else {
+        tmp_3 = getUnordered(this, clause);
+      }
+      tmp = tmp_3;
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).d1k = function (clause) {
+    return assertByFirstParameter(this, clause).d1k(clause.k1l(this));
+  };
+  protoOf(FamilyArityReteNode).e1k = function (clause) {
+    return assertByFirstParameter(this, clause).e1k(clause.k1l(this));
+  };
+  protoOf(FamilyArityReteNode).p1i = function (clause) {
+    var tmp;
+    if (this.b1n_1) {
+      tmp = retractAllOrdered_0(this, clause);
+    } else {
+      tmp = retractAllUnordered_0(this, clause);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).f1k = function () {
+    return asSequence(this.h1n_1.c2());
+  };
+  protoOf(FamilyArityReteNode).n1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(this, clause);
+    var tmp;
+    if (innerFirst.hu()) {
+      tmp = Utils_instance.x1k([this.f1n_1.w1l(clause), this.d1n_1.w1l(clause)]);
+    } else if (innerFirst.ct()) {
+      tmp = Utils_instance.x1k([this.f1n_1.w1l(clause), this.e1n_1.w1l(clause)]);
+    } else if (innerFirst.du()) {
+      tmp = Utils_instance.x1k([this.f1n_1.w1l(clause), this.d1n_1.w1l(clause), this.e1n_1.w1l(clause), this.g1n_1.w1l(clause)]);
+    } else {
+      tmp = Utils_instance.x1k([this.f1n_1.w1l(clause), this.g1n_1.w1l(clause)]);
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).m1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(this, clause);
+    return innerFirst.hu() ? Utils_instance.a1l([this.f1n_1.w1l(clause), this.d1n_1.w1l(clause)]) : innerFirst.ct() ? Utils_instance.a1l([this.f1n_1.w1l(clause), this.e1n_1.w1l(clause)]) : innerFirst.du() ? Utils_instance.a1l([this.f1n_1.w1l(clause), this.d1n_1.w1l(clause), this.e1n_1.w1l(clause), this.g1n_1.w1l(clause)]) : Utils_instance.a1l([this.f1n_1.w1l(clause), this.g1n_1.w1l(clause)]);
+  };
+  protoOf(FamilyArityReteNode).l1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(this, clause);
+    return innerFirst.hu() ? Utils_instance.x1k([this.f1n_1.v1l(clause), this.d1n_1.v1l(clause)]) : innerFirst.ct() ? Utils_instance.x1k([this.f1n_1.v1l(clause), this.e1n_1.v1l(clause)]) : innerFirst.du() ? Utils_instance.x1k([this.f1n_1.v1l(clause), this.d1n_1.v1l(clause), this.e1n_1.v1l(clause), this.g1n_1.v1l(clause)]) : Utils_instance.x1k([this.f1n_1.v1l(clause), this.g1n_1.v1l(clause)]);
+  };
+  protoOf(FamilyArityReteNode).k1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(this, clause);
+    return innerFirst.hu() ? Utils_instance.a1l([this.f1n_1.v1l(clause), this.d1n_1.v1l(clause)]) : innerFirst.ct() ? Utils_instance.a1l([this.f1n_1.v1l(clause), this.e1n_1.v1l(clause)]) : innerFirst.du() ? Utils_instance.a1l([this.f1n_1.v1l(clause), this.d1n_1.v1l(clause), this.e1n_1.v1l(clause), this.g1n_1.v1l(clause)]) : Utils_instance.a1l([this.f1n_1.v1l(clause), this.g1n_1.v1l(clause)]);
+  };
+  protoOf(FamilyArityReteNode).i1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(this, clause);
+    var tmp;
+    if (innerFirst.hu()) {
+      var tmp0_elvis_lhs = this.f1n_1.u1l(clause);
+      tmp = tmp0_elvis_lhs == null ? this.d1n_1.u1l(clause) : tmp0_elvis_lhs;
+    } else if (innerFirst.ct()) {
+      var tmp1_elvis_lhs = this.f1n_1.u1l(clause);
+      tmp = tmp1_elvis_lhs == null ? this.e1n_1.u1l(clause) : tmp1_elvis_lhs;
+    } else if (innerFirst.du()) {
+      var tmp2_elvis_lhs = this.f1n_1.u1l(clause);
+      var tmp3_elvis_lhs = tmp2_elvis_lhs == null ? this.d1n_1.u1l(clause) : tmp2_elvis_lhs;
+      var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? this.e1n_1.u1l(clause) : tmp3_elvis_lhs;
+      tmp = tmp4_elvis_lhs == null ? this.g1n_1.u1l(clause) : tmp4_elvis_lhs;
+    } else {
+      var tmp5_elvis_lhs = this.f1n_1.u1l(clause);
+      tmp = tmp5_elvis_lhs == null ? this.g1n_1.u1l(clause) : tmp5_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).j1n = function (clause) {
+    var innerFirst = nestedFirstArgument_1(this, clause);
+    var tmp;
+    if (innerFirst.hu()) {
+      tmp = Utils_instance.g1l(this.d1n_1.u1l(clause), this.f1n_1.u1l(clause));
+    } else if (innerFirst.ct()) {
+      tmp = Utils_instance.g1l(this.e1n_1.u1l(clause), this.f1n_1.u1l(clause));
+    } else if (innerFirst.du()) {
+      tmp = Utils_instance.g1l(Utils_instance.g1l(this.d1n_1.u1l(clause), this.e1n_1.u1l(clause)), Utils_instance.g1l(this.f1n_1.u1l(clause), this.g1n_1.u1l(clause)));
+    } else {
+      tmp = Utils_instance.g1l(this.f1n_1.u1l(clause), this.g1n_1.u1l(clause));
+    }
+    return tmp;
+  };
+  protoOf(FamilyArityReteNode).g1k = function () {
+    this.h1n_1.ko();
+  };
+  function isGlobal_1($this, $receiver) {
+    return $receiver.pt() && Utils_instance.w1k($receiver.castToRule().nv(), $this.q1n_1).du();
+  }
+  function nestedArity($this, $receiver) {
+    var tmp0_safe_receiver = $receiver.asRule();
+    var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.nv();
+    var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : Utils_instance.u1k(tmp1_safe_receiver, $this.q1n_1);
+    var tmp;
+    if (tmp2_elvis_lhs == null) {
+      // Inline function 'kotlin.error' call
+      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, $receiver) {
+    return Utils_instance.u1k(ensureNotNull($receiver.b1k().nv()), $this.q1n_1);
+  }
+  function regenerateCache_1($this) {
+    var tmp;
+    if ($this.p1n_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.f1k();
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s_0 = this_1.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var item_0 = _iterator__ex2g4s_0.q();
+        var tmp$ret$5 = item_0.f1k();
+        destination_0.j(tmp$ret$5);
+      }
+      tmp = tmp_1.c1l(destination_0);
+    }
+    return dequeOf_0(tmp);
+  }
+  function FunctorIndexingNode$regenerateCache$ref(p0) {
+    return constructCallableReference(function () {
+      var tmp0 = p0;
+      return regenerateCache_1(tmp0);
+    }, 0, 0, 35, 'regenerateCache', [p0]);
+  }
+  function FunctorIndexingNode$_get_size_$lambda_vcufvm(it) {
+    return it.s();
+  }
+  function FunctorIndexingNode$retractAllIndexed$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function FunctorIndexingNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.p1n_1 = ordered;
+    this.q1n_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.r1n_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.s1n_1 = tmp_1.io(FunctorIndexingNode$regenerateCache$ref(this));
+  }
+  protoOf(FunctorIndexingNode).s = function () {
+    var tmp = asSequence(this.r1n_1.h2());
+    return sum(map(tmp, FunctorIndexingNode$_get_size_$lambda_vcufvm));
+  };
+  protoOf(FunctorIndexingNode).c1i = function () {
+    var tmp;
+    if (this.r1n_1.g()) {
+      tmp = true;
+    } else {
+      var tmp0 = this.r1n_1.h2();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp_0;
+        if (isInterface(tmp0, Collection)) {
+          tmp_0 = tmp0.g();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (!element.c1i()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).f1i = function (clause) {
+    var tmp0_safe_receiver = this.r1n_1.f2(nestedArity(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.f1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(FunctorIndexingNode).d1k = function (clause) {
+    var tmp0 = this.r1n_1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var key = nestedArity_0(this, clause);
+    var value = tmp0.f2(key);
+    var tmp;
+    if (value == null) {
+      var answer = new FamilyArityIndexingNode(this.x1h(), this.p1n_1, this.q1n_1);
+      tmp0.p4(key, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.d1k(clause.k1l(this));
+  };
+  protoOf(FunctorIndexingNode).e1k = function (clause) {
+    var tmp0 = this.r1n_1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var key = nestedArity_0(this, clause);
+    var value = tmp0.f2(key);
+    var tmp;
+    if (value == null) {
+      var answer = new FamilyArityIndexingNode(this.x1h(), this.p1n_1, this.q1n_1);
+      tmp0.p4(key, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.e1k(clause.k1l(this));
+  };
+  protoOf(FunctorIndexingNode).p1i = function (clause) {
+    var tmp0_safe_receiver = this.r1n_1.f2(nestedArity(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(FunctorIndexingNode).f1k = function () {
+    return asSequence(this.s1n_1.c2());
+  };
+  protoOf(FunctorIndexingNode).u1l = function (clause) {
+    var tmp;
+    if (isGlobal_1(this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.x1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      var tmp0 = tmp_0.y1k(destination);
+      var tmp$ret$3;
+      $l$block: {
+        // Inline function 'kotlin.sequences.firstOrNull' call
+        var _iterator__ex2g4s_0 = tmp0.m();
+        while (_iterator__ex2g4s_0.p()) {
+          var element = _iterator__ex2g4s_0.q();
+          if (this.x1h().match(element.b1k(), clause)) {
+            tmp$ret$3 = element;
+            break $l$block;
+          }
+        }
+        tmp$ret$3 = null;
+      }
+      tmp = tmp$ret$3;
+    } else {
+      var tmp0_safe_receiver = this.r1n_1.f2(nestedArity(this, clause));
+      tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u1l(clause);
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).v1l = function (clause) {
+    var tmp;
+    if (isGlobal_1(this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.x1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp0_safe_receiver = this.r1n_1.f2(nestedArity(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v1l(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).w1l = function (clause) {
+    var tmp;
+    if (isGlobal_1(this, clause)) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.x1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      var tmp_1 = tmp_0.y1k(destination);
+      var partialResult = toList(filter(tmp_1, FunctorIndexingNode$retractAllIndexed$lambda(this, clause)));
+      // Inline function 'kotlin.collections.isNotEmpty' call
+      if (!partialResult.g()) {
+        this.g1k();
+        // Inline function 'kotlin.collections.forEach' call
+        var _iterator__ex2g4s_0 = partialResult.m();
+        while (_iterator__ex2g4s_0.p()) {
+          var element = _iterator__ex2g4s_0.q();
+          element.q1l();
+        }
+      }
+      tmp = asSequence(partialResult);
+    } else {
+      var tmp0_safe_receiver = this.r1n_1.f2(nestedArity(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.w1l(clause);
+      tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).x1l = function (clause) {
+    var tmp;
+    if (this.p1n_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.x1l(clause);
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = this.r1n_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s_0 = this_1.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var item_0 = _iterator__ex2g4s_0.q();
+        var tmp$ret$5 = item_0.x1l(clause);
+        destination_0.j(tmp$ret$5);
+      }
+      tmp = tmp_1.c1l(destination_0);
+    }
+    return tmp;
+  };
+  protoOf(FunctorIndexingNode).g1k = function () {
+    this.s1n_1.ko();
+  };
+  function FunctorNode(unificator) {
+    AbstractReteNode.call(this, unificator);
+  }
+  function assignHigherIndex($this, clause) {
+    var tmp = Companion_instance_7;
+    $this.z1n_1 = add($this.z1n_1, get_ONE());
+    return tmp.m1l($this.z1n_1, clause, [$this]);
+  }
+  function assignLowerIndex($this, clause) {
+    var tmp = Companion_instance_7;
+    $this.y1n_1 = subtract($this.y1n_1, get_ONE());
+    return tmp.m1l($this.y1n_1, clause, [$this]);
+  }
+  function regenerateCache_2($this) {
+    var tmp;
+    if ($this.u1n_1) {
+      var tmp_0 = Utils_instance.x1k([$this.x1n_1.f1k(), $this.w1n_1.f1k()]);
+      tmp = map(tmp_0, RootNode$regenerateCache$lambda);
+    } else {
+      var tmp_1 = Utils_instance;
+      var tmp_2 = $this.x1n_1.f1k();
+      var tmp_3 = map(tmp_2, RootNode$regenerateCache$lambda_0);
+      var tmp_4 = $this.w1n_1.f1k();
+      tmp = tmp_1.d1l([tmp_3, map(tmp_4, RootNode$regenerateCache$lambda_1)]);
+    }
+    return dequeOf_0(tmp);
+  }
+  function RootNode$regenerateCache$ref(p0) {
+    return constructCallableReference(function () {
+      var tmp0 = p0;
+      return regenerateCache_2(tmp0);
+    }, 0, 0, 36, 'regenerateCache', [p0]);
+  }
+  function RootNode$_get_directives_$lambda_9lfp1g(it) {
+    return it.c2().castToDirective();
+  }
+  function RootNode$_get_rules_$lambda_py6utr(it) {
+    return it.c2().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.j($clause);
+    };
+  }
+  function RootNode$regenerateCache$lambda(it) {
+    return it.b1k();
+  }
+  function RootNode$regenerateCache$lambda_0(it) {
+    return it.b1k();
+  }
+  function RootNode$regenerateCache$lambda_1(it) {
+    return it.b1k();
+  }
+  function RootNode(unificator, clauses, isOrdered) {
+    this.t1n_1 = unificator;
+    this.u1n_1 = isOrdered;
+    var tmp = this;
+    var tmp_0 = Companion_instance_1;
+    tmp.v1n_1 = tmp_0.io(RootNode$regenerateCache$ref(this));
+    this.w1n_1 = new RuleNode(this.t1n_1, this.u1n_1);
+    this.x1n_1 = new DirectiveIndex(this.t1n_1, this.u1n_1);
+    this.y1n_1 = new Long(0, 0);
+    this.z1n_1 = new Long(0, 0);
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = clauses.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      this.k1i(element);
+    }
+  }
+  protoOf(RootNode).x1h = function () {
+    return this.t1n_1;
+  };
+  protoOf(RootNode).f1j = function () {
+    return this.u1n_1;
+  };
+  protoOf(RootNode).s = function () {
+    return this.x1n_1.s() + this.w1n_1.s() | 0;
+  };
+  protoOf(RootNode).c1i = function () {
+    return this.x1n_1.c1i() && this.w1n_1.c1i();
+  };
+  protoOf(RootNode).h1i = function () {
+    return asSequence(this.v1n_1.c2());
+  };
+  protoOf(RootNode).a1i = function () {
+    var tmp = this.x1n_1.f1k();
+    return map(tmp, RootNode$_get_directives_$lambda_9lfp1g);
+  };
+  protoOf(RootNode).b1i = function () {
+    var tmp = this.w1n_1.f1k();
+    return map(tmp, RootNode$_get_rules_$lambda_py6utr);
+  };
+  protoOf(RootNode).f1i = function (clause) {
+    var tmp;
+    if (clause.qt()) {
+      tmp = this.x1n_1.f1i(clause);
+    } else {
+      tmp = this.w1n_1.f1i(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).n1i = function (clause) {
+    var tmp;
+    if (clause.qt()) {
+      tmp = this.x1n_1.n1i(clause);
+    } else {
+      tmp = this.w1n_1.n1i(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).p1i = function (clause) {
+    var tmp;
+    if (clause.qt()) {
+      tmp = this.x1n_1.p1i(clause);
+    } else {
+      tmp = this.w1n_1.p1i(clause);
+    }
+    return tmp;
+  };
+  protoOf(RootNode).s1i = function () {
+    return new RootNode(this.t1n_1, asIterable(this.h1i()), this.u1n_1);
+  };
+  protoOf(RootNode).j1j = function (clause) {
+    var indexed = assignLowerIndex(this, clause);
+    if (this.u1n_1) {
+      this.v1n_1.lo(RootNode$assertA$lambda(clause));
+      if (clause.qt()) {
+        this.x1n_1.d1k(indexed);
+      } else {
+        this.w1n_1.d1k(indexed);
+      }
+    } else {
+      throw UnsupportedOperationException_init_$Create$('An unordered ReteTree cannot perform the assertA operation.');
+    }
+  };
+  protoOf(RootNode).k1i = function (clause) {
+    var indexed = assignHigherIndex(this, clause);
+    this.v1n_1.lo(RootNode$assertZ$lambda(clause));
+    if (clause.qt()) {
+      this.x1n_1.e1k(indexed);
+    } else {
+      this.w1n_1.e1k(indexed);
+    }
+  };
+  protoOf(RootNode).f1k = function () {
+    return asSequence(this.v1n_1.c2());
+  };
+  protoOf(RootNode).g1k = function () {
+    this.v1n_1.ko();
+  };
+  function nestedFunctor_1($this, $receiver) {
+    return Utils_instance.v1k(ensureNotNull($receiver.nv()), 0);
+  }
+  function nestedFunctor_2($this, $receiver) {
+    return nestedFunctor_1($this, $receiver.b1k());
+  }
+  function regenerateCache_3($this) {
+    var tmp;
+    if ($this.b1o_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.c1o_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.f1k();
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.c1o_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s_0 = this_1.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var item_0 = _iterator__ex2g4s_0.q();
+        var tmp$ret$5 = item_0.f1k();
+        destination_0.j(tmp$ret$5);
+      }
+      tmp = tmp_1.c1l(destination_0);
+    }
+    return dequeOf_0(tmp);
+  }
+  function RuleNode$regenerateCache$ref(p0) {
+    return constructCallableReference(function () {
+      var tmp0 = p0;
+      return regenerateCache_3(tmp0);
+    }, 0, 0, 37, 'regenerateCache', [p0]);
+  }
+  function RuleNode$_get_size_$lambda_xjenvf(it) {
+    return it.s();
+  }
+  function RuleNode(unificator, ordered) {
+    this.a1o_1 = unificator;
+    this.b1o_1 = ordered;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.c1o_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.d1o_1 = tmp_1.io(RuleNode$regenerateCache$ref(this));
+  }
+  protoOf(RuleNode).f1i = function (clause) {
+    var tmp0_safe_receiver = this.c1o_1.f2(nestedFunctor_1(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.f1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).d1k = function (clause) {
+    // Inline function 'kotlin.let' call
+    var it = nestedFunctor_2(this, clause);
+    if (this.b1o_1) {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = this.c1o_1;
+      var value = this_0.f2(it);
+      var tmp;
+      if (value == null) {
+        var answer = new TopLevelFunctorReteNode(this.a1o_1, this.b1o_1, 0);
+        this_0.p4(it, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      tmp.d1k(clause.k1l(this));
+    } else {
+      this.e1k(clause);
+    }
+  };
+  protoOf(RuleNode).e1k = function (clause) {
+    // Inline function 'kotlin.let' call
+    var it = nestedFunctor_2(this, clause);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = this.c1o_1;
+    var value = this_0.f2(it);
+    var tmp;
+    if (value == null) {
+      var answer = new TopLevelFunctorReteNode(this.a1o_1, this.b1o_1, 0);
+      this_0.p4(it, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    tmp.e1k(clause.k1l(this));
+  };
+  protoOf(RuleNode).n1i = function (clause) {
+    var tmp0_safe_receiver = this.c1o_1.f2(nestedFunctor_1(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.n1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).s = function () {
+    var tmp = asSequence(this.c1o_1.h2());
+    return sum(map(tmp, RuleNode$_get_size_$lambda_xjenvf));
+  };
+  protoOf(RuleNode).c1i = function () {
+    var tmp;
+    if (this.c1o_1.g()) {
+      tmp = true;
+    } else {
+      var tmp0 = this.c1o_1.h2();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp_0;
+        if (isInterface(tmp0, Collection)) {
+          tmp_0 = tmp0.g();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (!element.c1i()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(RuleNode).p1i = function (clause) {
+    var tmp0_safe_receiver = this.c1o_1.f2(nestedFunctor_1(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(RuleNode).f1k = function () {
+    return asSequence(this.d1o_1.c2());
+  };
+  protoOf(RuleNode).g1k = function () {
+    this.d1o_1.ko();
+  };
+  function selectArity($this, clause) {
+    return $this.h1o_1.f2(Utils_instance.u1k(ensureNotNull(clause.nv()), $this.g1o_1));
+  }
+  function chooseAssertionBranch($this, clause, op) {
+    // Inline function 'kotlin.let' call
+    var it = Utils_instance.u1k(ensureNotNull(clause.b1k().nv()), $this.g1o_1);
+    var tmp;
+    if (it === 0) {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_0 = $this.h1o_1;
+      var value = this_0.f2(it);
+      var tmp_0;
+      if (value == null) {
+        var answer = new ZeroArityReteNode($this.x1h(), $this.f1o_1);
+        this_0.p4(it, answer);
+        tmp_0 = answer;
+      } else {
+        tmp_0 = value;
+      }
+      tmp = tmp_0;
+    } else {
+      // Inline function 'kotlin.collections.getOrPut' call
+      var this_1 = $this.h1o_1;
+      var value_0 = this_1.f2(it);
+      var tmp_1;
+      if (value_0 == null) {
+        var answer_0 = new FamilyArityReteNode($this.x1h(), $this.f1o_1, $this.g1o_1);
+        this_1.p4(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.f1o_1) {
+      var tmp_0 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = $this.h1o_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var _iterator__ex2g4s = this_0.m();
+      while (_iterator__ex2g4s.p()) {
+        var item = _iterator__ex2g4s.q();
+        var tmp$ret$2 = item.f1k();
+        destination.j(tmp$ret$2);
+      }
+      tmp = tmp_0.y1k(destination);
+    } else {
+      var tmp_1 = Utils_instance;
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = $this.h1o_1.h2();
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s_0 = this_1.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var item_0 = _iterator__ex2g4s_0.q();
+        var tmp$ret$5 = item_0.f1k();
+        destination_0.j(tmp$ret$5);
+      }
+      tmp = tmp_1.c1l(destination_0);
+    }
+    return dequeOf_0(tmp);
+  }
+  function TopLevelFunctorReteNode$regenerateCache$ref(p0) {
+    return constructCallableReference(function () {
+      var tmp0 = p0;
+      return regenerateCache_4(tmp0);
+    }, 0, 0, 38, 'regenerateCache', [p0]);
+  }
+  function TopLevelFunctorReteNode$_get_size_$lambda_6i36rr(it) {
+    return it.s();
+  }
+  function TopLevelFunctorReteNode(unificator, ordered, nestingLevel) {
+    FunctorNode.call(this, unificator);
+    this.f1o_1 = ordered;
+    this.g1o_1 = nestingLevel;
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.h1o_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    var tmp_1 = Companion_instance_1;
+    tmp_0.i1o_1 = tmp_1.io(TopLevelFunctorReteNode$regenerateCache$ref(this));
+  }
+  protoOf(TopLevelFunctorReteNode).s = function () {
+    var tmp = asSequence(this.h1o_1.h2());
+    return sum(map(tmp, TopLevelFunctorReteNode$_get_size_$lambda_6i36rr));
+  };
+  protoOf(TopLevelFunctorReteNode).c1i = function () {
+    var tmp;
+    if (this.h1o_1.g()) {
+      tmp = true;
+    } else {
+      var tmp0 = this.h1o_1.h2();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp_0;
+        if (isInterface(tmp0, Collection)) {
+          tmp_0 = tmp0.g();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (!element.c1i()) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  };
+  protoOf(TopLevelFunctorReteNode).f1i = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.f1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).d1k = function (clause) {
+    var tmp = clause.k1l(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertA$ref());
+  };
+  protoOf(TopLevelFunctorReteNode).e1k = function (clause) {
+    var tmp = clause.k1l(this);
+    chooseAssertionBranch(this, tmp, ReteNode$assertZ$ref());
+  };
+  protoOf(TopLevelFunctorReteNode).n1i = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.n1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).p1i = function (clause) {
+    var tmp0_safe_receiver = selectArity(this, clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1i(clause);
+    return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
+  };
+  protoOf(TopLevelFunctorReteNode).f1k = function () {
+    return asSequence(this.i1o_1.c2());
+  };
+  protoOf(TopLevelFunctorReteNode).g1k = function () {
+    this.i1o_1.ko();
+  };
+  function ZeroArityReteNode$retractFirst$lambda(it) {
+    return it.b1k();
+  }
+  function ZeroArityReteNode$get$lambda(this$0, $clause) {
+    return function (it) {
+      return this$0.x1h().match(it.b1k(), $clause);
+    };
+  }
+  function ZeroArityReteNode$get$lambda_0(it) {
+    return it.b1k();
+  }
+  function ZeroArityReteNode$retractAll$lambda(it) {
+    return it.b1k();
+  }
+  function ZeroArityReteNode(unificator, ordered) {
+    ArityNode.call(this, unificator);
+    this.k1o_1 = ordered;
+    this.l1o_1 = dequeOf([]);
+  }
+  protoOf(ZeroArityReteNode).n1i = function (clause) {
+    var tmp = this.c1k(this.l1o_1, clause);
+    return buffered(take(map(tmp, ZeroArityReteNode$retractFirst$lambda), 1));
+  };
+  protoOf(ZeroArityReteNode).s = function () {
+    return this.l1o_1.s();
+  };
+  protoOf(ZeroArityReteNode).c1i = function () {
+    return this.l1o_1.g();
+  };
+  protoOf(ZeroArityReteNode).f1i = function (clause) {
+    var tmp = asSequence(this.l1o_1);
+    var tmp_0 = filter(tmp, ZeroArityReteNode$get$lambda(this, clause));
+    return map(tmp_0, ZeroArityReteNode$get$lambda_0);
+  };
+  protoOf(ZeroArityReteNode).d1k = function (clause) {
+    if (this.k1o_1) {
+      addFirst(this.l1o_1, Companion_instance_8.s1l(clause.k1l(this), this));
+    } else {
+      this.e1k(clause);
+    }
+  };
+  protoOf(ZeroArityReteNode).e1k = function (clause) {
+    this.l1o_1.j(Companion_instance_8.s1l(clause.k1l(this), this));
+  };
+  protoOf(ZeroArityReteNode).p1i = function (clause) {
+    var tmp = this.c1k(this.l1o_1, clause);
+    return buffered(map(tmp, ZeroArityReteNode$retractAll$lambda));
+  };
+  protoOf(ZeroArityReteNode).f1k = function () {
+    return asSequence(this.l1o_1);
+  };
+  protoOf(ZeroArityReteNode).g1k = function () {
+  };
+  protoOf(ZeroArityReteNode).r1l = function (indexed) {
+    this.l1o_1.e3(indexed);
+  };
+  function AbstractTheory$get$lambda(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory$get$lambda_0(it) {
+    return it.castToRule();
+  }
+  function AbstractTheory(tags) {
+    this.m1o_1 = tags;
+  }
+  protoOf(AbstractTheory).vq = function () {
+    return this.m1o_1;
+  };
+  protoOf(AbstractTheory).n1o = function () {
+    return this;
+  };
+  protoOf(AbstractTheory).toImmutableTheory = function () {
+    return this.n1o();
+  };
+  protoOf(AbstractTheory).o1o = function (clause) {
+    return plus_2.call(this, TheoryUtils_instance.t1i(clause));
+  };
+  protoOf(AbstractTheory).plus = function (clause) {
+    return this.o1o(clause);
+  };
+  protoOf(AbstractTheory).e1i = function (clause) {
+    return any(this.get(clause));
+  };
+  protoOf(AbstractTheory).contains = function (clause) {
+    return this.e1i(clause);
+  };
+  protoOf(AbstractTheory).p1o = function (head) {
+    return this.e1i(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  };
+  protoOf(AbstractTheory).containsHead = function (head) {
+    return this.p1o(head);
+  };
+  protoOf(AbstractTheory).q1o = function (indicator) {
+    return any(this.r1o(indicator));
+  };
+  protoOf(AbstractTheory).containsIndicator = function (indicator) {
+    return this.q1o(indicator);
+  };
+  protoOf(AbstractTheory).s1o = 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.s1o(head);
+  };
+  protoOf(AbstractTheory).r1o = function (indicator) {
+    // Inline function 'kotlin.require' call
+    if (!indicator.xv()) {
+      var message = 'The provided indicator is not well formed: ' + indicator.toString();
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    var tmp = Companion_instance_2;
+    var tmp_0 = Companion_getInstance_0();
+    var tmp_1 = ensureNotNull(indicator.qx());
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = numberRangeToNumber(1, ensureNotNull(indicator.rx()));
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var inductionVariable = this_0.bg_1;
+    var last = this_0.cg_1;
+    if (inductionVariable <= last)
+      do {
+        var item = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp$ret$4 = Companion_getInstance().anonymous();
+        destination.j(tmp$ret$4);
+      }
+       while (!(item === last));
+    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.r1o(indicator);
+  };
+  protoOf(AbstractTheory).t1o = function (indicator) {
+    // Inline function 'kotlin.require' call
+    if (!indicator.xv()) {
+      var message = 'The provided indicator is not well formed: ' + indicator.toString();
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return this.retractAllByHead(Companion_getInstance_0().template(ensureNotNull(indicator.qx()), ensureNotNull(indicator.rx()))).u1o();
+  };
+  protoOf(AbstractTheory).abolish = function (indicator) {
+    return this.t1o(indicator);
+  };
+  protoOf(AbstractTheory).toString = function () {
+    return '' + getKClassFromExpression(this).g9() + '{ ' + joinToString(this.h1i(), '. ') + ' }';
+  };
+  protoOf(AbstractTheory).v1o = function (asPrologText) {
+    var tmp;
+    if (asPrologText) {
+      tmp = joinToString(this.h1i(), '.\n', '', '.\n');
+    } else {
+      tmp = this.toString();
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).toStringAsProlog = function (asPrologText) {
+    return this.v1o(asPrologText);
+  };
+  protoOf(AbstractTheory).m = function () {
+    return this.h1i().m();
+  };
+  protoOf(AbstractTheory).equals = function (other) {
+    if (other == null)
+      return false;
+    if (!isInterface(other, Theory))
+      return false;
+    return this.w1o(other, true);
+  };
+  protoOf(AbstractTheory).w1o = function (other, useVarCompleteName) {
+    if (this === other)
+      return true;
+    var i = this.h1i().m();
+    var j = other.h1i().m();
+    while (i.p() && j.p()) {
+      if (!i.q().equalsUsingVarCompleteNames(j.q(), useVarCompleteName)) {
+        return false;
+      }
+    }
+    return i.p() === j.p();
+  };
+  protoOf(AbstractTheory).equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.w1o(other, useVarCompleteName);
+  };
+  protoOf(AbstractTheory).hashCode = function () {
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = getKClass(AbstractTheory).g9();
+    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 _iterator__ex2g4s = this.h1i().m();
+    while (_iterator__ex2g4s.p()) {
+      var clause = _iterator__ex2g4s.q();
+      result = imul(31, result) + clause.hashCode() | 0;
+    }
+    return result;
+  };
+  protoOf(AbstractTheory).s = function () {
+    var i = new Long(0, 0);
+    var iter = this.m();
+    while (iter.p()) {
+      iter.q();
+      var _unary__edvuaz = i;
+      i = add(_unary__edvuaz, get_ONE());
+    }
+    return i;
+  };
+  protoOf(AbstractTheory).c1i = function () {
+    return !this.x1o();
+  };
+  protoOf(AbstractTheory).x1o = function () {
+    return this.m().p();
+  };
+  protoOf(AbstractTheory).y1o = function (unificator) {
+    var tmp;
+    if (!equals(unificator, this.x1h())) {
+      tmp = this.z1o(asSequence(this.h1i()), VOID, unificator);
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).setUnificator = function (unificator) {
+    return this.y1o(unificator);
+  };
+  protoOf(AbstractTheory).a1p = function (theory) {
+    var tmp;
+    if (theory.x1o()) {
+      tmp = this.z1o(plus_0(asSequence(this.h1i()), TheoryUtils_instance.b1p(asSequence(theory.h1i()))));
+    } else {
+      tmp = this;
+    }
+    return tmp;
+  };
+  protoOf(AbstractTheory).plusTheory = function (theory) {
+    return this.a1p(theory);
+  };
+  protoOf(AbstractTheory).c1p = function (clause) {
+    return this.z1o(plus_0(TheoryUtils_instance.d1p([clause]), asSequence(this.h1i())));
+  };
+  protoOf(AbstractTheory).assertA = function (clause) {
+    return this.c1p(clause);
+  };
+  protoOf(AbstractTheory).e1p = function (clauses) {
+    return this.z1o(plus_0(TheoryUtils_instance.b1p(asSequence(clauses)), asSequence(this.h1i())));
+  };
+  protoOf(AbstractTheory).assertAIterable = function (clauses) {
+    return this.e1p(clauses);
+  };
+  protoOf(AbstractTheory).f1p = function (clauses) {
+    return this.z1o(plus_0(TheoryUtils_instance.b1p(clauses), asSequence(this.h1i())));
+  };
+  protoOf(AbstractTheory).assertASequence = function (clauses) {
+    return this.f1p(clauses);
+  };
+  protoOf(AbstractTheory).g1p = function (clause) {
+    return this.z1o(plus_0(asSequence(this.h1i()), TheoryUtils_instance.b1p(sequenceOf_0(clause))));
+  };
+  protoOf(AbstractTheory).assertZ = function (clause) {
+    return this.g1p(clause);
+  };
+  protoOf(AbstractTheory).h1p = function (clauses) {
+    return this.z1o(plus_0(asSequence(this.h1i()), asSequence(TheoryUtils_instance.e1j(clauses))));
+  };
+  protoOf(AbstractTheory).assertZIterable = function (clauses) {
+    return this.h1p(clauses);
+  };
+  protoOf(AbstractTheory).i1p = function (clauses) {
+    return this.z1o(plus_0(asSequence(this.h1i()), TheoryUtils_instance.b1p(clauses)));
+  };
+  protoOf(AbstractTheory).assertZSequence = function (clauses) {
+    return this.i1p(clauses);
+  };
+  protoOf(AbstractTheory).z1o = function (clauses, tags, unificator, $super) {
+    tags = tags === VOID ? this.vq() : tags;
+    unificator = unificator === VOID ? this.x1h() : unificator;
+    return $super === VOID ? this.j1p(clauses, tags, unificator) : $super.j1p.call(this, clauses, tags, unificator);
+  };
+  protoOf(AbstractTheory).k1p = function (clauses) {
+    return this.l1p(asIterable(clauses));
+  };
+  protoOf(AbstractTheory).retractSequence = function (clauses) {
+    return this.k1p(clauses);
+  };
+  protoOf(AbstractTheory).m1p = function () {
+    return this;
+  };
+  protoOf(AbstractTheory).clone = function () {
+    return this.m1p();
+  };
+  function Default() {
+    Default_instance = this;
+    this.o1p_1 = new IndexedTheoryFactory(Companion_getInstance_1().q1h());
+  }
+  protoOf(Default).emptyTheoryWithUnificator = function (unificator) {
+    return this.o1p_1.q1p(unificator);
+  };
+  protoOf(Default).emptyTheory = function () {
+    return this.o1p_1.emptyTheory();
+  };
+  protoOf(Default).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.o1p_1.r1p(clauses, unificator);
+  };
+  protoOf(Default).theoryOfIterable = function (clauses) {
+    return this.o1p_1.theoryOfIterable(clauses);
+  };
+  protoOf(Default).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.o1p_1.s1p(unificator, clauses);
+  };
+  protoOf(Default).theoryOf = function (clauses) {
+    return this.o1p_1.theoryOf(clauses);
+  };
+  protoOf(Default).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.o1p_1.t1p(clauses, unificator);
+  };
+  protoOf(Default).theoryOfSequence = function (clauses) {
+    return this.o1p_1.theoryOfSequence(clauses);
+  };
+  protoOf(Default).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.o1p_1.u1p(unificator);
+  };
+  protoOf(Default).emptyMutableTheory = function () {
+    return this.o1p_1.emptyMutableTheory();
+  };
+  protoOf(Default).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.o1p_1.v1p(clauses, unificator);
+  };
+  protoOf(Default).mutableTheoryOfIterable = function (clauses) {
+    return this.o1p_1.mutableTheoryOfIterable(clauses);
+  };
+  protoOf(Default).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.o1p_1.w1p(unificator, clauses);
+  };
+  protoOf(Default).mutableTheoryOf = function (clauses) {
+    return this.o1p_1.mutableTheoryOf(clauses);
+  };
+  protoOf(Default).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.o1p_1.x1p(clauses, unificator);
+  };
+  protoOf(Default).mutableTheoryOfSequence = function (clauses) {
+    return this.o1p_1.mutableTheoryOfSequence(clauses);
+  };
+  protoOf(Default).x1h = function () {
+    return this.o1p_1.p1p_1;
+  };
+  var Default_instance;
+  function Default_getInstance() {
+    if (Default_instance == null)
+      new Default();
+    return Default_instance;
+  }
+  function IndexedTheoryFactory(unificator) {
+    this.p1p_1 = unificator;
+  }
+  protoOf(IndexedTheoryFactory).x1h = function () {
+    return this.p1p_1;
+  };
+  protoOf(IndexedTheoryFactory).q1p = function (unificator) {
+    return IndexedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(IndexedTheoryFactory).emptyTheoryWithUnificator = function (unificator) {
+    return this.q1p(unificator);
+  };
+  protoOf(IndexedTheoryFactory).r1p = function (clauses, unificator) {
+    return IndexedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.r1p(clauses, unificator);
+  };
+  protoOf(IndexedTheoryFactory).s1p = function (unificator, clauses) {
+    return IndexedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(IndexedTheoryFactory).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.s1p(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).t1p = function (clauses, unificator) {
+    return IndexedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.t1p(clauses, unificator);
+  };
+  protoOf(IndexedTheoryFactory).u1p = function (unificator) {
+    return MutableIndexedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(IndexedTheoryFactory).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.u1p(unificator);
+  };
+  protoOf(IndexedTheoryFactory).v1p = function (clauses, unificator) {
+    return MutableIndexedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.v1p(clauses, unificator);
+  };
+  protoOf(IndexedTheoryFactory).w1p = function (unificator, clauses) {
+    return MutableIndexedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(IndexedTheoryFactory).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.w1p(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).x1p = function (clauses, unificator) {
+    return MutableIndexedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(IndexedTheoryFactory).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.x1p(clauses, unificator);
+  };
+  function Default_0() {
+    Default_instance_0 = this;
+    this.y1p_1 = new ListedTheoryFactory(Companion_getInstance_1().q1h());
+  }
+  protoOf(Default_0).emptyTheoryWithUnificator = function (unificator) {
+    return this.y1p_1.q1p(unificator);
+  };
+  protoOf(Default_0).emptyTheory = function () {
+    return this.y1p_1.emptyTheory();
+  };
+  protoOf(Default_0).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.y1p_1.r1p(clauses, unificator);
+  };
+  protoOf(Default_0).theoryOfIterable = function (clauses) {
+    return this.y1p_1.theoryOfIterable(clauses);
+  };
+  protoOf(Default_0).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.y1p_1.s1p(unificator, clauses);
+  };
+  protoOf(Default_0).theoryOf = function (clauses) {
+    return this.y1p_1.theoryOf(clauses);
+  };
+  protoOf(Default_0).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.y1p_1.t1p(clauses, unificator);
+  };
+  protoOf(Default_0).theoryOfSequence = function (clauses) {
+    return this.y1p_1.theoryOfSequence(clauses);
+  };
+  protoOf(Default_0).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.y1p_1.u1p(unificator);
+  };
+  protoOf(Default_0).emptyMutableTheory = function () {
+    return this.y1p_1.emptyMutableTheory();
+  };
+  protoOf(Default_0).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.y1p_1.v1p(clauses, unificator);
+  };
+  protoOf(Default_0).mutableTheoryOfIterable = function (clauses) {
+    return this.y1p_1.mutableTheoryOfIterable(clauses);
+  };
+  protoOf(Default_0).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.y1p_1.w1p(unificator, clauses);
+  };
+  protoOf(Default_0).mutableTheoryOf = function (clauses) {
+    return this.y1p_1.mutableTheoryOf(clauses);
+  };
+  protoOf(Default_0).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.y1p_1.x1p(clauses, unificator);
+  };
+  protoOf(Default_0).mutableTheoryOfSequence = function (clauses) {
+    return this.y1p_1.mutableTheoryOfSequence(clauses);
+  };
+  protoOf(Default_0).x1h = function () {
+    return this.y1p_1.z1p_1;
+  };
+  var Default_instance_0;
+  function Default_getInstance_0() {
+    if (Default_instance_0 == null)
+      new Default_0();
+    return Default_instance_0;
+  }
+  function ListedTheoryFactory(unificator) {
+    this.z1p_1 = unificator;
+  }
+  protoOf(ListedTheoryFactory).x1h = function () {
+    return this.z1p_1;
+  };
+  protoOf(ListedTheoryFactory).q1p = function (unificator) {
+    return ListedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(ListedTheoryFactory).emptyTheoryWithUnificator = function (unificator) {
+    return this.q1p(unificator);
+  };
+  protoOf(ListedTheoryFactory).r1p = function (clauses, unificator) {
+    return ListedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).theoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.r1p(clauses, unificator);
+  };
+  protoOf(ListedTheoryFactory).s1p = function (unificator, clauses) {
+    return ListedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(ListedTheoryFactory).theoryOfWithUnificator = function (unificator, clauses) {
+    return this.s1p(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).t1p = function (clauses, unificator) {
+    return ListedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).theoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.t1p(clauses, unificator);
+  };
+  protoOf(ListedTheoryFactory).u1p = function (unificator) {
+    return MutableListedTheory_init_$Create$(unificator, emptyList());
+  };
+  protoOf(ListedTheoryFactory).emptyMutableTheoryWithUnificator = function (unificator) {
+    return this.u1p(unificator);
+  };
+  protoOf(ListedTheoryFactory).v1p = function (clauses, unificator) {
+    return MutableListedTheory_init_$Create$(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
+    return this.v1p(clauses, unificator);
+  };
+  protoOf(ListedTheoryFactory).w1p = function (unificator, clauses) {
+    return MutableListedTheory_init_$Create$(unificator, asIterable_0(clauses));
+  };
+  protoOf(ListedTheoryFactory).mutableTheoryOfWithUnificator = function (unificator, clauses) {
+    return this.w1p(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).x1p = function (clauses, unificator) {
+    return MutableListedTheory_init_$Create$_0(unificator, clauses);
+  };
+  protoOf(ListedTheoryFactory).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
+    return this.x1p(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;
+      var tmp$ret$2 = Companion_instance.emptyWithFunction(item);
+      destination.j(tmp$ret$2);
+    }
+    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;
+      var tmp$ret$2 = Companion_instance.emptyWithFunction(item);
+      destination.j(tmp$ret$2);
+    }
+    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.g1q_1 = theory;
+    this.h1q_1 = clauses;
+  }
+  protoOf(Success_0).u1o = function () {
+    return this.g1q_1;
+  };
+  protoOf(Success_0).h1i = function () {
+    return this.h1q_1;
+  };
+  protoOf(Success_0).a1j = function () {
+    return first_0(this.h1q_1);
+  };
+  protoOf(Success_0).toString = function () {
+    return 'Success(theory=' + toString(this.g1q_1) + ', clauses=' + toString(this.h1q_1) + ')';
+  };
+  protoOf(Success_0).hashCode = function () {
+    var result = hashCode(this.g1q_1);
+    result = imul(result, 31) + hashCode(this.h1q_1) | 0;
+    return result;
+  };
+  protoOf(Success_0).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Success_0))
+      return false;
+    if (!equals(this.g1q_1, other.g1q_1))
+      return false;
+    if (!equals(this.h1q_1, other.h1q_1))
+      return false;
+    return true;
+  };
+  function Failure_0(theory) {
+    RetractResult.call(this);
+    this.i1q_1 = theory;
+  }
+  protoOf(Failure_0).u1o = function () {
+    return this.i1q_1;
+  };
+  protoOf(Failure_0).h1i = function () {
+    return null;
+  };
+  protoOf(Failure_0).a1j = function () {
+    return null;
+  };
+  protoOf(Failure_0).toString = function () {
+    return 'Failure(theory=' + toString(this.i1q_1) + ')';
+  };
+  protoOf(Failure_0).hashCode = function () {
+    return hashCode(this.i1q_1);
+  };
+  protoOf(Failure_0).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Failure_0))
+      return false;
+    if (!equals(this.i1q_1, other.i1q_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().q1h());
+  };
+  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().q1h(), 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().q1h(), 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().q1h(), 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().q1h(), 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;
+      var tmp$ret$2 = Companion_instance.emptyWithFunction(item);
+      destination.j(tmp$ret$2);
+    }
+    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;
+      var tmp$ret$2 = Companion_instance.emptyWithFunction(item);
+      destination.j(tmp$ret$2);
+    }
+    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) {
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.all' call
+      var _iterator__ex2g4s = clauses.m();
+      while (_iterator__ex2g4s.p()) {
+        var element = _iterator__ex2g4s.q();
+        if (!element.xv()) {
+          tmp$ret$0 = false;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = true;
+    }
+    // Inline function 'kotlin.require' call
+    if (!tmp$ret$0) {
+      var message = "ClauseDatabase can contain only well formed clauses: these aren't " + toString(toList(filterNot(clauses, TheoryUtils$actualCheck$lambda)));
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  function TheoryUtils$actualCheck$lambda(it) {
+    return it.xv();
+  }
+  function TheoryUtils() {
+  }
+  protoOf(TheoryUtils).t1i = function (clause) {
+    // Inline function 'kotlin.also' call
+    // Inline function 'kotlin.require' call
+    if (!clause.xv()) {
+      var message = 'ClauseDatabase can contain only well formed clauses: ' + ("this isn't " + clause.toString());
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return clause;
+  };
+  protoOf(TheoryUtils).d1p = function (clauses) {
+    // Inline function 'kotlin.also' call
+    var this_0 = asSequence_0(clauses);
+    actualCheck(TheoryUtils_instance, this_0);
+    return this_0;
+  };
+  protoOf(TheoryUtils).e1j = function (clauses) {
+    // Inline function 'kotlin.also' call
+    actualCheck(TheoryUtils_instance, asSequence(clauses));
+    return clauses;
+  };
+  protoOf(TheoryUtils).b1p = function (clauses) {
+    // Inline function 'kotlin.also' call
+    actualCheck(TheoryUtils_instance, clauses);
+    return clauses;
+  };
+  var TheoryUtils_instance;
+  function TheoryUtils_getInstance() {
+    return TheoryUtils_instance;
+  }
+  function AbstractIndexedTheory$clauses$$inlined$Iterable$1(this$0) {
+    this.j1q_1 = this$0;
+  }
+  protoOf(AbstractIndexedTheory$clauses$$inlined$Iterable$1).m = function () {
+    return this.j1q_1.m1q().m();
+  };
+  function AbstractIndexedTheory(queue, tags) {
+    AbstractTheory.call(this, tags);
+    this.l1q_1 = queue;
+  }
+  protoOf(AbstractIndexedTheory).x1h = function () {
+    return this.m1q().x1h();
+  };
+  protoOf(AbstractIndexedTheory).m1q = function () {
+    return this.l1q_1;
+  };
+  protoOf(AbstractIndexedTheory).a1i = function () {
+    return this.m1q().z1h();
+  };
+  protoOf(AbstractIndexedTheory).b1i = function () {
+    return this.m1q().b1i();
+  };
+  protoOf(AbstractIndexedTheory).h1i = function () {
+    // Inline function 'kotlin.collections.Iterable' call
+    return new AbstractIndexedTheory$clauses$$inlined$Iterable$1(this);
+  };
+  protoOf(AbstractIndexedTheory).f1i = function (clause) {
+    return this.m1q().f1i(clause);
+  };
+  protoOf(AbstractIndexedTheory).get = function (clause) {
+    return this.f1i(clause);
+  };
+  protoOf(AbstractIndexedTheory).s = function () {
+    return fromInt(this.m1q().s());
+  };
+  protoOf(AbstractIndexedTheory).c1i = function () {
+    return this.m1q().isEmpty();
+  };
+  protoOf(AbstractIndexedTheory).x1o = function () {
+    return !this.c1i();
+  };
+  function AbstractListedTheory(unificator, clauses, tags) {
+    AbstractTheory.call(this, tags);
+    this.o1q_1 = clauses;
+    this.p1q_1 = unificator;
+  }
+  protoOf(AbstractListedTheory).h1i = function () {
+    return this.o1q_1;
+  };
+  protoOf(AbstractListedTheory).q1q = function (_set____db54di) {
+    this.p1q_1 = _set____db54di;
+  };
+  protoOf(AbstractListedTheory).x1h = function () {
+    return this.p1q_1;
+  };
+  protoOf(AbstractListedTheory).f1i = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = this.h1i();
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      if (this.x1h().match(element, clause)) {
+        destination.j(element);
+      }
+    }
+    return asSequence(destination);
+  };
+  protoOf(AbstractListedTheory).get = function (clause) {
+    return this.f1i(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.e1j(clauses);
+    return $this;
+  }
+  function IndexedTheory_init_$Create$(unificator, clauses, tags) {
+    return IndexedTheory_init_$Init$(unificator, clauses, tags, objectCreate(protoOf(IndexedTheory)));
+  }
+  function IndexedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    IndexedTheory_init_$Init$(unificator, asIterable(clauses), tags, $this);
+    return $this;
+  }
+  function IndexedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return IndexedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(IndexedTheory)));
+  }
+  function _get_hashCodeCache__ny3r0q_0($this) {
+    var tmp0 = $this.t1q_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('hashCodeCache', 1, tmp, IndexedTheory$_get_hashCodeCache_$ref_4wtmhh(), null);
+    return tmp0.c2();
+  }
+  function _get_sizeCache__6eswog($this) {
+    var tmp0 = $this.u1q_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('sizeCache', 1, tmp, IndexedTheory$_get_sizeCache_$ref_fqi1u9(), null);
+    return tmp0.c2();
+  }
+  function IndexedTheory$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractIndexedTheory).hashCode.call(this$0);
+    };
+  }
+  function IndexedTheory$_get_hashCodeCache_$ref_4wtmhh() {
+    return constructCallableReference(function (p0) {
+      return _get_hashCodeCache__ny3r0q_0(p0);
+    }, 1, 0, 39);
+  }
+  function IndexedTheory$sizeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractIndexedTheory).s.call(this$0);
+    };
+  }
+  function IndexedTheory$_get_sizeCache_$ref_fqi1u9() {
+    return constructCallableReference(function (p0) {
+      return _get_sizeCache__6eswog(p0);
+    }, 1, 0, 40);
+  }
+  function IndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    var tmp = this;
+    tmp.t1q_1 = lazy(IndexedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.u1q_1 = lazy(IndexedTheory$sizeCache$delegate$lambda(this));
+  }
+  protoOf(IndexedTheory).j1p = function (clauses, tags, unificator) {
+    return IndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(IndexedTheory).d1q = function (clause) {
+    var newTheory = Companion_instance_4.ofIterable(this.x1h(), this.h1i());
+    var retracted = newTheory.retrieveFirst(clause);
+    return retracted.b1j() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.z1i(), this.vq()), ensureNotNull(retracted.h1i()));
+  };
+  protoOf(IndexedTheory).retract = function (clause) {
+    return this.d1q(clause);
+  };
+  protoOf(IndexedTheory).a1p = function (theory) {
+    return this.c1i() ? theory.toImmutableTheory() : theory.c1i() ? this : protoOf(AbstractIndexedTheory).a1p.call(this, theory);
+  };
+  protoOf(IndexedTheory).plusTheory = function (theory) {
+    return this.a1p(theory);
+  };
+  protoOf(IndexedTheory).a1q = function () {
+    return Companion_instance_9.indexedOfIterable(this.x1h(), this);
+  };
+  protoOf(IndexedTheory).toMutableTheory = function () {
+    return this.a1q();
+  };
+  protoOf(IndexedTheory).l1p = function (clauses) {
+    var newTheory = Companion_instance_5.ofIterable(this.x1h(), this.h1i());
+    var removed = dequeOf([]);
+    var _iterator__ex2g4s = clauses.m();
+    while (_iterator__ex2g4s.p()) {
+      var clause = _iterator__ex2g4s.q();
+      var result = newTheory.w1i(clause);
+      if (result.lz()) {
+        removed.y(ensureNotNull(result.h1i()));
+      }
+    }
+    var tmp;
+    if (removed.g()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(new IndexedTheory(newTheory, this.vq()), removed);
+    }
+    return tmp;
+  };
+  protoOf(IndexedTheory).retractIterable = function (clauses) {
+    return this.l1p(clauses);
+  };
+  protoOf(IndexedTheory).p1i = function (clause) {
+    var newTheory = Companion_instance_4.ofIterable(this.x1h(), this.h1i());
+    var retracted = newTheory.o1i(clause);
+    return retracted.b1j() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.z1i(), this.vq()), ensureNotNull(retracted.h1i()));
+  };
+  protoOf(IndexedTheory).retractAll = function (clause) {
+    return this.p1i(clause);
+  };
+  protoOf(IndexedTheory).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_0(this);
+  };
+  protoOf(IndexedTheory).s = function () {
+    return _get_sizeCache__6eswog(this);
+  };
+  protoOf(IndexedTheory).jz = function (tags) {
+    var tmp;
+    if (tags === this.vq()) {
+      tmp = this;
+    } else {
+      tmp = new IndexedTheory(this.m1q(), tags);
+    }
+    return tmp;
+  };
+  protoOf(IndexedTheory).resetTags = function (tags) {
+    return this.jz(tags);
+  };
+  function ListedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    ListedTheory.call($this, unificator, toList_0(clauses), tags);
+    TheoryUtils_instance.e1j(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.b1p(clauses);
+    return $this;
+  }
+  function ListedTheory_init_$Create$_0(unificator, clauses, tags) {
+    return ListedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(ListedTheory)));
+  }
+  function _get_hashCodeCache__ny3r0q_1($this) {
+    var tmp0 = $this.y1q_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('hashCodeCache', 1, tmp, ListedTheory$_get_hashCodeCache_$ref_jbnoxj(), null);
+    return tmp0.c2();
+  }
+  function _get_sizeCache__6eswog_0($this) {
+    var tmp0 = $this.z1q_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('sizeCache', 1, tmp, ListedTheory$_get_sizeCache_$ref_3h5dr1(), null);
+    return tmp0.c2();
+  }
+  function ListedTheory$hashCodeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractListedTheory).hashCode.call(this$0);
+    };
+  }
+  function ListedTheory$_get_hashCodeCache_$ref_jbnoxj() {
+    return constructCallableReference(function (p0) {
+      return _get_hashCodeCache__ny3r0q_1(p0);
+    }, 1, 0, 41);
+  }
+  function ListedTheory$sizeCache$delegate$lambda(this$0) {
+    return function () {
+      return protoOf(AbstractListedTheory).s.call(this$0);
+    };
+  }
+  function ListedTheory$_get_sizeCache_$ref_3h5dr1() {
+    return constructCallableReference(function (p0) {
+      return _get_sizeCache__6eswog_0(p0);
+    }, 1, 0, 42);
+  }
+  function ListedTheory(unificator, clauses, tags) {
+    AbstractListedTheory.call(this, unificator, clauses, tags);
+    var tmp = this;
+    tmp.y1q_1 = lazy(ListedTheory$hashCodeCache$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.z1q_1 = lazy(ListedTheory$sizeCache$delegate$lambda(this));
+  }
+  protoOf(ListedTheory).j1p = function (clauses, tags, unificator) {
+    return ListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(ListedTheory).d1q = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = this.h1i();
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      if (this.x1h().match(element, clause)) {
+        destination.j(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
+      var tmp0_0 = this.h1i();
+      // Inline function 'kotlin.collections.filterTo' call
+      var destination_0 = ArrayList_init_$Create$_0();
+      var _iterator__ex2g4s_0 = tmp0_0.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var element_0 = _iterator__ex2g4s_0.q();
+        if (!element_0.equals(toBeActuallyRetracted)) {
+          destination_0.j(element_0);
+        }
+      }
+      var newTheory = destination_0;
+      tmp = new Success_0(new ListedTheory(this.x1h(), newTheory, this.vq()), listOf_0(toBeActuallyRetracted));
+    }
+    return tmp;
+  };
+  protoOf(ListedTheory).retract = function (clause) {
+    return this.d1q(clause);
+  };
+  protoOf(ListedTheory).a1q = function () {
+    return Companion_instance_9.listedOfIterable(this.x1h(), this);
+  };
+  protoOf(ListedTheory).toMutableTheory = function () {
+    return this.a1q();
+  };
+  protoOf(ListedTheory).l1p = function (clauses) {
+    var residual = dequeOf_1(this.h1i());
+    var removed = dequeOf([]);
+    var i = residual.m();
+    while (i.p()) {
+      var current = i.q();
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.any' call
+        var tmp;
+        if (isInterface(clauses, Collection)) {
+          tmp = clauses.g();
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+        var _iterator__ex2g4s = clauses.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (this.x1h().match(element, current)) {
+            tmp$ret$0 = true;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = false;
+      }
+      if (tmp$ret$0) {
+        i.g3();
+        removed.j(current);
+      }
+    }
+    var tmp_0;
+    if (removed.g()) {
+      tmp_0 = new Failure_0(this);
+    } else {
+      tmp_0 = new Success_0(new ListedTheory(this.x1h(), residual, this.vq()), removed);
+    }
+    return tmp_0;
+  };
+  protoOf(ListedTheory).retractIterable = function (clauses) {
+    return this.l1p(clauses);
+  };
+  protoOf(ListedTheory).p1i = function (clause) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = this.h1i();
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.m();
+    while (_iterator__ex2g4s.p()) {
+      var element = _iterator__ex2g4s.q();
+      if (this.x1h().match(element, clause)) {
+        destination.j(element);
+      }
+    }
+    var retractability = destination;
+    var tmp;
+    if (none_0(retractability)) {
+      tmp = new Failure_0(this);
+    } else {
+      // Inline function 'kotlin.collections.partition' call
+      var this_0 = toList_0(this.h1i());
+      var first = ArrayList_init_$Create$_0();
+      var second = ArrayList_init_$Create$_0();
+      var _iterator__ex2g4s_0 = this_0.m();
+      while (_iterator__ex2g4s_0.p()) {
+        var element_0 = _iterator__ex2g4s_0.q();
+        if (this.x1h().match(element_0, clause)) {
+          first.j(element_0);
+        } else {
+          second.j(element_0);
+        }
+      }
+      var partitionedClauses = new Pair(first, second);
+      var newTheory = partitionedClauses.second;
+      var toBeActuallyRetracted = partitionedClauses.first;
+      tmp = new Success_0(new ListedTheory(this.x1h(), newTheory, this.vq()), toBeActuallyRetracted);
+    }
+    return tmp;
+  };
+  protoOf(ListedTheory).retractAll = function (clause) {
+    return this.p1i(clause);
+  };
+  protoOf(ListedTheory).hashCode = function () {
+    return _get_hashCodeCache__ny3r0q_1(this);
+  };
+  protoOf(ListedTheory).s = function () {
+    return _get_sizeCache__6eswog_0(this);
+  };
+  protoOf(ListedTheory).jz = function (tags) {
+    return tags === this.vq() ? this : new ListedTheory(this.x1h(), this.h1i(), tags);
+  };
+  protoOf(ListedTheory).resetTags = function (tags) {
+    return this.jz(tags);
+  };
+  protoOf(ListedTheory).a1p = function (theory) {
+    return this.c1i() ? theory.toImmutableTheory() : theory.c1i() ? this : protoOf(AbstractListedTheory).a1p.call(this, theory);
+  };
+  protoOf(ListedTheory).plusTheory = function (theory) {
+    return this.a1p(theory);
+  };
+  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.e1j(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, $receiver) {
+    return $receiver.lz() ? new Success_0($this, ensureNotNull($receiver.h1i())) : new Failure_0($this);
+  }
+  function MutableIndexedTheory$retract$lambda(this$0) {
+    return function (it) {
+      return this$0.c1r_1.m1i(it);
+    };
+  }
+  function MutableIndexedTheory$retract$lambda_0(it) {
+    return it.lz();
+  }
+  function MutableIndexedTheory$retract$lambda_1(it) {
+    return asSequence(ensureNotNull(it.h1i()));
+  }
+  function MutableIndexedTheory(queue, tags) {
+    AbstractIndexedTheory.call(this, queue, tags);
+    this.c1r_1 = queue;
+  }
+  protoOf(MutableIndexedTheory).m1q = function () {
+    return this.c1r_1;
+  };
+  protoOf(MutableIndexedTheory).y1o = function (unificator) {
+    return protoOf(AbstractIndexedTheory).y1o.call(this, unificator).toMutableTheory();
+  };
+  protoOf(MutableIndexedTheory).setUnificator = function (unificator) {
+    return this.y1o(unificator);
+  };
+  protoOf(MutableIndexedTheory).a1q = function () {
+    return toMutableTheory.call(this);
+  };
+  protoOf(MutableIndexedTheory).toMutableTheory = function () {
+    return this.a1q();
+  };
+  protoOf(MutableIndexedTheory).h1i = function () {
+    return toList_0(this.c1r_1);
+  };
+  protoOf(MutableIndexedTheory).m = function () {
+    return this.c1r_1.m();
+  };
+  protoOf(MutableIndexedTheory).j1p = function (clauses, tags, unificator) {
+    return MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(MutableIndexedTheory).d1q = function (clause) {
+    return toRetractResult(this, this.c1r_1.m1i(clause));
+  };
+  protoOf(MutableIndexedTheory).retract = function (clause) {
+    return this.d1q(clause);
+  };
+  protoOf(MutableIndexedTheory).l1p = 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.g()) {
+      tmp_2 = new Failure_0(this);
+    } else {
+      tmp_2 = new Success_0(this, retracted);
+    }
+    return tmp_2;
+  };
+  protoOf(MutableIndexedTheory).retractIterable = function (clauses) {
+    return this.l1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).p1i = function (clause) {
+    return toRetractResult(this, this.c1r_1.o1i(clause));
+  };
+  protoOf(MutableIndexedTheory).retractAll = function (clause) {
+    return this.p1i(clause);
+  };
+  protoOf(MutableIndexedTheory).o1o = function (clause) {
+    return this.g1p(TheoryUtils_instance.t1i(clause));
+  };
+  protoOf(MutableIndexedTheory).plus = function (clause) {
+    return this.o1o(clause);
+  };
+  protoOf(MutableIndexedTheory).a1p = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.h1p(toList_0(theory));
+    } else {
+      tmp = this.h1p(theory);
+    }
+    return tmp;
+  };
+  protoOf(MutableIndexedTheory).plusTheory = function (theory) {
+    return this.a1p(theory);
+  };
+  protoOf(MutableIndexedTheory).c1p = function (clause) {
+    // Inline function 'kotlin.also' call
+    this.c1r_1.u1i(TheoryUtils_instance.t1i(clause));
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertA = function (clause) {
+    return this.c1p(clause);
+  };
+  protoOf(MutableIndexedTheory).e1p = function (clauses) {
+    // Inline function 'kotlin.also' call
+    var _iterator__ex2g4s = asReversed(toList_0(TheoryUtils_instance.e1j(clauses))).m();
+    while (_iterator__ex2g4s.p()) {
+      var clause = _iterator__ex2g4s.q();
+      this.c1r_1.u1i(clause);
+    }
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertAIterable = function (clauses) {
+    return this.e1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).f1p = function (clauses) {
+    return this.e1p(asIterable(clauses));
+  };
+  protoOf(MutableIndexedTheory).assertASequence = function (clauses) {
+    return this.f1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).g1p = function (clause) {
+    // Inline function 'kotlin.also' call
+    this.c1r_1.v1i(TheoryUtils_instance.t1i(clause));
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertZ = function (clause) {
+    return this.g1p(clause);
+  };
+  protoOf(MutableIndexedTheory).h1p = function (clauses) {
+    // Inline function 'kotlin.also' call
+    this.c1r_1.l1i(TheoryUtils_instance.e1j(clauses));
+    return this;
+  };
+  protoOf(MutableIndexedTheory).assertZIterable = function (clauses) {
+    return this.h1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).i1p = function (clauses) {
+    return this.h1p(TheoryUtils_instance.e1j(asIterable(clauses)));
+  };
+  protoOf(MutableIndexedTheory).assertZSequence = function (clauses) {
+    return this.i1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).k1p = function (clauses) {
+    return this.l1p(asIterable(clauses));
+  };
+  protoOf(MutableIndexedTheory).retractSequence = function (clauses) {
+    return this.k1p(clauses);
+  };
+  protoOf(MutableIndexedTheory).t1o = function (indicator) {
+    return protoOf(AbstractIndexedTheory).t1o.call(this, indicator).toMutableTheory();
+  };
+  protoOf(MutableIndexedTheory).abolish = function (indicator) {
+    return this.t1o(indicator);
+  };
+  protoOf(MutableIndexedTheory).n1o = function () {
+    return Companion_instance_10.indexedOfIterable(this.x1h(), this);
+  };
+  protoOf(MutableIndexedTheory).toImmutableTheory = function () {
+    return this.n1o();
+  };
+  protoOf(MutableIndexedTheory).jz = function (tags) {
+    return tags === this.vq() ? this : new MutableIndexedTheory(this.c1r_1, tags);
+  };
+  protoOf(MutableIndexedTheory).resetTags = function (tags) {
+    return this.jz(tags);
+  };
+  protoOf(MutableIndexedTheory).m1p = function () {
+    return this.z1o(asSequence(this.h1i()));
+  };
+  protoOf(MutableIndexedTheory).clone = function () {
+    return this.m1p();
+  };
+  protoOf(MutableIndexedTheory).assertAFact = function (struct) {
+    return this.b1q(struct);
+  };
+  protoOf(MutableIndexedTheory).assertZFact = function (struct) {
+    return this.c1q(struct);
+  };
+  protoOf(MutableIndexedTheory).retractByHead = function (head) {
+    return this.e1q(head);
+  };
+  protoOf(MutableIndexedTheory).retractAllByHead = function (head) {
+    return this.f1q(head);
+  };
+  function MutableListedTheory_init_$Init$(unificator, clauses, tags, $this) {
+    tags = tags === VOID ? emptyMap() : tags;
+    MutableListedTheory.call($this, unificator, toMutableList(clauses), tags);
+    TheoryUtils_instance.e1j(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.b1p(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.g1r_1 = clauses;
+  }
+  protoOf(MutableListedTheory).h1i = function () {
+    return this.g1r_1;
+  };
+  protoOf(MutableListedTheory).y1o = function (unificator) {
+    this.q1q(unificator);
+    return this;
+  };
+  protoOf(MutableListedTheory).setUnificator = function (unificator) {
+    return this.y1o(unificator);
+  };
+  protoOf(MutableListedTheory).a1q = function () {
+    return toMutableTheory.call(this);
+  };
+  protoOf(MutableListedTheory).toMutableTheory = function () {
+    return this.a1q();
+  };
+  protoOf(MutableListedTheory).j1p = function (clauses, tags, unificator) {
+    return MutableListedTheory_init_$Create$_0(unificator, clauses, tags);
+  };
+  protoOf(MutableListedTheory).d1q = function (clause) {
+    var i = this.g1r_1.g4();
+    while (i.p()) {
+      var c = i.q();
+      if (this.x1h().match(c, clause)) {
+        i.g3();
+        return new Success_0(this, listOf_0(c));
+      }
+    }
+    return new Failure_0(this);
+  };
+  protoOf(MutableListedTheory).retract = function (clause) {
+    return this.d1q(clause);
+  };
+  protoOf(MutableListedTheory).l1p = function (clauses) {
+    var i = this.g1r_1.g4();
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var retracted = ArrayList_init_$Create$_0();
+    while (i.p()) {
+      var c = i.q();
+      var _iterator__ex2g4s = clauses.m();
+      while (_iterator__ex2g4s.p()) {
+        var clause = _iterator__ex2g4s.q();
+        if (this.x1h().match(c, clause)) {
+          retracted.j(c);
+          i.g3();
+        }
+      }
+    }
+    var tmp;
+    if (retracted.g()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).retractIterable = function (clauses) {
+    return this.l1p(clauses);
+  };
+  protoOf(MutableListedTheory).p1i = function (clause) {
+    var i = this.g1r_1.g4();
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var retracted = ArrayList_init_$Create$_0();
+    while (i.p()) {
+      var c = i.q();
+      if (this.x1h().match(c, clause)) {
+        retracted.j(c);
+        i.g3();
+      }
+    }
+    var tmp;
+    if (retracted.g()) {
+      tmp = new Failure_0(this);
+    } else {
+      tmp = new Success_0(this, retracted);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).retractAll = function (clause) {
+    return this.p1i(clause);
+  };
+  protoOf(MutableListedTheory).o1o = function (clause) {
+    return this.g1p(clause);
+  };
+  protoOf(MutableListedTheory).plus = function (clause) {
+    return this.o1o(clause);
+  };
+  protoOf(MutableListedTheory).a1p = function (theory) {
+    var tmp;
+    if (theory === this) {
+      tmp = this.h1p(toList_0(theory));
+    } else {
+      tmp = this.h1p(theory);
+    }
+    return tmp;
+  };
+  protoOf(MutableListedTheory).plusTheory = function (theory) {
+    return this.a1p(theory);
+  };
+  protoOf(MutableListedTheory).c1p = function (clause) {
+    // Inline function 'kotlin.also' call
+    addFirst(this.g1r_1, TheoryUtils_instance.t1i(clause));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertA = function (clause) {
+    return this.c1p(clause);
+  };
+  protoOf(MutableListedTheory).e1p = function (clauses) {
+    // Inline function 'kotlin.also' call
+    addFirst_0(this.g1r_1, TheoryUtils_instance.e1j(clauses));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertAIterable = function (clauses) {
+    return this.e1p(clauses);
+  };
+  protoOf(MutableListedTheory).f1p = function (clauses) {
+    return this.e1p(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).assertASequence = function (clauses) {
+    return this.f1p(clauses);
+  };
+  protoOf(MutableListedTheory).g1p = function (clause) {
+    // Inline function 'kotlin.also' call
+    this.g1r_1.j(TheoryUtils_instance.t1i(clause));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertZ = function (clause) {
+    return this.g1p(clause);
+  };
+  protoOf(MutableListedTheory).h1p = function (clauses) {
+    // Inline function 'kotlin.also' call
+    addAll(this.g1r_1, TheoryUtils_instance.e1j(clauses));
+    return this;
+  };
+  protoOf(MutableListedTheory).assertZIterable = function (clauses) {
+    return this.h1p(clauses);
+  };
+  protoOf(MutableListedTheory).i1p = function (clauses) {
+    return this.h1p(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).assertZSequence = function (clauses) {
+    return this.i1p(clauses);
+  };
+  protoOf(MutableListedTheory).k1p = function (clauses) {
+    return this.l1p(asIterable(clauses));
+  };
+  protoOf(MutableListedTheory).retractSequence = function (clauses) {
+    return this.k1p(clauses);
+  };
+  protoOf(MutableListedTheory).t1o = function (indicator) {
+    return protoOf(AbstractListedTheory).t1o.call(this, indicator).toMutableTheory();
+  };
+  protoOf(MutableListedTheory).abolish = function (indicator) {
+    return this.t1o(indicator);
+  };
+  protoOf(MutableListedTheory).n1o = function () {
+    return Companion_instance_10.listedOfIterable(this.x1h(), this);
+  };
+  protoOf(MutableListedTheory).toImmutableTheory = function () {
+    return this.n1o();
+  };
+  protoOf(MutableListedTheory).jz = function (tags) {
+    return tags === this.vq() ? this : new MutableListedTheory(this.x1h(), this.g1r_1, tags);
+  };
+  protoOf(MutableListedTheory).resetTags = function (tags) {
+    return this.jz(tags);
+  };
+  protoOf(MutableListedTheory).m1p = function () {
+    return this.z1o(asSequence(this.g1r_1));
+  };
+  protoOf(MutableListedTheory).clone = function () {
+    return this.m1p();
+  };
+  protoOf(MutableListedTheory).assertAFact = function (struct) {
+    return this.b1q(struct);
+  };
+  protoOf(MutableListedTheory).assertZFact = function (struct) {
+    return this.c1q(struct);
+  };
+  protoOf(MutableListedTheory).retractByHead = function (head) {
+    return this.e1q(head);
+  };
+  protoOf(MutableListedTheory).retractAllByHead = function (head) {
+    return this.f1q(head);
+  };
+  function takeFirstAfterSkipping(_this__u8e3s4, n) {
+    var iter = _this__u8e3s4.m();
+    // Inline function 'kotlin.repeat' call
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        iter.q();
+      }
+       while (inductionVariable < n);
+    return iter.q();
+  }
+  //region block: post-declaration
+  defineProp(protoOf(RetrieveResult), 'collection', function () {
+    return this.z1i();
+  });
+  defineProp(protoOf(RetrieveResult), 'clauses', function () {
+    return this.h1i();
+  });
+  defineProp(protoOf(RetrieveResult), 'firstClause', function () {
+    return this.a1j();
+  });
+  protoOf(MutableReteClauseQueue).f1i = get;
+  protoOf(ReteClauseQueue).f1i = get;
+  protoOf(IndexedClause$Companion$wrap$1).b1k = get_innerClause;
+  protoOf(IndexedClause$Companion$wrap$1).k1l = plus_1;
+  protoOf(IndexedClause$Companion$wrap$1).rq = compareTo;
+  protoOf(IndexedClause$Companion$wrap$1).ac = component1;
+  protoOf(IndexedClause$Companion$wrap$1).bc = component2;
+  protoOf(SituatedIndexedClause$Companion$of$1).b1k = get_innerClause;
+  protoOf(SituatedIndexedClause$Companion$of$1).k1l = plus_1;
+  protoOf(SituatedIndexedClause$Companion$of$1).rq = compareTo;
+  protoOf(SituatedIndexedClause$Companion$of$1).ac = component1;
+  protoOf(SituatedIndexedClause$Companion$of$1).bc = component2;
+  protoOf(AbstractTheory).n1p = get_isMutable;
+  protoOf(AbstractTheory).b1i = get_rules;
+  protoOf(AbstractTheory).a1i = 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.u1o();
+  });
+  defineProp(protoOf(RetractResult), 'clauses', function () {
+    return this.h1i();
+  });
+  defineProp(protoOf(RetractResult), 'firstClause', function () {
+    return this.a1j();
+  });
+  protoOf(MutableIndexedTheory).b1q = assertAFact_0;
+  protoOf(MutableIndexedTheory).c1q = assertZFact_0;
+  protoOf(MutableIndexedTheory).e1q = retractByHead_0;
+  protoOf(MutableIndexedTheory).n1p = get_isMutable_0;
+  protoOf(MutableIndexedTheory).f1q = retractAllByHead_0;
+  protoOf(MutableListedTheory).b1q = assertAFact_0;
+  protoOf(MutableListedTheory).c1q = assertZFact_0;
+  protoOf(MutableListedTheory).e1q = retractByHead_0;
+  protoOf(MutableListedTheory).n1p = get_isMutable_0;
+  protoOf(MutableListedTheory).f1q = 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 = MutableTheory;
+  _.$_$.d = Success_0;
+  _.$_$.e = Theory;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-theory.js.map