@tuprolog/2p-full 1.3.1 → 1.4.0

package/2p-theory.js

@@ -137,13 +137,13 @@
     return this.addLast(clause);
   }
   function add_1(clause) {
-    return this.y1i(clause);
+    return this.d1l(clause);
   }
   function retrieve(clause) {
     return this.retrieveFirst(clause);
   }
   function retrieve_0(clause) {
-    return this.b1j(clause);
+    return this.g1l(clause);
   }
   initMetadataForInterface(ClauseQueue, 'ClauseQueue');
   initMetadataForCompanion(Companion_0);
@@ -162,7 +162,7 @@
     return this.e2();
   }
   function plus_1(traversed) {
-    return Companion_instance_7.c1m(this.mp(), this.q1k(), plus(this.y1l(), traversed));
+    return Companion_instance_7.h1o(this.mp(), this.v1m(), plus(this.d1o(), traversed));
   }
   initMetadataForInterface(IndexedClause, 'IndexedClause', VOID, VOID, [LongIndexed]);
   initMetadataForClass(IndexedClause$Companion$wrap$1, VOID, VOID, VOID, [IndexedClause]);
@@ -190,11 +190,11 @@
     return false;
   }
   function get_rules() {
-    var tmp = asSequence(this.w1i());
+    var tmp = asSequence(this.b1l());
     return asIterable(filterNotNull(map(tmp, Theory$_get_rules_$lambda_c39n1s)));
   }
   function get_directives() {
-    var tmp = asSequence(this.w1i());
+    var tmp = asSequence(this.b1l());
     return asIterable(filterNotNull(map(tmp, Theory$_get_directives_$lambda_zbsn17)));
   }
   function plus_2(clause) {
@@ -215,28 +215,28 @@
   initMetadataForInterface(Theory, 'Theory', VOID, VOID, [Taggable]);
   initMetadataForClass(AbstractTheory, 'AbstractTheory', VOID, VOID, [Theory]);
   function emptyTheory() {
-    return this.emptyTheoryWithUnificator(this.m1i());
+    return this.emptyTheoryWithUnificator(this.r1k());
   }
   function theoryOfIterable(clauses) {
-    return this.theoryOfIterableWithUnificator(clauses, this.m1i());
+    return this.theoryOfIterableWithUnificator(clauses, this.r1k());
   }
   function theoryOf(clauses) {
-    return this.theoryOfWithUnificator(this.m1i(), clauses.slice());
+    return this.theoryOfWithUnificator(this.r1k(), clauses.slice());
   }
   function theoryOfSequence(clauses) {
-    return this.theoryOfSequenceWithUnificator(clauses, this.m1i());
+    return this.theoryOfSequenceWithUnificator(clauses, this.r1k());
   }
   function emptyMutableTheory() {
-    return this.emptyMutableTheoryWithUnificator(this.m1i());
+    return this.emptyMutableTheoryWithUnificator(this.r1k());
   }
   function mutableTheoryOfIterable(clauses) {
-    return this.mutableTheoryOfIterableWithUnificator(clauses, this.m1i());
+    return this.mutableTheoryOfIterableWithUnificator(clauses, this.r1k());
   }
   function mutableTheoryOf(clauses) {
-    return this.mutableTheoryOfWithUnificator(this.m1i(), clauses.slice());
+    return this.mutableTheoryOfWithUnificator(this.r1k(), clauses.slice());
   }
   function mutableTheoryOfSequence(clauses) {
-    return this.mutableTheoryOfSequenceWithUnificator(clauses, this.m1i());
+    return this.mutableTheoryOfSequenceWithUnificator(clauses, this.r1k());
   }
   initMetadataForInterface(TheoryFactory, 'TheoryFactory');
   initMetadataForObject(Default, 'Default', VOID, VOID, [TheoryFactory]);
@@ -251,16 +251,16 @@
     return this;
   }
   function assertAFact_0(struct) {
-    return this.r1p(Companion_instance_3.of(struct));
+    return this.w1r(Companion_instance_3.of(struct));
   }
   function assertZFact_0(struct) {
-    return this.v1p(Companion_instance_3.of(struct));
+    return this.a1s(Companion_instance_3.of(struct));
   }
   function retractByHead_0(head) {
-    return this.s1q(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+    return this.x1s(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
   }
   function retractAllByHead_0(head) {
-    return this.e1j(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+    return this.j1l(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
   }
   initMetadataForInterface(MutableTheory, 'MutableTheory', VOID, VOID, [Theory]);
   initMetadataForClass(RetractResult, 'RetractResult');
@@ -277,39 +277,39 @@
   initMetadataForClass(MutableListedTheory, 'MutableListedTheory', VOID, AbstractListedTheory, [MutableTheory]);
   //endregion
   function AbstractClauseCollection(rete) {
-    this.l1i_1 = rete;
+    this.q1k_1 = rete;
   }
-  protoOf(AbstractClauseCollection).m1i = function () {
-    return this.l1i_1.m1i();
+  protoOf(AbstractClauseCollection).r1k = function () {
+    return this.q1k_1.r1k();
   };
   protoOf(AbstractClauseCollection).s = function () {
-    return this.l1i_1.s();
+    return this.q1k_1.s();
   };
-  protoOf(AbstractClauseCollection).o1i = function () {
-    return asIterable(this.l1i_1.p1i());
+  protoOf(AbstractClauseCollection).t1k = function () {
+    return asIterable(this.q1k_1.u1k());
   };
-  protoOf(AbstractClauseCollection).q1i = function () {
-    return asIterable(this.l1i_1.q1i());
+  protoOf(AbstractClauseCollection).v1k = function () {
+    return asIterable(this.q1k_1.v1k());
   };
   protoOf(AbstractClauseCollection).h = function () {
-    return this.l1i_1.r1i();
+    return this.q1k_1.w1k();
   };
   protoOf(AbstractClauseCollection).isEmpty = function () {
     return this.h();
   };
-  protoOf(AbstractClauseCollection).s1i = function () {
+  protoOf(AbstractClauseCollection).x1k = function () {
     return !this.h();
   };
   protoOf(AbstractClauseCollection).isNonEmpty = function () {
-    return this.s1i();
+    return this.x1k();
   };
-  protoOf(AbstractClauseCollection).t1i = function (element) {
-    return any(this.l1i_1.u1i(element));
+  protoOf(AbstractClauseCollection).y1k = function (element) {
+    return any(this.q1k_1.z1k(element));
   };
   protoOf(AbstractClauseCollection).contains = function (element) {
-    return this.t1i(element);
+    return this.y1k(element);
   };
-  protoOf(AbstractClauseCollection).v1i = function (elements) {
+  protoOf(AbstractClauseCollection).a1l = function (elements) {
     var tmp0 = asSequence(elements);
     var tmp$ret$0;
     $l$block: {
@@ -317,7 +317,7 @@
       var _iterator__ex2g4s = tmp0.n();
       while (_iterator__ex2g4s.q()) {
         var element = _iterator__ex2g4s.r();
-        if (!this.t1i(element)) {
+        if (!this.y1k(element)) {
           tmp$ret$0 = false;
           break $l$block;
         }
@@ -327,10 +327,10 @@
     return tmp$ret$0;
   };
   protoOf(AbstractClauseCollection).containsAll = function (elements) {
-    return this.v1i(elements);
+    return this.a1l(elements);
   };
   protoOf(AbstractClauseCollection).n = function () {
-    return this.l1i_1.w1i().n();
+    return this.q1k_1.b1l().n();
   };
   protoOf(AbstractClauseCollection).toString = function () {
     return '' + getKClassFromExpression(this).b9() + '(' + joinToString(this, ', ') + ')';
@@ -340,82 +340,82 @@
     AbstractMutableReteClauseCollection.call($this);
     return $this;
   }
-  protoOf(AbstractMutableReteClauseCollection).y1i = function (clause) {
-    this.l1i_1.z1i(clause);
-    return this.n1i();
+  protoOf(AbstractMutableReteClauseCollection).d1l = function (clause) {
+    this.q1k_1.e1l(clause);
+    return this.s1k();
   };
   protoOf(AbstractMutableReteClauseCollection).add = function (clause) {
-    return this.y1i(clause);
+    return this.d1l(clause);
   };
-  protoOf(AbstractMutableReteClauseCollection).a1j = function (clauses) {
+  protoOf(AbstractMutableReteClauseCollection).f1l = function (clauses) {
     // Inline function 'kotlin.collections.forEach' call
     var _iterator__ex2g4s = clauses.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      this.l1i_1.z1i(element);
+      this.q1k_1.e1l(element);
     }
-    return this.n1i();
+    return this.s1k();
   };
   protoOf(AbstractMutableReteClauseCollection).addAll = function (clauses) {
-    return this.a1j(clauses);
+    return this.f1l(clauses);
   };
-  protoOf(AbstractMutableReteClauseCollection).b1j = function (clause) {
-    var retracted = this.l1i_1.c1j(clause);
-    return none(retracted) ? new Failure(this.n1i()) : new Success(this.n1i(), toList(retracted));
+  protoOf(AbstractMutableReteClauseCollection).g1l = function (clause) {
+    var retracted = this.q1k_1.h1l(clause);
+    return none(retracted) ? new Failure(this.s1k()) : new Success(this.s1k(), toList(retracted));
   };
   protoOf(AbstractMutableReteClauseCollection).retrieve = function (clause) {
-    return this.b1j(clause);
+    return this.g1l(clause);
   };
-  protoOf(AbstractMutableReteClauseCollection).d1j = function (clause) {
-    var retracted = this.l1i_1.e1j(clause);
-    return none(retracted) ? new Failure(this.n1i()) : new Success(this.n1i(), toList(retracted));
+  protoOf(AbstractMutableReteClauseCollection).i1l = function (clause) {
+    var retracted = this.q1k_1.j1l(clause);
+    return none(retracted) ? new Failure(this.s1k()) : new Success(this.s1k(), toList(retracted));
   };
   protoOf(AbstractMutableReteClauseCollection).retrieveAll = function (clause) {
-    return this.d1j(clause);
+    return this.i1l(clause);
   };
   function AbstractMutableReteClauseCollection() {
   }
   function AbstractReteClauseCollection(rete) {
     AbstractClauseCollection.call(this, rete);
   }
-  protoOf(AbstractReteClauseCollection).y1i = function (clause) {
+  protoOf(AbstractReteClauseCollection).d1l = function (clause) {
     // Inline function 'kotlin.apply' call
-    var this_0 = this.l1i_1.h1j();
-    this_0.z1i(TheoryUtils_instance.i1j(clause));
-    return this.g1j(this_0);
+    var this_0 = this.q1k_1.m1l();
+    this_0.e1l(TheoryUtils_instance.n1l(clause));
+    return this.l1l(this_0);
   };
   protoOf(AbstractReteClauseCollection).add = function (clause) {
-    return this.y1i(clause);
+    return this.d1l(clause);
   };
-  protoOf(AbstractReteClauseCollection).a1j = function (clauses) {
+  protoOf(AbstractReteClauseCollection).f1l = function (clauses) {
     // Inline function 'kotlin.apply' call
-    var this_0 = this.l1i_1.h1j();
+    var this_0 = this.q1k_1.m1l();
     // Inline function 'kotlin.collections.forEach' call
     var _iterator__ex2g4s = clauses.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      this_0.z1i(TheoryUtils_instance.i1j(element));
+      this_0.e1l(TheoryUtils_instance.n1l(element));
     }
-    return this.g1j(this_0);
+    return this.l1l(this_0);
   };
   protoOf(AbstractReteClauseCollection).addAll = function (clauses) {
-    return this.a1j(clauses);
+    return this.f1l(clauses);
   };
-  protoOf(AbstractReteClauseCollection).b1j = function (clause) {
-    var newTheory = this.l1i_1.h1j();
-    var retracted = newTheory.c1j(clause);
-    return none(retracted) ? new Failure(this.n1i()) : new Success(this.g1j(newTheory), toList(retracted));
+  protoOf(AbstractReteClauseCollection).g1l = function (clause) {
+    var newTheory = this.q1k_1.m1l();
+    var retracted = newTheory.h1l(clause);
+    return none(retracted) ? new Failure(this.s1k()) : new Success(this.l1l(newTheory), toList(retracted));
   };
   protoOf(AbstractReteClauseCollection).retrieve = function (clause) {
-    return this.b1j(clause);
+    return this.g1l(clause);
   };
-  protoOf(AbstractReteClauseCollection).d1j = function (clause) {
-    var newTheory = this.l1i_1.h1j();
-    var retracted = newTheory.e1j(clause);
-    return none(retracted) ? new Failure(this.n1i()) : new Success(this.g1j(newTheory), toList(retracted));
+  protoOf(AbstractReteClauseCollection).i1l = function (clause) {
+    var newTheory = this.q1k_1.m1l();
+    var retracted = newTheory.j1l(clause);
+    return none(retracted) ? new Failure(this.s1k()) : new Success(this.l1l(newTheory), toList(retracted));
   };
   protoOf(AbstractReteClauseCollection).retrieveAll = function (clause) {
-    return this.d1j(clause);
+    return this.i1l(clause);
   };
   function Companion() {
   }
@@ -499,27 +499,27 @@
   }
   function Success(collection, clauses) {
     RetrieveResult.call(this);
-    this.m1j_1 = collection;
-    this.n1j_1 = clauses;
+    this.r1l_1 = collection;
+    this.s1l_1 = clauses;
   }
-  protoOf(Success).o1j = function () {
-    return this.m1j_1;
+  protoOf(Success).t1l = function () {
+    return this.r1l_1;
   };
-  protoOf(Success).w1i = function () {
-    return this.n1j_1;
+  protoOf(Success).b1l = function () {
+    return this.s1l_1;
   };
   protoOf(Success).d10 = function () {
     return true;
   };
-  protoOf(Success).p1j = function () {
-    return first(this.n1j_1);
+  protoOf(Success).u1l = function () {
+    return first(this.s1l_1);
   };
   protoOf(Success).toString = function () {
-    return 'Success(collection=' + toString(this.m1j_1) + ', clauses=' + toString(this.n1j_1) + ')';
+    return 'Success(collection=' + toString(this.r1l_1) + ', clauses=' + toString(this.s1l_1) + ')';
   };
   protoOf(Success).hashCode = function () {
-    var result = hashCode(this.m1j_1);
-    result = imul(result, 31) + hashCode(this.n1j_1) | 0;
+    var result = hashCode(this.r1l_1);
+    result = imul(result, 31) + hashCode(this.s1l_1) | 0;
     return result;
   };
   protoOf(Success).equals = function (other) {
@@ -527,40 +527,40 @@
       return true;
     if (!(other instanceof Success))
       return false;
-    if (!equals(this.m1j_1, other.m1j_1))
+    if (!equals(this.r1l_1, other.r1l_1))
       return false;
-    if (!equals(this.n1j_1, other.n1j_1))
+    if (!equals(this.s1l_1, other.s1l_1))
       return false;
     return true;
   };
   function Failure(collection) {
     RetrieveResult.call(this);
-    this.r1j_1 = collection;
+    this.w1l_1 = collection;
   }
-  protoOf(Failure).o1j = function () {
-    return this.r1j_1;
+  protoOf(Failure).t1l = function () {
+    return this.w1l_1;
   };
-  protoOf(Failure).q1j = function () {
+  protoOf(Failure).v1l = function () {
     return true;
   };
-  protoOf(Failure).w1i = function () {
+  protoOf(Failure).b1l = function () {
     return null;
   };
-  protoOf(Failure).p1j = function () {
+  protoOf(Failure).u1l = function () {
     return null;
   };
   protoOf(Failure).toString = function () {
-    return 'Failure(collection=' + toString(this.r1j_1) + ')';
+    return 'Failure(collection=' + toString(this.w1l_1) + ')';
   };
   protoOf(Failure).hashCode = function () {
-    return hashCode(this.r1j_1);
+    return hashCode(this.w1l_1);
   };
   protoOf(Failure).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Failure))
       return false;
-    if (!equals(this.r1j_1, other.r1j_1))
+    if (!equals(this.w1l_1, other.w1l_1))
       return false;
     return true;
   };
@@ -569,12 +569,12 @@
   protoOf(RetrieveResult).d10 = function () {
     return false;
   };
-  protoOf(RetrieveResult).q1j = function () {
+  protoOf(RetrieveResult).v1l = function () {
     return false;
   };
   function MutableReteClauseQueue_init_$Init$(unificator, clauses, $this) {
-    MutableReteClauseQueue.call($this, Companion_instance_6.s1j(unificator, clauses));
-    TheoryUtils_instance.t1j(clauses);
+    MutableReteClauseQueue.call($this, Companion_instance_6.x1l(unificator, clauses));
+    TheoryUtils_instance.y1l(clauses);
     return $this;
   }
   function MutableReteClauseQueue_init_$Create$(unificator, clauses) {
@@ -584,43 +584,43 @@
     AbstractMutableReteClauseCollection_init_$Init$(rete, this);
     // Inline function 'kotlin.require' call
     // Inline function 'kotlin.require' call
-    if (!rete.u1j()) {
+    if (!rete.z1l()) {
       var message = 'Failed requirement.';
       throw IllegalArgumentException_init_$Create$(toString(message));
     }
   }
-  protoOf(MutableReteClauseQueue).w1j = function (clause) {
-    return this.l1i_1.u1i(clause);
+  protoOf(MutableReteClauseQueue).b1m = function (clause) {
+    return this.q1k_1.z1k(clause);
   };
   protoOf(MutableReteClauseQueue).getFifoOrdered = function (clause) {
-    return this.w1j(clause);
+    return this.b1m(clause);
   };
-  protoOf(MutableReteClauseQueue).x1j = function (clause) {
-    return asSequence(asReversed(toList(this.w1j(clause))));
+  protoOf(MutableReteClauseQueue).c1m = function (clause) {
+    return asSequence(asReversed(toList(this.b1m(clause))));
   };
   protoOf(MutableReteClauseQueue).getLifoOrdered = function (clause) {
-    return this.x1j(clause);
+    return this.c1m(clause);
   };
-  protoOf(MutableReteClauseQueue).j1j = function (clause) {
-    this.l1i_1.y1j(clause);
+  protoOf(MutableReteClauseQueue).o1l = function (clause) {
+    this.q1k_1.d1m(clause);
     return this;
   };
   protoOf(MutableReteClauseQueue).addFirst = function (clause) {
-    return this.j1j(clause);
+    return this.o1l(clause);
   };
-  protoOf(MutableReteClauseQueue).k1j = function (clause) {
-    this.l1i_1.z1i(clause);
+  protoOf(MutableReteClauseQueue).p1l = function (clause) {
+    this.q1k_1.e1l(clause);
     return this;
   };
   protoOf(MutableReteClauseQueue).addLast = function (clause) {
-    return this.k1j(clause);
+    return this.p1l(clause);
   };
-  protoOf(MutableReteClauseQueue).l1j = function (clause) {
-    var retracted = this.l1i_1.c1j(clause);
+  protoOf(MutableReteClauseQueue).q1l = function (clause) {
+    var retracted = this.q1k_1.h1l(clause);
     return none(retracted) ? new Failure(this) : new Success(this, toList(retracted));
   };
   protoOf(MutableReteClauseQueue).retrieveFirst = function (clause) {
-    return this.l1j(clause);
+    return this.q1l(clause);
   };
   protoOf(MutableReteClauseQueue).equals = function (other) {
     var tmp;
@@ -634,19 +634,19 @@
   protoOf(MutableReteClauseQueue).hashCode = function () {
     return Companion_instance_5.computeHashCode(this);
   };
-  protoOf(MutableReteClauseQueue).n1i = function () {
+  protoOf(MutableReteClauseQueue).s1k = function () {
     return this;
   };
   function _get_hashCodeCache__ny3r0q($this) {
-    var tmp0 = $this.a1k_1;
+    var tmp0 = $this.f1m_1;
     var tmp = KProperty1;
     // Inline function 'kotlin.getValue' call
     getPropertyCallableRef('hashCodeCache', 1, tmp, ReteClauseQueue$_get_hashCodeCache_$ref_rnll9p(), null);
     return tmp0.e2();
   }
   function ReteClauseQueue_init_$Init$(unificator, clauses, $this) {
-    ReteClauseQueue.call($this, Companion_instance_6.s1j(unificator, clauses));
-    TheoryUtils_instance.t1j(clauses);
+    ReteClauseQueue.call($this, Companion_instance_6.x1l(unificator, clauses));
+    TheoryUtils_instance.y1l(clauses);
     return $this;
   }
   function ReteClauseQueue_init_$Create$(unificator, clauses) {
@@ -665,63 +665,63 @@
   function ReteClauseQueue(rete) {
     AbstractReteClauseCollection.call(this, rete);
     var tmp = this;
-    tmp.a1k_1 = lazy(ReteClauseQueue$hashCodeCache$delegate$lambda(this));
+    tmp.f1m_1 = lazy(ReteClauseQueue$hashCodeCache$delegate$lambda(this));
     // Inline function 'kotlin.require' call
     // Inline function 'kotlin.require' call
-    if (!rete.u1j()) {
+    if (!rete.z1l()) {
       var message = 'Failed requirement.';
       throw IllegalArgumentException_init_$Create$(toString(message));
     }
   }
-  protoOf(ReteClauseQueue).j1j = function (clause) {
+  protoOf(ReteClauseQueue).o1l = function (clause) {
     // Inline function 'kotlin.apply' call
-    var this_0 = this.l1i_1.h1j();
-    this_0.y1j(TheoryUtils_instance.i1j(clause));
+    var this_0 = this.q1k_1.m1l();
+    this_0.d1m(TheoryUtils_instance.n1l(clause));
     return new ReteClauseQueue(this_0);
   };
   protoOf(ReteClauseQueue).addFirst = function (clause) {
-    return this.j1j(clause);
+    return this.o1l(clause);
   };
-  protoOf(ReteClauseQueue).k1j = function (clause) {
+  protoOf(ReteClauseQueue).p1l = function (clause) {
     // Inline function 'kotlin.apply' call
-    var this_0 = this.l1i_1.h1j();
-    this_0.z1i(TheoryUtils_instance.i1j(clause));
+    var this_0 = this.q1k_1.m1l();
+    this_0.e1l(TheoryUtils_instance.n1l(clause));
     return new ReteClauseQueue(this_0);
   };
   protoOf(ReteClauseQueue).addLast = function (clause) {
-    return this.k1j(clause);
+    return this.p1l(clause);
   };
-  protoOf(ReteClauseQueue).w1j = function (clause) {
-    return this.l1i_1.u1i(clause);
+  protoOf(ReteClauseQueue).b1m = function (clause) {
+    return this.q1k_1.z1k(clause);
   };
   protoOf(ReteClauseQueue).getFifoOrdered = function (clause) {
-    return this.w1j(clause);
+    return this.b1m(clause);
   };
-  protoOf(ReteClauseQueue).x1j = function (clause) {
-    return asSequence(asReversed(toList(this.w1j(clause))));
+  protoOf(ReteClauseQueue).c1m = function (clause) {
+    return asSequence(asReversed(toList(this.b1m(clause))));
   };
   protoOf(ReteClauseQueue).getLifoOrdered = function (clause) {
-    return this.x1j(clause);
+    return this.c1m(clause);
   };
-  protoOf(ReteClauseQueue).y1i = function (clause) {
-    return this.k1j(clause);
+  protoOf(ReteClauseQueue).d1l = function (clause) {
+    return this.p1l(clause);
   };
   protoOf(ReteClauseQueue).add = function (clause) {
-    return this.y1i(clause);
+    return this.d1l(clause);
   };
-  protoOf(ReteClauseQueue).b1j = function (clause) {
-    return protoOf(AbstractReteClauseCollection).b1j.call(this, clause);
+  protoOf(ReteClauseQueue).g1l = function (clause) {
+    return protoOf(AbstractReteClauseCollection).g1l.call(this, clause);
   };
   protoOf(ReteClauseQueue).retrieve = function (clause) {
-    return this.b1j(clause);
+    return this.g1l(clause);
   };
-  protoOf(ReteClauseQueue).l1j = function (clause) {
-    return protoOf(AbstractReteClauseCollection).b1j.call(this, clause);
+  protoOf(ReteClauseQueue).q1l = function (clause) {
+    return protoOf(AbstractReteClauseCollection).g1l.call(this, clause);
   };
   protoOf(ReteClauseQueue).retrieveFirst = function (clause) {
-    return this.l1j(clause);
+    return this.q1l(clause);
   };
-  protoOf(ReteClauseQueue).g1j = function (rete) {
+  protoOf(ReteClauseQueue).l1l = function (rete) {
     return new ReteClauseQueue(rete);
   };
   protoOf(ReteClauseQueue).equals = function (other) {
@@ -742,13 +742,13 @@
   protoOf(ReteClauseQueue).hashCode = function () {
     return _get_hashCodeCache__ny3r0q(this);
   };
-  protoOf(ReteClauseQueue).n1i = function () {
+  protoOf(ReteClauseQueue).s1k = function () {
     return this;
   };
   function AbstractReteNode$removeAllLazily$slambda($source, this$0, $clause, resultContinuation) {
-    this.j1k_1 = $source;
-    this.k1k_1 = this$0;
-    this.l1k_1 = $clause;
+    this.o1m_1 = $source;
+    this.p1m_1 = this$0;
+    this.q1m_1 = $clause;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(AbstractReteNode$removeAllLazily$slambda).bq = function ($this$sequence, $completion) {
@@ -768,21 +768,21 @@
         switch (tmp) {
           case 0:
             this.c8_1 = 5;
-            this.n1k_1 = this.j1k_1.n();
+            this.s1m_1 = this.o1m_1.n();
             this.b8_1 = 1;
             continue $sm;
           case 1:
-            if (!this.n1k_1.q()) {
+            if (!this.s1m_1.q()) {
               this.b8_1 = 4;
               continue $sm;
             }
 
-            var it = this.n1k_1.r();
-            if (this.k1k_1.m1i().match(it.q1k(), this.l1k_1)) {
-              it.o1k();
-              this.n1k_1.b3();
+            var it = this.s1m_1.r();
+            if (this.p1m_1.r1k().match(this.q1m_1, it.v1m())) {
+              it.t1m();
+              this.s1m_1.b3();
               this.b8_1 = 2;
-              suspendResult = this.m1k_1.bd(it, this);
+              suspendResult = this.r1m_1.bd(it, this);
               if (suspendResult === get_COROUTINE_SUSPENDED()) {
                 return suspendResult;
               }
@@ -815,8 +815,8 @@
      while (true);
   };
   protoOf(AbstractReteNode$removeAllLazily$slambda).cq = function ($this$sequence, completion) {
-    var i = new AbstractReteNode$removeAllLazily$slambda(this.j1k_1, this.k1k_1, this.l1k_1, completion);
-    i.m1k_1 = $this$sequence;
+    var i = new AbstractReteNode$removeAllLazily$slambda(this.o1m_1, this.p1m_1, this.q1m_1, completion);
+    i.r1m_1 = $this$sequence;
     return i;
   };
   function AbstractReteNode$removeAllLazily$slambda_0($source, this$0, $clause, resultContinuation) {
@@ -826,29 +826,29 @@
     }, 1);
   }
   function AbstractReteNode(unificator) {
-    this.p1k_1 = unificator;
+    this.u1m_1 = unificator;
   }
-  protoOf(AbstractReteNode).m1i = function () {
-    return this.p1k_1;
+  protoOf(AbstractReteNode).r1k = function () {
+    return this.u1m_1;
   };
-  protoOf(AbstractReteNode).r1k = function (source, clause) {
+  protoOf(AbstractReteNode).w1m = function (source, clause) {
     return sequence(AbstractReteNode$removeAllLazily$slambda_0(source, this, clause, null));
   };
   function ReteNode$assertA$ref() {
     return constructCallableReference(function (p0, p1) {
-      p0.s1k(p1);
+      p0.x1m(p1);
       return Unit_instance;
     }, 2, 0, 30, 'assertA');
   }
   function ReteNode$assertZ$ref() {
     return constructCallableReference(function (p0, p1) {
-      p0.t1k(p1);
+      p0.y1m(p1);
       return Unit_instance;
     }, 2, 0, 31, 'assertZ');
   }
   function Companion_1() {
   }
-  protoOf(Companion_1).s1j = function (unificator, clauses) {
+  protoOf(Companion_1).x1l = function (unificator, clauses) {
     return new RootNode(unificator, clauses, true);
   };
   var Companion_instance_6;
@@ -859,17 +859,17 @@
     return sequence(Utils$firstArguments$slambda_0($receiver, null));
   }
   function Utils$firstArguments$slambda($this_firstArguments, resultContinuation) {
-    this.e1l_1 = $this_firstArguments;
+    this.j1n_1 = $this_firstArguments;
     CoroutineImpl.call(this, resultContinuation);
   }
-  protoOf(Utils$firstArguments$slambda).h1l = function ($this$sequence, $completion) {
-    var tmp = this.i1l($this$sequence, $completion);
+  protoOf(Utils$firstArguments$slambda).m1n = function ($this$sequence, $completion) {
+    var tmp = this.n1n($this$sequence, $completion);
     tmp.d8_1 = Unit_instance;
     tmp.e8_1 = null;
     return tmp.j8();
   };
   protoOf(Utils$firstArguments$slambda).a9 = function (p1, $completion) {
-    return this.h1l(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+    return this.m1n(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
   };
   protoOf(Utils$firstArguments$slambda).j8 = function () {
     var suspendResult = this.d8_1;
@@ -879,29 +879,29 @@
         switch (tmp) {
           case 0:
             this.c8_1 = 5;
-            this.g1l_1 = this.e1l_1;
+            this.l1n_1 = this.j1n_1;
             this.b8_1 = 1;
             continue $sm;
           case 1:
-            if (!this.g1l_1.du()) {
+            if (!this.l1n_1.du()) {
               this.b8_1 = 3;
               continue $sm;
             }
 
             this.b8_1 = 2;
-            suspendResult = this.f1l_1.bd(this.g1l_1, this);
+            suspendResult = this.k1n_1.bd(this.l1n_1, this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 2:
-            this.g1l_1 = this.g1l_1.castToStruct().getArgAt(0);
+            this.l1n_1 = this.l1n_1.castToStruct().getArgAt(0);
             this.b8_1 = 1;
             continue $sm;
           case 3:
             this.b8_1 = 4;
-            suspendResult = this.f1l_1.bd(this.g1l_1, this);
+            suspendResult = this.k1n_1.bd(this.l1n_1, this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -923,58 +923,58 @@
       }
      while (true);
   };
-  protoOf(Utils$firstArguments$slambda).i1l = function ($this$sequence, completion) {
-    var i = new Utils$firstArguments$slambda(this.e1l_1, completion);
-    i.f1l_1 = $this$sequence;
+  protoOf(Utils$firstArguments$slambda).n1n = function ($this$sequence, completion) {
+    var i = new Utils$firstArguments$slambda(this.j1n_1, completion);
+    i.k1n_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.h1l($this$sequence, $completion);
+      return i.m1n($this$sequence, $completion);
     }, 1);
   }
   function Utils() {
   }
-  protoOf(Utils).j1l = function (_this__u8e3s4, nestingLevel) {
+  protoOf(Utils).o1n = function (_this__u8e3s4, nestingLevel) {
     // Inline function 'kotlin.let' call
     return takeFirstAfterSkipping(firstArguments(this, _this__u8e3s4), nestingLevel).castToStruct().rt();
   };
-  protoOf(Utils).k1l = function (_this__u8e3s4, nestingLevel) {
+  protoOf(Utils).p1n = function (_this__u8e3s4, nestingLevel) {
     // Inline function 'kotlin.let' call
     return takeFirstAfterSkipping(firstArguments(this, _this__u8e3s4), nestingLevel).castToStruct().xt();
   };
-  protoOf(Utils).l1l = function (_this__u8e3s4, nestingLevel) {
+  protoOf(Utils).q1n = function (_this__u8e3s4, nestingLevel) {
     return takeFirstAfterSkipping(firstArguments(this, _this__u8e3s4), nestingLevel);
   };
-  protoOf(Utils).m1l = function (args) {
-    return this.n1l(listOf(args.slice()));
+  protoOf(Utils).r1n = function (args) {
+    return this.s1n(listOf(args.slice()));
   };
-  protoOf(Utils).o1l = function (sequence) {
-    return this.n1l(asIterable(sequence));
+  protoOf(Utils).t1n = function (sequence) {
+    return this.s1n(asIterable(sequence));
   };
-  protoOf(Utils).n1l = function (iterable) {
+  protoOf(Utils).s1n = function (iterable) {
     return mergeSequences(iterable, SituatedIndexedClause$compareTo$ref());
   };
-  protoOf(Utils).p1l = function (args) {
-    return this.q1l(sequenceOf(args.slice()));
+  protoOf(Utils).u1n = function (args) {
+    return this.v1n(sequenceOf(args.slice()));
   };
-  protoOf(Utils).q1l = function (sequence) {
+  protoOf(Utils).v1n = function (sequence) {
     return flatten(sequence);
   };
-  protoOf(Utils).r1l = function (iterable) {
-    return this.q1l(asSequence(iterable));
+  protoOf(Utils).w1n = function (iterable) {
+    return this.v1n(asSequence(iterable));
   };
-  protoOf(Utils).s1l = function (args) {
-    return this.t1l(sequenceOf(args.slice()));
+  protoOf(Utils).x1n = function (args) {
+    return this.y1n(sequenceOf(args.slice()));
   };
-  protoOf(Utils).t1l = function (sequence) {
+  protoOf(Utils).y1n = function (sequence) {
     return flatten(sequence);
   };
-  protoOf(Utils).u1l = function (iterable) {
-    return this.t1l(asSequence(iterable));
+  protoOf(Utils).z1n = function (iterable) {
+    return this.y1n(asSequence(iterable));
   };
-  protoOf(Utils).v1l = function (a, b) {
+  protoOf(Utils).a1o = function (a, b) {
     return a == null && b == null ? null : a == null ? b : b == null ? a : a.hr(b) < 0 ? a : b;
   };
   var Utils_instance;
@@ -982,24 +982,24 @@
     return Utils_instance;
   }
   function IndexedClause$Companion$wrap$1($traversed, $indexedClause) {
-    this.x1l_1 = $indexedClause;
-    this.w1l_1 = listOf($traversed.slice());
+    this.c1o_1 = $indexedClause;
+    this.b1o_1 = listOf($traversed.slice());
   }
   protoOf(IndexedClause$Companion$wrap$1).mp = function () {
-    return this.x1l_1.mp();
+    return this.c1o_1.mp();
   };
   protoOf(IndexedClause$Companion$wrap$1).e2 = function () {
-    return this.x1l_1.e2();
+    return this.c1o_1.e2();
   };
-  protoOf(IndexedClause$Companion$wrap$1).y1l = function () {
-    return this.w1l_1;
+  protoOf(IndexedClause$Companion$wrap$1).d1o = function () {
+    return this.b1o_1;
   };
-  protoOf(IndexedClause$Companion$wrap$1).o1k = function () {
+  protoOf(IndexedClause$Companion$wrap$1).t1m = function () {
     // Inline function 'kotlin.collections.forEach' call
-    var _iterator__ex2g4s = this.w1l_1.n();
+    var _iterator__ex2g4s = this.b1o_1.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      element.v1k();
+      element.a1n();
     }
   };
   protoOf(IndexedClause$Companion$wrap$1).d = function (other) {
@@ -1007,17 +1007,17 @@
   };
   function Companion_2() {
   }
-  protoOf(Companion_2).a1m = function (indexedClause, traversed) {
+  protoOf(Companion_2).f1o = function (indexedClause, traversed) {
     return new IndexedClause$Companion$wrap$1(traversed, indexedClause);
   };
-  protoOf(Companion_2).b1m = function (index, clause, traversed) {
-    return this.a1m(Companion_instance_0.gr(index, clause), traversed.slice());
+  protoOf(Companion_2).g1o = function (index, clause, traversed) {
+    return this.f1o(Companion_instance_0.gr(index, clause), traversed.slice());
   };
-  protoOf(Companion_2).c1m = function (index, clause, traversed) {
+  protoOf(Companion_2).h1o = function (index, clause, traversed) {
     var tmp = Companion_instance_0.gr(index, clause);
     // Inline function 'kotlin.collections.toTypedArray' call
     var tmp$ret$0 = copyToArray(traversed);
-    return this.a1m(tmp, tmp$ret$0.slice());
+    return this.f1o(tmp, tmp$ret$0.slice());
   };
   var Companion_instance_7;
   function Companion_getInstance_5() {
@@ -1026,24 +1026,24 @@
   function IndexedClause() {
   }
   function SituatedIndexedClause$Companion$of$1($indexed, $index) {
-    this.d1m_1 = $indexed;
-    this.e1m_1 = $index;
+    this.i1o_1 = $indexed;
+    this.j1o_1 = $index;
   }
   protoOf(SituatedIndexedClause$Companion$of$1).mp = function () {
-    return this.d1m_1.mp();
+    return this.i1o_1.mp();
   };
   protoOf(SituatedIndexedClause$Companion$of$1).e2 = function () {
-    return this.d1m_1.e2();
+    return this.i1o_1.e2();
   };
-  protoOf(SituatedIndexedClause$Companion$of$1).f1m = function () {
-    this.e1m_1.g1m(this);
-    this.o1k();
+  protoOf(SituatedIndexedClause$Companion$of$1).k1o = function () {
+    this.j1o_1.l1o(this);
+    this.t1m();
   };
-  protoOf(SituatedIndexedClause$Companion$of$1).y1l = function () {
-    return this.d1m_1.y1l();
+  protoOf(SituatedIndexedClause$Companion$of$1).d1o = function () {
+    return this.i1o_1.d1o();
   };
-  protoOf(SituatedIndexedClause$Companion$of$1).o1k = function () {
-    this.d1m_1.o1k();
+  protoOf(SituatedIndexedClause$Companion$of$1).t1m = function () {
+    this.i1o_1.t1m();
   };
   protoOf(SituatedIndexedClause$Companion$of$1).equals = function (other) {
     if (this === other)
@@ -1059,7 +1059,7 @@
   };
   function Companion_3() {
   }
-  protoOf(Companion_3).h1m = function (indexed, index) {
+  protoOf(Companion_3).m1o = function (indexed, index) {
     return new SituatedIndexedClause$Companion$of$1(indexed, index);
   };
   var Companion_instance_8;
@@ -1076,11 +1076,11 @@
   function AbstractIndexingLeaf(unificator) {
     AbstractReteNode.call(this, unificator);
   }
-  protoOf(AbstractIndexingLeaf).v1k = function () {
+  protoOf(AbstractIndexingLeaf).a1n = function () {
   };
   function extractFirst($this, clause) {
     // Inline function 'kotlin.collections.mapNotNull' call
-    var tmp0 = $this.q1m_1.j2();
+    var tmp0 = $this.v1o_1.j2();
     // Inline function 'kotlin.collections.mapNotNullTo' call
     var destination = ArrayList_init_$Create$_0();
     // Inline function 'kotlin.collections.forEach' call
@@ -1105,7 +1105,7 @@
       var _iterator__ex2g4s = index.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        if ($this.m1i().match(item.q1k(), clause)) {
+        if ($this.r1k().match(clause, item.v1m())) {
           tmp$ret$0 = index_0;
           break $l$block;
         }
@@ -1123,74 +1123,74 @@
     return tmp;
   }
   function extractGlobalSequence($this, clause) {
-    var tmp = $this.m1m(clause);
+    var tmp = $this.r1o(clause);
     return map(tmp, AtomIndex$extractGlobalSequence$lambda);
   }
   function nestedFirstArgument($this, $receiver) {
-    return Utils_instance.l1l(ensureNotNull($receiver.dw()), $this.p1m_1 + 1 | 0);
+    return Utils_instance.q1n(ensureNotNull($receiver.dw()), $this.u1o_1 + 1 | 0);
   }
   function asInnerAtom($this, $receiver) {
     return nestedFirstArgument($this, $receiver).castToAtom();
   }
   function asInnerAtom_0($this, $receiver) {
-    return nestedFirstArgument($this, $receiver.q1k()).castToAtom();
+    return nestedFirstArgument($this, $receiver.v1m()).castToAtom();
   }
   function asInnerAtom_1($this, $receiver) {
-    return nestedFirstArgument($this, $receiver.q1k()).castToAtom();
+    return nestedFirstArgument($this, $receiver.v1m()).castToAtom();
   }
   function AtomIndex$_get_size_$lambda_ygjfwe(it) {
     return it.s();
   }
   function AtomIndex$get$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function AtomIndex$get$lambda_0(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function AtomIndex$getIndexed$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function AtomIndex$retractAllIndexed$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.r1k(it, $clause);
+      return this$0.w1m(it, $clause);
     };
   }
   function AtomIndex$retractAll$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function AtomIndex$getCache$lambda(it) {
     return asSequence(it);
   }
   function AtomIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function AtomIndex$extractGlobalSequence$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function AtomIndex(unificator, ordered, nestingLevel) {
     AbstractIndexingLeaf.call(this, unificator);
-    this.o1m_1 = ordered;
-    this.p1m_1 = nestingLevel;
+    this.t1o_1 = ordered;
+    this.u1o_1 = nestingLevel;
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.q1m_1 = LinkedHashMap_init_$Create$();
+    tmp.v1o_1 = LinkedHashMap_init_$Create$();
   }
   protoOf(AtomIndex).s = function () {
-    var tmp = asSequence(this.q1m_1.j2());
+    var tmp = asSequence(this.v1o_1.j2());
     return sum(map(tmp, AtomIndex$_get_size_$lambda_ygjfwe));
   };
-  protoOf(AtomIndex).r1i = function () {
+  protoOf(AtomIndex).w1k = function () {
     var tmp;
-    if (this.q1m_1.h()) {
+    if (this.v1o_1.h()) {
       tmp = true;
     } else {
-      var tmp0 = this.q1m_1.j2();
+      var tmp0 = this.v1o_1.j2();
       var tmp$ret$0;
       $l$block_0: {
         // Inline function 'kotlin.collections.all' call
@@ -1218,10 +1218,10 @@
     }
     return tmp;
   };
-  protoOf(AtomIndex).u1i = function (clause) {
+  protoOf(AtomIndex).z1k = function (clause) {
     var tmp;
     if (nestedFirstArgument(this, clause).st()) {
-      var tmp0_safe_receiver = this.q1m_1.h2(asInnerAtom(this, clause));
+      var tmp0_safe_receiver = this.v1o_1.h2(asInnerAtom(this, clause));
       var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : asSequence(tmp0_safe_receiver);
       var tmp_0;
       if (tmp1_safe_receiver == null) {
@@ -1243,12 +1243,12 @@
     }
     return tmp;
   };
-  protoOf(AtomIndex).s1k = function (clause) {
-    if (this.o1m_1) {
+  protoOf(AtomIndex).x1m = function (clause) {
+    if (this.t1o_1) {
       // Inline function 'kotlin.let' call
       var it = asInnerAtom_1(this, clause);
       // Inline function 'kotlin.collections.getOrPut' call
-      var this_0 = this.q1m_1;
+      var this_0 = this.v1o_1;
       var value = this_0.h2(it);
       var tmp;
       if (value == null) {
@@ -1259,16 +1259,16 @@
         tmp = value;
       }
       var tmp$ret$2 = tmp;
-      addFirst(tmp$ret$2, Companion_instance_8.h1m(clause.z1l(this), this));
+      addFirst(tmp$ret$2, Companion_instance_8.m1o(clause.e1o(this), this));
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
     }
   };
-  protoOf(AtomIndex).t1k = function (clause) {
+  protoOf(AtomIndex).y1m = function (clause) {
     // Inline function 'kotlin.let' call
     var it = asInnerAtom_1(this, clause);
     // Inline function 'kotlin.collections.getOrPut' call
-    var this_0 = this.q1m_1;
+    var this_0 = this.v1o_1;
     var value = this_0.h2(it);
     var tmp;
     if (value == null) {
@@ -1278,13 +1278,13 @@
     } else {
       tmp = value;
     }
-    tmp.l(Companion_instance_8.h1m(clause.z1l(this), this));
+    tmp.l(Companion_instance_8.m1o(clause.e1o(this), this));
   };
-  protoOf(AtomIndex).j1m = function (clause) {
+  protoOf(AtomIndex).o1o = function (clause) {
     var tmp;
     if (nestedFirstArgument(this, clause).st()) {
       // Inline function 'kotlin.let' call
-      var it = this.q1m_1.h2(asInnerAtom(this, clause));
+      var it = this.v1o_1.h2(asInnerAtom(this, clause));
       var tmp_0;
       if (it == null) {
         tmp_0 = null;
@@ -1297,10 +1297,10 @@
     }
     return tmp;
   };
-  protoOf(AtomIndex).k1m = function (clause) {
+  protoOf(AtomIndex).p1o = function (clause) {
     var tmp;
     if (nestedFirstArgument(this, clause).st()) {
-      var tmp0_safe_receiver = this.q1m_1.h2(asInnerAtom(this, clause));
+      var tmp0_safe_receiver = this.v1o_1.h2(asInnerAtom(this, clause));
       var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : asSequence(tmp0_safe_receiver);
       var tmp_0;
       if (tmp1_safe_receiver == null) {
@@ -1311,36 +1311,36 @@
       var tmp2_elvis_lhs = tmp_0;
       tmp = tmp2_elvis_lhs == null ? emptySequence() : tmp2_elvis_lhs;
     } else {
-      tmp = this.m1m(clause);
+      tmp = this.r1o(clause);
     }
     return tmp;
   };
-  protoOf(AtomIndex).g1m = function (indexed) {
-    ensureNotNull(this.q1m_1.h2(asInnerAtom_0(this, indexed))).z2(indexed);
+  protoOf(AtomIndex).l1o = function (indexed) {
+    ensureNotNull(this.v1o_1.h2(asInnerAtom_0(this, indexed))).z2(indexed);
   };
-  protoOf(AtomIndex).l1m = function (clause) {
+  protoOf(AtomIndex).q1o = function (clause) {
     var tmp;
     if (nestedFirstArgument(this, clause).st()) {
-      var partialIndex = this.q1m_1.h2(asInnerAtom(this, clause));
-      tmp = partialIndex == null ? emptySequence() : this.r1k(partialIndex, clause);
+      var partialIndex = this.v1o_1.h2(asInnerAtom(this, clause));
+      tmp = partialIndex == null ? emptySequence() : this.w1m(partialIndex, clause);
     } else {
       var tmp_0 = Utils_instance;
-      var tmp_1 = asSequence(this.q1m_1.j2());
-      tmp = tmp_0.o1l(map(tmp_1, AtomIndex$retractAllIndexed$lambda(this, clause)));
+      var tmp_1 = asSequence(this.v1o_1.j2());
+      tmp = tmp_0.t1n(map(tmp_1, AtomIndex$retractAllIndexed$lambda(this, clause)));
     }
     return buffered(tmp);
   };
-  protoOf(AtomIndex).e1j = function (clause) {
-    var tmp = this.l1m(clause);
+  protoOf(AtomIndex).j1l = function (clause) {
+    var tmp = this.q1o(clause);
     return map(tmp, AtomIndex$retractAll$lambda);
   };
-  protoOf(AtomIndex).u1k = function () {
+  protoOf(AtomIndex).z1m = function () {
     var tmp = Utils_instance;
-    var tmp_0 = asSequence(this.q1m_1.j2());
-    return tmp.o1l(map(tmp_0, AtomIndex$getCache$lambda));
+    var tmp_0 = asSequence(this.v1o_1.j2());
+    return tmp.t1n(map(tmp_0, AtomIndex$getCache$lambda));
   };
-  protoOf(AtomIndex).m1m = function (clause) {
-    var tmp = this.u1k();
+  protoOf(AtomIndex).r1o = function (clause) {
+    var tmp = this.z1m();
     return filter(tmp, AtomIndex$extractGlobalIndexedSequence$lambda(this, clause));
   };
   function retractAllOrdered($this, clause) {
@@ -1348,20 +1348,20 @@
     if (isGlobal($this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = $this.u1m_1.j2();
+      var this_0 = $this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.l1m(clause);
+        var tmp$ret$2 = item.q1o(clause);
         destination.l(tmp$ret$2);
       }
-      var tmp_1 = tmp_0.n1l(destination);
+      var tmp_1 = tmp_0.s1n(destination);
       tmp = map(tmp_1, CompoundIndex$retractAllOrdered$lambda);
     } else {
-      var tmp0_safe_receiver = $this.u1m_1.h2(nestedFunctor($this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1j(clause);
+      var tmp0_safe_receiver = $this.z1o_1.h2(nestedFunctor($this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j1l(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
@@ -1371,60 +1371,60 @@
     if (isGlobal($this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = $this.u1m_1.j2();
+      var this_0 = $this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.e1j(clause);
+        var tmp$ret$2 = item.j1l(clause);
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.u1l(destination);
+      tmp = tmp_0.z1n(destination);
     } else {
-      var tmp0_safe_receiver = $this.u1m_1.h2(nestedFunctor($this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1j(clause);
+      var tmp0_safe_receiver = $this.z1o_1.h2(nestedFunctor($this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j1l(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
   }
   function nestedFunctor($this, $receiver) {
-    return Utils_instance.k1l(ensureNotNull($receiver.dw()), $this.t1m_1);
+    return Utils_instance.p1n(ensureNotNull($receiver.dw()), $this.y1o_1);
   }
   function nestedFunctor_0($this, $receiver) {
-    return Utils_instance.k1l(ensureNotNull($receiver.q1k().dw()), $this.t1m_1);
+    return Utils_instance.p1n(ensureNotNull($receiver.v1m().dw()), $this.y1o_1);
   }
   function isGlobal($this, $receiver) {
-    return Utils_instance.l1l(ensureNotNull($receiver.dw()), $this.t1m_1).tu();
+    return Utils_instance.q1n(ensureNotNull($receiver.dw()), $this.y1o_1).tu();
   }
   function regenerateCache($this) {
     var tmp;
-    if ($this.s1m_1) {
+    if ($this.x1o_1) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = $this.u1m_1.j2();
+      var this_0 = $this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.u1k();
+        var tmp$ret$2 = item.z1m();
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
       var tmp_1 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_1 = $this.u1m_1.j2();
+      var this_1 = $this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
       var _iterator__ex2g4s_0 = this_1.n();
       while (_iterator__ex2g4s_0.q()) {
         var item_0 = _iterator__ex2g4s_0.r();
-        var tmp$ret$5 = item_0.u1k();
+        var tmp$ret$5 = item_0.z1m();
         destination_0.l(tmp$ret$5);
       }
-      tmp = tmp_1.r1l(destination_0);
+      tmp = tmp_1.w1n(destination_0);
     }
     return dequeOf_0(tmp);
   }
@@ -1439,41 +1439,41 @@
   }
   function CompoundIndex$get$lambda($clause) {
     return function (it) {
-      return it.k1m($clause);
+      return it.p1o($clause);
     };
   }
   function CompoundIndex$get$lambda_0(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function CompoundIndex$get$lambda_1($clause) {
     return function (it) {
-      return it.u1i($clause);
+      return it.z1k($clause);
     };
   }
   function CompoundIndex$retractAllOrdered$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function CompoundIndex(unificator, ordered, nestingLevel) {
     AbstractReteNode.call(this, unificator);
-    this.s1m_1 = ordered;
-    this.t1m_1 = nestingLevel;
+    this.x1o_1 = ordered;
+    this.y1o_1 = nestingLevel;
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.u1m_1 = LinkedHashMap_init_$Create$();
+    tmp.z1o_1 = LinkedHashMap_init_$Create$();
     var tmp_0 = this;
     var tmp_1 = Companion_instance_1;
-    tmp_0.v1m_1 = tmp_1.yo(CompoundIndex$regenerateCache$ref(this));
+    tmp_0.a1p_1 = tmp_1.yo(CompoundIndex$regenerateCache$ref(this));
   }
   protoOf(CompoundIndex).s = function () {
-    var tmp = asSequence(this.u1m_1.j2());
+    var tmp = asSequence(this.z1o_1.j2());
     return sum(map(tmp, CompoundIndex$_get_size_$lambda_91vt0k));
   };
-  protoOf(CompoundIndex).r1i = function () {
+  protoOf(CompoundIndex).w1k = function () {
     var tmp;
-    if (this.u1m_1.h()) {
+    if (this.z1o_1.h()) {
       tmp = true;
     } else {
-      var tmp0 = this.u1m_1.j2();
+      var tmp0 = this.z1o_1.j2();
       var tmp$ret$0;
       $l$block_0: {
         // Inline function 'kotlin.collections.all' call
@@ -1490,7 +1490,7 @@
         var _iterator__ex2g4s = tmp0.n();
         while (_iterator__ex2g4s.q()) {
           var element = _iterator__ex2g4s.r();
-          if (!element.r1i()) {
+          if (!element.w1k()) {
             tmp$ret$0 = false;
             break $l$block_0;
           }
@@ -1501,91 +1501,91 @@
     }
     return tmp;
   };
-  protoOf(CompoundIndex).u1i = function (clause) {
+  protoOf(CompoundIndex).z1k = function (clause) {
     var tmp;
     if (isGlobal(this, clause)) {
       var tmp_0;
-      if (this.s1m_1) {
+      if (this.x1o_1) {
         var tmp_1 = Utils_instance;
-        var tmp_2 = asSequence(this.u1m_1.j2());
-        var tmp_3 = tmp_1.m1l([flatMap(tmp_2, CompoundIndex$get$lambda(clause))]);
+        var tmp_2 = asSequence(this.z1o_1.j2());
+        var tmp_3 = tmp_1.r1n([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.u1m_1.j2());
-        tmp_0 = tmp_4.s1l([flatMap(tmp_5, CompoundIndex$get$lambda_1(clause))]);
+        var tmp_5 = asSequence(this.z1o_1.j2());
+        tmp_0 = tmp_4.x1n([flatMap(tmp_5, CompoundIndex$get$lambda_1(clause))]);
       }
       tmp = tmp_0;
     } else {
-      var tmp0_safe_receiver = this.u1m_1.h2(nestedFunctor(this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u1i(clause);
+      var tmp0_safe_receiver = this.z1o_1.h2(nestedFunctor(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z1k(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
   };
-  protoOf(CompoundIndex).s1k = function (clause) {
+  protoOf(CompoundIndex).x1m = function (clause) {
     // Inline function 'kotlin.let' call
     var it = nestedFunctor_0(this, clause);
-    if (this.s1m_1) {
+    if (this.x1o_1) {
       // Inline function 'kotlin.collections.getOrPut' call
-      var this_0 = this.u1m_1;
+      var this_0 = this.z1o_1;
       var value = this_0.h2(it);
       var tmp;
       if (value == null) {
-        var answer = new FunctorIndexingNode(this.m1i(), this.s1m_1, this.t1m_1);
+        var answer = new FunctorIndexingNode(this.r1k(), this.x1o_1, this.y1o_1);
         this_0.k4(it, answer);
         tmp = answer;
       } else {
         tmp = value;
       }
-      tmp.s1k(clause.z1l(this));
+      tmp.x1m(clause.e1o(this));
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
     }
     return Unit_instance;
   };
-  protoOf(CompoundIndex).t1k = function (clause) {
+  protoOf(CompoundIndex).y1m = function (clause) {
     // Inline function 'kotlin.let' call
     var it = nestedFunctor_0(this, clause);
     // Inline function 'kotlin.collections.getOrPut' call
-    var this_0 = this.u1m_1;
+    var this_0 = this.z1o_1;
     var value = this_0.h2(it);
     var tmp;
     if (value == null) {
-      var answer = new FunctorIndexingNode(this.m1i(), this.s1m_1, this.t1m_1);
+      var answer = new FunctorIndexingNode(this.r1k(), this.x1o_1, this.y1o_1);
       this_0.k4(it, answer);
       tmp = answer;
     } else {
       tmp = value;
     }
-    tmp.t1k(clause.z1l(this));
+    tmp.y1m(clause.e1o(this));
     return Unit_instance;
   };
-  protoOf(CompoundIndex).e1j = function (clause) {
+  protoOf(CompoundIndex).j1l = function (clause) {
     var tmp;
-    if (this.s1m_1) {
+    if (this.x1o_1) {
       tmp = retractAllOrdered(this, clause);
     } else {
       tmp = retractAllUnordered(this, clause);
     }
     return tmp;
   };
-  protoOf(CompoundIndex).u1k = function () {
-    return asSequence(this.v1m_1.e2());
+  protoOf(CompoundIndex).z1m = function () {
+    return asSequence(this.a1p_1.e2());
   };
-  protoOf(CompoundIndex).j1m = function (clause) {
+  protoOf(CompoundIndex).o1o = function (clause) {
     var tmp;
     if (isGlobal(this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.mapNotNull' call
-      var tmp0 = this.u1m_1.j2();
+      var tmp0 = this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapNotNullTo' call
       var destination = ArrayList_init_$Create$_0();
       // Inline function 'kotlin.collections.forEach' call
       var _iterator__ex2g4s = tmp0.n();
       while (_iterator__ex2g4s.q()) {
         var element = _iterator__ex2g4s.r();
-        var tmp0_safe_receiver = element.j1m(clause);
+        var tmp0_safe_receiver = element.o1o(clause);
         if (tmp0_safe_receiver == null)
           null;
         else {
@@ -1593,128 +1593,128 @@
           destination.l(tmp0_safe_receiver);
         }
       }
-      tmp = firstOrNull(tmp_0.o1l(sequenceOf_0(asSequence(destination))));
+      tmp = firstOrNull(tmp_0.t1n(sequenceOf_0(asSequence(destination))));
     } else {
-      var tmp0_safe_receiver_0 = this.u1m_1.h2(nestedFunctor(this, clause));
-      tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.j1m(clause);
+      var tmp0_safe_receiver_0 = this.z1o_1.h2(nestedFunctor(this, clause));
+      tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.o1o(clause);
     }
     return tmp;
   };
-  protoOf(CompoundIndex).k1m = function (clause) {
+  protoOf(CompoundIndex).p1o = function (clause) {
     var tmp;
     if (isGlobal(this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.u1m_1.j2();
+      var this_0 = this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.m1m(clause);
+        var tmp$ret$2 = item.r1o(clause);
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
-      var tmp0_safe_receiver = this.u1m_1.h2(nestedFunctor(this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.k1m(clause);
+      var tmp0_safe_receiver = this.z1o_1.h2(nestedFunctor(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1o(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
   };
-  protoOf(CompoundIndex).l1m = function (clause) {
+  protoOf(CompoundIndex).q1o = function (clause) {
     var tmp;
     if (isGlobal(this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.u1m_1.j2();
+      var this_0 = this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.l1m(clause);
+        var tmp$ret$2 = item.q1o(clause);
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
-      var tmp0_safe_receiver = this.u1m_1.h2(nestedFunctor(this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.l1m(clause);
+      var tmp0_safe_receiver = this.z1o_1.h2(nestedFunctor(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.q1o(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
   };
-  protoOf(CompoundIndex).m1m = function (clause) {
+  protoOf(CompoundIndex).r1o = function (clause) {
     var tmp;
-    if (this.s1m_1) {
+    if (this.x1o_1) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.u1m_1.j2();
+      var this_0 = this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.m1m(clause);
+        var tmp$ret$2 = item.r1o(clause);
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
       var tmp_1 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_1 = this.u1m_1.j2();
+      var this_1 = this.z1o_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
       var _iterator__ex2g4s_0 = this_1.n();
       while (_iterator__ex2g4s_0.q()) {
         var item_0 = _iterator__ex2g4s_0.r();
-        var tmp$ret$5 = item_0.m1m(clause);
+        var tmp$ret$5 = item_0.r1o(clause);
         destination_0.l(tmp$ret$5);
       }
-      tmp = tmp_1.r1l(destination_0);
+      tmp = tmp_1.w1n(destination_0);
     }
     return tmp;
   };
-  protoOf(CompoundIndex).v1k = function () {
-    this.v1m_1.ap();
+  protoOf(CompoundIndex).a1n = function () {
+    this.a1p_1.ap();
   };
   function DirectiveIndex$retractFirst$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function DirectiveIndex$retractAll$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function DirectiveIndex$getCache$lambda(it) {
     var tmp = Companion_instance_8;
-    return tmp.h1m(it, new DirectiveIndex$getCache$1$1());
+    return tmp.m1o(it, new DirectiveIndex$getCache$1$1());
   }
   function DirectiveIndex$getCache$1$1() {
   }
-  protoOf(DirectiveIndex$getCache$1$1).g1m = function (indexed) {
+  protoOf(DirectiveIndex$getCache$1$1).l1o = 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.x1m_1 = ordered;
-    this.y1m_1 = dequeOf([]);
+    this.c1p_1 = ordered;
+    this.d1p_1 = dequeOf([]);
   }
   protoOf(DirectiveIndex).s = function () {
-    return this.y1m_1.s();
+    return this.d1p_1.s();
   };
-  protoOf(DirectiveIndex).r1i = function () {
-    return this.y1m_1.h();
+  protoOf(DirectiveIndex).w1k = function () {
+    return this.d1p_1.h();
   };
-  protoOf(DirectiveIndex).u1i = function (clause) {
+  protoOf(DirectiveIndex).z1k = function (clause) {
     // Inline function 'kotlin.collections.filter' call
-    var tmp0 = this.y1m_1;
+    var tmp0 = this.d1p_1;
     // Inline function 'kotlin.collections.filterTo' call
     var destination = ArrayList_init_$Create$_0();
     var _iterator__ex2g4s = tmp0.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      if (this.m1i().match(element.q1k(), clause)) {
+      if (this.r1k().match(clause, element.v1m())) {
         destination.l(element);
       }
     }
@@ -1724,38 +1724,38 @@
     var _iterator__ex2g4s_0 = destination.n();
     while (_iterator__ex2g4s_0.q()) {
       var item = _iterator__ex2g4s_0.r();
-      var tmp$ret$5 = item.q1k();
+      var tmp$ret$5 = item.v1m();
       destination_0.l(tmp$ret$5);
     }
     return asSequence(destination_0);
   };
-  protoOf(DirectiveIndex).s1k = function (clause) {
-    if (this.x1m_1) {
-      addFirst(this.y1m_1, clause.z1l(this));
+  protoOf(DirectiveIndex).x1m = function (clause) {
+    if (this.c1p_1) {
+      addFirst(this.d1p_1, clause.e1o(this));
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
     }
   };
-  protoOf(DirectiveIndex).t1k = function (clause) {
-    this.y1m_1.l(clause.z1l(this));
+  protoOf(DirectiveIndex).y1m = function (clause) {
+    this.d1p_1.l(clause.e1o(this));
   };
-  protoOf(DirectiveIndex).c1j = function (clause) {
-    var tmp = this.r1k(this.y1m_1, clause);
+  protoOf(DirectiveIndex).h1l = function (clause) {
+    var tmp = this.w1m(this.d1p_1, clause);
     return buffered(take(map(tmp, DirectiveIndex$retractFirst$lambda), 1));
   };
-  protoOf(DirectiveIndex).e1j = function (clause) {
-    var tmp = this.r1k(this.y1m_1, clause);
+  protoOf(DirectiveIndex).j1l = function (clause) {
+    var tmp = this.w1m(this.d1p_1, clause);
     return buffered(map(tmp, DirectiveIndex$retractAll$lambda));
   };
-  protoOf(DirectiveIndex).u1k = function () {
-    var tmp = asSequence(this.y1m_1);
+  protoOf(DirectiveIndex).z1m = function () {
+    var tmp = asSequence(this.d1p_1);
     return map(tmp, DirectiveIndex$getCache$lambda);
   };
-  protoOf(DirectiveIndex).v1k = function () {
+  protoOf(DirectiveIndex).a1n = function () {
   };
   function extractFirst_1($this, clause) {
     // Inline function 'kotlin.collections.mapNotNull' call
-    var tmp0 = $this.c1n_1.j2();
+    var tmp0 = $this.h1p_1.j2();
     // Inline function 'kotlin.collections.mapNotNullTo' call
     var destination = ArrayList_init_$Create$_0();
     // Inline function 'kotlin.collections.forEach' call
@@ -1780,7 +1780,7 @@
       var _iterator__ex2g4s = index.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        if ($this.m1i().match(item.q1k(), clause)) {
+        if ($this.r1k().match(clause, item.v1m())) {
           tmp$ret$0 = index_0;
           break $l$block;
         }
@@ -1798,74 +1798,74 @@
     return tmp;
   }
   function extractGlobalSequence_0($this, clause) {
-    var tmp = $this.m1m(clause);
+    var tmp = $this.r1o(clause);
     return map(tmp, NumericIndex$extractGlobalSequence$lambda);
   }
   function nestedFirstArgument_0($this, $receiver) {
-    return Utils_instance.l1l(ensureNotNull($receiver.dw()), $this.b1n_1 + 1 | 0);
+    return Utils_instance.q1n(ensureNotNull($receiver.dw()), $this.g1p_1 + 1 | 0);
   }
   function asInnerNumeric($this, $receiver) {
     return nestedFirstArgument_0($this, $receiver).castToNumeric();
   }
   function asInnerNumeric_0($this, $receiver) {
-    return nestedFirstArgument_0($this, $receiver.q1k()).castToNumeric();
+    return nestedFirstArgument_0($this, $receiver.v1m()).castToNumeric();
   }
   function asInnerNumeric_1($this, $receiver) {
-    return nestedFirstArgument_0($this, $receiver.q1k()).castToNumeric();
+    return nestedFirstArgument_0($this, $receiver.v1m()).castToNumeric();
   }
   function NumericIndex$_get_size_$lambda_exo30i(it) {
     return it.s();
   }
   function NumericIndex$get$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function NumericIndex$get$lambda_0(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function NumericIndex$getIndexed$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function NumericIndex$retractAllIndexed$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.r1k(it, $clause);
+      return this$0.w1m(it, $clause);
     };
   }
   function NumericIndex$retractAll$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function NumericIndex$getCache$lambda(it) {
     return asSequence(it);
   }
   function NumericIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function NumericIndex$extractGlobalSequence$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function NumericIndex(unificator, ordered, nestingLevel) {
     AbstractIndexingLeaf.call(this, unificator);
-    this.a1n_1 = ordered;
-    this.b1n_1 = nestingLevel;
+    this.f1p_1 = ordered;
+    this.g1p_1 = nestingLevel;
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.c1n_1 = LinkedHashMap_init_$Create$();
+    tmp.h1p_1 = LinkedHashMap_init_$Create$();
   }
   protoOf(NumericIndex).s = function () {
-    var tmp = asSequence(this.c1n_1.j2());
+    var tmp = asSequence(this.h1p_1.j2());
     return sum(map(tmp, NumericIndex$_get_size_$lambda_exo30i));
   };
-  protoOf(NumericIndex).r1i = function () {
+  protoOf(NumericIndex).w1k = function () {
     var tmp;
-    if (this.c1n_1.h()) {
+    if (this.h1p_1.h()) {
       tmp = true;
     } else {
-      var tmp0 = this.c1n_1.j2();
+      var tmp0 = this.h1p_1.j2();
       var tmp$ret$0;
       $l$block_0: {
         // Inline function 'kotlin.collections.all' call
@@ -1893,10 +1893,10 @@
     }
     return tmp;
   };
-  protoOf(NumericIndex).u1i = function (clause) {
+  protoOf(NumericIndex).z1k = function (clause) {
     var tmp;
     if (nestedFirstArgument_0(this, clause).xu()) {
-      var tmp0_safe_receiver = this.c1n_1.h2(asInnerNumeric(this, clause));
+      var tmp0_safe_receiver = this.h1p_1.h2(asInnerNumeric(this, clause));
       var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : asSequence(tmp0_safe_receiver);
       var tmp_0;
       if (tmp1_safe_receiver == null) {
@@ -1918,12 +1918,12 @@
     }
     return tmp;
   };
-  protoOf(NumericIndex).s1k = function (clause) {
-    if (this.a1n_1) {
+  protoOf(NumericIndex).x1m = function (clause) {
+    if (this.f1p_1) {
       // Inline function 'kotlin.let' call
       var it = asInnerNumeric_1(this, clause);
       // Inline function 'kotlin.collections.getOrPut' call
-      var this_0 = this.c1n_1;
+      var this_0 = this.h1p_1;
       var value = this_0.h2(it);
       var tmp;
       if (value == null) {
@@ -1934,16 +1934,16 @@
         tmp = value;
       }
       var tmp$ret$2 = tmp;
-      addFirst(tmp$ret$2, Companion_instance_8.h1m(clause.z1l(this), this));
+      addFirst(tmp$ret$2, Companion_instance_8.m1o(clause.e1o(this), this));
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
     }
   };
-  protoOf(NumericIndex).t1k = function (clause) {
+  protoOf(NumericIndex).y1m = function (clause) {
     // Inline function 'kotlin.let' call
     var it = asInnerNumeric_1(this, clause);
     // Inline function 'kotlin.collections.getOrPut' call
-    var this_0 = this.c1n_1;
+    var this_0 = this.h1p_1;
     var value = this_0.h2(it);
     var tmp;
     if (value == null) {
@@ -1953,12 +1953,12 @@
     } else {
       tmp = value;
     }
-    tmp.l(Companion_instance_8.h1m(clause.z1l(this), this));
+    tmp.l(Companion_instance_8.m1o(clause.e1o(this), this));
   };
-  protoOf(NumericIndex).j1m = function (clause) {
+  protoOf(NumericIndex).o1o = function (clause) {
     if (nestedFirstArgument_0(this, clause).xu()) {
       // Inline function 'kotlin.let' call
-      var it = this.c1n_1.h2(asInnerNumeric(this, clause));
+      var it = this.h1p_1.h2(asInnerNumeric(this, clause));
       var tmp;
       if (it == null) {
         tmp = null;
@@ -1970,10 +1970,10 @@
       return extractFirst_1(this, clause);
     }
   };
-  protoOf(NumericIndex).k1m = function (clause) {
+  protoOf(NumericIndex).p1o = function (clause) {
     var tmp;
     if (nestedFirstArgument_0(this, clause).xu()) {
-      var tmp0_safe_receiver = this.c1n_1.h2(asInnerNumeric(this, clause));
+      var tmp0_safe_receiver = this.h1p_1.h2(asInnerNumeric(this, clause));
       var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : asSequence(tmp0_safe_receiver);
       var tmp_0;
       if (tmp1_safe_receiver == null) {
@@ -1984,36 +1984,36 @@
       var tmp2_elvis_lhs = tmp_0;
       tmp = tmp2_elvis_lhs == null ? emptySequence() : tmp2_elvis_lhs;
     } else {
-      tmp = this.m1m(clause);
+      tmp = this.r1o(clause);
     }
     return tmp;
   };
-  protoOf(NumericIndex).g1m = function (indexed) {
-    ensureNotNull(this.c1n_1.h2(asInnerNumeric_0(this, indexed))).z2(indexed);
+  protoOf(NumericIndex).l1o = function (indexed) {
+    ensureNotNull(this.h1p_1.h2(asInnerNumeric_0(this, indexed))).z2(indexed);
   };
-  protoOf(NumericIndex).l1m = function (clause) {
+  protoOf(NumericIndex).q1o = function (clause) {
     var tmp;
     if (nestedFirstArgument_0(this, clause).xu()) {
-      var partialIndex = this.c1n_1.h2(asInnerNumeric(this, clause));
-      tmp = partialIndex == null ? emptySequence() : buffered(this.r1k(partialIndex, clause));
+      var partialIndex = this.h1p_1.h2(asInnerNumeric(this, clause));
+      tmp = partialIndex == null ? emptySequence() : buffered(this.w1m(partialIndex, clause));
     } else {
       var tmp_0 = Utils_instance;
-      var tmp_1 = asSequence(this.c1n_1.j2());
-      tmp = buffered(tmp_0.o1l(map(tmp_1, NumericIndex$retractAllIndexed$lambda(this, clause))));
+      var tmp_1 = asSequence(this.h1p_1.j2());
+      tmp = buffered(tmp_0.t1n(map(tmp_1, NumericIndex$retractAllIndexed$lambda(this, clause))));
     }
     return tmp;
   };
-  protoOf(NumericIndex).e1j = function (clause) {
-    var tmp = this.l1m(clause);
+  protoOf(NumericIndex).j1l = function (clause) {
+    var tmp = this.q1o(clause);
     return map(tmp, NumericIndex$retractAll$lambda);
   };
-  protoOf(NumericIndex).u1k = function () {
+  protoOf(NumericIndex).z1m = function () {
     var tmp = Utils_instance;
-    var tmp_0 = asSequence(this.c1n_1.j2());
-    return tmp.o1l(map(tmp_0, NumericIndex$getCache$lambda));
+    var tmp_0 = asSequence(this.h1p_1.j2());
+    return tmp.t1n(map(tmp_0, NumericIndex$getCache$lambda));
   };
-  protoOf(NumericIndex).m1m = function (clause) {
-    var tmp = this.u1k();
+  protoOf(NumericIndex).r1o = function (clause) {
+    var tmp = this.z1m();
     return filter(tmp, NumericIndex$extractGlobalIndexedSequence$lambda(this, clause));
   };
   function extractFirst_3($this, clause, index) {
@@ -2024,7 +2024,7 @@
       var _iterator__ex2g4s = index.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        if ($this.m1i().match(item.q1k(), clause)) {
+        if ($this.r1k().match(clause, item.v1m())) {
           tmp$ret$0 = index_0;
           break $l$block;
         }
@@ -2042,69 +2042,69 @@
     return tmp;
   }
   function extractGlobalSequence_1($this, clause) {
-    var tmp = $this.m1m(clause);
+    var tmp = $this.r1o(clause);
     return map(tmp, VariableIndex$extractGlobalSequence$lambda);
   }
   function VariableIndex$retractAll$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function VariableIndex$extractGlobalIndexedSequence$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function VariableIndex$extractGlobalSequence$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function VariableIndex(unificator, ordered) {
     AbstractIndexingLeaf.call(this, unificator);
-    this.e1n_1 = ordered;
-    this.f1n_1 = dequeOf([]);
+    this.j1p_1 = ordered;
+    this.k1p_1 = dequeOf([]);
   }
   protoOf(VariableIndex).s = function () {
-    return this.f1n_1.s();
+    return this.k1p_1.s();
   };
-  protoOf(VariableIndex).r1i = function () {
-    return this.f1n_1.h();
+  protoOf(VariableIndex).w1k = function () {
+    return this.k1p_1.h();
   };
-  protoOf(VariableIndex).u1i = function (clause) {
+  protoOf(VariableIndex).z1k = function (clause) {
     return extractGlobalSequence_1(this, clause);
   };
-  protoOf(VariableIndex).s1k = function (clause) {
+  protoOf(VariableIndex).x1m = function (clause) {
     var tmp;
-    if (this.e1n_1) {
-      addFirst(this.f1n_1, Companion_instance_8.h1m(clause.z1l(this), this));
+    if (this.j1p_1) {
+      addFirst(this.k1p_1, Companion_instance_8.m1o(clause.e1o(this), this));
       tmp = Unit_instance;
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
       tmp = Unit_instance;
     }
     return tmp;
   };
-  protoOf(VariableIndex).t1k = function (clause) {
-    this.f1n_1.l(Companion_instance_8.h1m(clause.z1l(this), this));
+  protoOf(VariableIndex).y1m = function (clause) {
+    this.k1p_1.l(Companion_instance_8.m1o(clause.e1o(this), this));
   };
-  protoOf(VariableIndex).e1j = function (clause) {
-    var tmp = this.l1m(clause);
+  protoOf(VariableIndex).j1l = function (clause) {
+    var tmp = this.q1o(clause);
     return map(tmp, VariableIndex$retractAll$lambda);
   };
-  protoOf(VariableIndex).u1k = function () {
-    return asSequence(this.f1n_1);
+  protoOf(VariableIndex).z1m = function () {
+    return asSequence(this.k1p_1);
   };
-  protoOf(VariableIndex).j1m = function (clause) {
-    return extractFirst_3(this, clause, this.f1n_1);
+  protoOf(VariableIndex).o1o = function (clause) {
+    return extractFirst_3(this, clause, this.k1p_1);
   };
-  protoOf(VariableIndex).k1m = function (clause) {
-    return this.m1m(clause);
+  protoOf(VariableIndex).p1o = function (clause) {
+    return this.r1o(clause);
   };
-  protoOf(VariableIndex).g1m = function (indexed) {
-    this.f1n_1.z2(indexed);
+  protoOf(VariableIndex).l1o = function (indexed) {
+    this.k1p_1.z2(indexed);
   };
-  protoOf(VariableIndex).l1m = function (clause) {
-    return buffered(this.r1k(this.f1n_1, clause));
+  protoOf(VariableIndex).q1o = function (clause) {
+    return buffered(this.w1m(this.k1p_1, clause));
   };
-  protoOf(VariableIndex).m1m = function (clause) {
-    var tmp = asSequence(this.f1n_1);
+  protoOf(VariableIndex).r1o = function (clause) {
+    var tmp = asSequence(this.k1p_1);
     return filter(tmp, VariableIndex$extractGlobalIndexedSequence$lambda(this, clause));
   };
   function ArityNode(unificator) {
@@ -2112,78 +2112,78 @@
   }
   function FamilyArityIndexingNode(unificator, ordered, nestingLevel) {
     FamilyArityReteNode.call(this, unificator, ordered, nestingLevel);
-    this.o1n_1 = ordered;
+    this.t1p_1 = ordered;
   }
-  protoOf(FamilyArityIndexingNode).j1m = function (clause) {
+  protoOf(FamilyArityIndexingNode).o1o = function (clause) {
     var tmp;
-    if (this.o1n_1) {
-      tmp = this.y1n(clause);
+    if (this.t1p_1) {
+      tmp = this.d1q(clause);
     } else {
-      tmp = this.x1n(clause);
+      tmp = this.c1q(clause);
     }
     return tmp;
   };
-  protoOf(FamilyArityIndexingNode).k1m = function (clause) {
+  protoOf(FamilyArityIndexingNode).p1o = function (clause) {
     var tmp;
-    if (this.o1n_1) {
-      tmp = this.a1o(clause);
+    if (this.t1p_1) {
+      tmp = this.f1q(clause);
     } else {
-      tmp = this.z1n(clause);
+      tmp = this.e1q(clause);
     }
     return tmp;
   };
-  protoOf(FamilyArityIndexingNode).l1m = function (clause) {
+  protoOf(FamilyArityIndexingNode).q1o = function (clause) {
     var tmp;
-    if (this.o1n_1) {
-      tmp = this.c1o(clause);
+    if (this.t1p_1) {
+      tmp = this.h1q(clause);
     } else {
-      tmp = this.b1o(clause);
+      tmp = this.g1q(clause);
     }
     return tmp;
   };
-  protoOf(FamilyArityIndexingNode).m1m = function (clause) {
+  protoOf(FamilyArityIndexingNode).r1o = function (clause) {
     var tmp;
-    if (this.o1n_1) {
-      tmp = Utils_instance.m1l([this.t1n_1.m1m(clause), this.s1n_1.m1m(clause), this.u1n_1.m1m(clause), this.v1n_1.m1m(clause)]);
+    if (this.t1p_1) {
+      tmp = Utils_instance.r1n([this.y1p_1.r1o(clause), this.x1p_1.r1o(clause), this.z1p_1.r1o(clause), this.a1q_1.r1o(clause)]);
     } else {
-      tmp = Utils_instance.p1l([this.t1n_1.m1m(clause), this.s1n_1.m1m(clause), this.u1n_1.m1m(clause), this.v1n_1.m1m(clause)]);
+      tmp = Utils_instance.u1n([this.y1p_1.r1o(clause), this.x1p_1.r1o(clause), this.z1p_1.r1o(clause), this.a1q_1.r1o(clause)]);
     }
     return tmp;
   };
   function retractAllOrdered_0($this, clause) {
-    var tmp = $this.c1o(clause);
+    var tmp = $this.h1q(clause);
     return map(tmp, FamilyArityReteNode$retractAllOrdered$lambda);
   }
   function getOrdered($this, clause) {
-    var tmp = $this.a1o(clause);
+    var tmp = $this.f1q(clause);
     return map(tmp, FamilyArityReteNode$getOrdered$lambda);
   }
   function retractAllUnordered_0($this, clause) {
-    var tmp = $this.b1o(clause);
+    var tmp = $this.g1q(clause);
     return map(tmp, FamilyArityReteNode$retractAllUnordered$lambda);
   }
   function getUnordered($this, clause) {
-    var tmp = $this.z1n(clause);
+    var tmp = $this.e1q(clause);
     return map(tmp, FamilyArityReteNode$getUnordered$lambda);
   }
   function regenerateCache_0($this) {
     var tmp;
-    if ($this.q1n_1) {
-      tmp = Utils_instance.m1l([$this.t1n_1.u1k(), $this.s1n_1.u1k(), $this.u1n_1.u1k(), $this.v1n_1.u1k()]);
+    if ($this.v1p_1) {
+      tmp = Utils_instance.r1n([$this.y1p_1.z1m(), $this.x1p_1.z1m(), $this.z1p_1.z1m(), $this.a1q_1.z1m()]);
     } else {
-      tmp = Utils_instance.p1l([$this.t1n_1.u1k(), $this.s1n_1.u1k(), $this.u1n_1.u1k(), $this.v1n_1.u1k()]);
+      tmp = Utils_instance.u1n([$this.y1p_1.z1m(), $this.x1p_1.z1m(), $this.z1p_1.z1m(), $this.a1q_1.z1m()]);
     }
     return dequeOf_0(tmp);
   }
   function nestedFirstArgument_1($this, $receiver) {
-    return Utils_instance.l1l(ensureNotNull($receiver.dw()), $this.r1n_1 + 1 | 0);
+    return Utils_instance.q1n(ensureNotNull($receiver.dw()), $this.w1p_1 + 1 | 0);
   }
   function assertByFirstParameter($this, clause) {
-    var innerFirst = nestedFirstArgument_1($this, clause.q1k());
-    return innerFirst.xu() ? $this.s1n_1 : innerFirst.st() ? $this.t1n_1 : innerFirst.tu() ? $this.u1n_1 : $this.v1n_1;
+    var innerFirst = nestedFirstArgument_1($this, clause.v1m());
+    return innerFirst.xu() ? $this.x1p_1 : innerFirst.st() ? $this.y1p_1 : innerFirst.tu() ? $this.z1p_1 : $this.a1q_1;
   }
   function isGlobal_0($this, $receiver) {
-    return Utils_instance.l1l(ensureNotNull($receiver.dw()), $this.r1n_1 + 1 | 0).tu();
+    return Utils_instance.q1n(ensureNotNull($receiver.dw()), $this.w1p_1 + 1 | 0).tu();
   }
   function FamilyArityReteNode$regenerateCache$ref(p0) {
     return constructCallableReference(function () {
@@ -2195,66 +2195,66 @@
     return it.s();
   }
   function FamilyArityReteNode$get$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function FamilyArityReteNode$get$lambda_0(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function FamilyArityReteNode$retractAllOrdered$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function FamilyArityReteNode$getOrdered$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function FamilyArityReteNode$retractAllUnordered$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function FamilyArityReteNode$getUnordered$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function FamilyArityReteNode(unificator, ordered, nestingLevel) {
     ArityNode.call(this, unificator);
-    this.q1n_1 = ordered;
-    this.r1n_1 = nestingLevel;
-    this.s1n_1 = new NumericIndex(unificator, this.q1n_1, this.r1n_1);
-    this.t1n_1 = new AtomIndex(unificator, this.q1n_1, this.r1n_1);
-    this.u1n_1 = new VariableIndex(unificator, this.q1n_1);
-    this.v1n_1 = new CompoundIndex(unificator, this.q1n_1, this.r1n_1 + 1 | 0);
+    this.v1p_1 = ordered;
+    this.w1p_1 = nestingLevel;
+    this.x1p_1 = new NumericIndex(unificator, this.v1p_1, this.w1p_1);
+    this.y1p_1 = new AtomIndex(unificator, this.v1p_1, this.w1p_1);
+    this.z1p_1 = new VariableIndex(unificator, this.v1p_1);
+    this.a1q_1 = new CompoundIndex(unificator, this.v1p_1, this.w1p_1 + 1 | 0);
     var tmp = this;
     var tmp_0 = Companion_instance_1;
-    tmp.w1n_1 = tmp_0.yo(FamilyArityReteNode$regenerateCache$ref(this));
+    tmp.b1q_1 = tmp_0.yo(FamilyArityReteNode$regenerateCache$ref(this));
   }
-  protoOf(FamilyArityReteNode).c1j = function (clause) {
+  protoOf(FamilyArityReteNode).h1l = function (clause) {
     var tmp;
-    if (this.q1n_1) {
-      tmp = this.y1n(clause);
+    if (this.v1p_1) {
+      tmp = this.d1q(clause);
     } else {
-      tmp = this.x1n(clause);
+      tmp = this.c1q(clause);
     }
     var result = tmp;
     var tmp_0;
     if (result == null) {
       tmp_0 = emptySequence();
     } else {
-      result.f1m();
-      this.v1k();
-      tmp_0 = sequenceOf_0(result.q1k());
+      result.k1o();
+      this.a1n();
+      tmp_0 = sequenceOf_0(result.v1m());
     }
     return tmp_0;
   };
   protoOf(FamilyArityReteNode).s = function () {
-    var tmp = sequenceOf([this.s1n_1, this.t1n_1, this.u1n_1, this.v1n_1]);
+    var tmp = sequenceOf([this.x1p_1, this.y1p_1, this.z1p_1, this.a1q_1]);
     return sum(map(tmp, FamilyArityReteNode$_get_size_$lambda_sxz8zo));
   };
-  protoOf(FamilyArityReteNode).r1i = function () {
-    var tmp0 = sequenceOf([this.s1n_1, this.t1n_1, this.u1n_1, this.v1n_1]);
+  protoOf(FamilyArityReteNode).w1k = function () {
+    var tmp0 = sequenceOf([this.x1p_1, this.y1p_1, this.z1p_1, this.a1q_1]);
     var tmp$ret$0;
     $l$block: {
       // Inline function 'kotlin.sequences.all' call
       var _iterator__ex2g4s = tmp0.n();
       while (_iterator__ex2g4s.q()) {
         var element = _iterator__ex2g4s.r();
-        if (!element.r1i()) {
+        if (!element.w1k()) {
           tmp$ret$0 = false;
           break $l$block;
         }
@@ -2263,21 +2263,21 @@
     }
     return tmp$ret$0;
   };
-  protoOf(FamilyArityReteNode).u1i = function (clause) {
+  protoOf(FamilyArityReteNode).z1k = function (clause) {
     var tmp;
     if (isGlobal_0(this, clause)) {
       var tmp_0;
-      if (this.q1n_1) {
-        var tmp_1 = Utils_instance.m1l([this.t1n_1.m1m(clause), this.u1n_1.m1m(clause), this.s1n_1.m1m(clause), this.v1n_1.m1m(clause)]);
+      if (this.v1p_1) {
+        var tmp_1 = Utils_instance.r1n([this.y1p_1.r1o(clause), this.z1p_1.r1o(clause), this.x1p_1.r1o(clause), this.a1q_1.r1o(clause)]);
         tmp_0 = map(tmp_1, FamilyArityReteNode$get$lambda);
       } else {
-        var tmp_2 = Utils_instance.p1l([this.t1n_1.m1m(clause), this.u1n_1.m1m(clause), this.s1n_1.m1m(clause), this.v1n_1.m1m(clause)]);
+        var tmp_2 = Utils_instance.u1n([this.y1p_1.r1o(clause), this.z1p_1.r1o(clause), this.x1p_1.r1o(clause), this.a1q_1.r1o(clause)]);
         tmp_0 = map(tmp_2, FamilyArityReteNode$get$lambda_0);
       }
       tmp = tmp_0;
     } else {
       var tmp_3;
-      if (this.q1n_1) {
+      if (this.v1p_1) {
         tmp_3 = getOrdered(this, clause);
       } else {
         tmp_3 = getUnordered(this, clause);
@@ -2286,94 +2286,94 @@
     }
     return tmp;
   };
-  protoOf(FamilyArityReteNode).s1k = function (clause) {
-    return assertByFirstParameter(this, clause).s1k(clause.z1l(this));
+  protoOf(FamilyArityReteNode).x1m = function (clause) {
+    return assertByFirstParameter(this, clause).x1m(clause.e1o(this));
   };
-  protoOf(FamilyArityReteNode).t1k = function (clause) {
-    return assertByFirstParameter(this, clause).t1k(clause.z1l(this));
+  protoOf(FamilyArityReteNode).y1m = function (clause) {
+    return assertByFirstParameter(this, clause).y1m(clause.e1o(this));
   };
-  protoOf(FamilyArityReteNode).e1j = function (clause) {
+  protoOf(FamilyArityReteNode).j1l = function (clause) {
     var tmp;
-    if (this.q1n_1) {
+    if (this.v1p_1) {
       tmp = retractAllOrdered_0(this, clause);
     } else {
       tmp = retractAllUnordered_0(this, clause);
     }
     return tmp;
   };
-  protoOf(FamilyArityReteNode).u1k = function () {
-    return asSequence(this.w1n_1.e2());
+  protoOf(FamilyArityReteNode).z1m = function () {
+    return asSequence(this.b1q_1.e2());
   };
-  protoOf(FamilyArityReteNode).c1o = function (clause) {
+  protoOf(FamilyArityReteNode).h1q = function (clause) {
     var innerFirst = nestedFirstArgument_1(this, clause);
     var tmp;
     if (innerFirst.xu()) {
-      tmp = Utils_instance.m1l([this.u1n_1.l1m(clause), this.s1n_1.l1m(clause)]);
+      tmp = Utils_instance.r1n([this.z1p_1.q1o(clause), this.x1p_1.q1o(clause)]);
     } else if (innerFirst.st()) {
-      tmp = Utils_instance.m1l([this.u1n_1.l1m(clause), this.t1n_1.l1m(clause)]);
+      tmp = Utils_instance.r1n([this.z1p_1.q1o(clause), this.y1p_1.q1o(clause)]);
     } else if (innerFirst.tu()) {
-      tmp = Utils_instance.m1l([this.u1n_1.l1m(clause), this.s1n_1.l1m(clause), this.t1n_1.l1m(clause), this.v1n_1.l1m(clause)]);
+      tmp = Utils_instance.r1n([this.z1p_1.q1o(clause), this.x1p_1.q1o(clause), this.y1p_1.q1o(clause), this.a1q_1.q1o(clause)]);
     } else {
-      tmp = Utils_instance.m1l([this.u1n_1.l1m(clause), this.v1n_1.l1m(clause)]);
+      tmp = Utils_instance.r1n([this.z1p_1.q1o(clause), this.a1q_1.q1o(clause)]);
     }
     return tmp;
   };
-  protoOf(FamilyArityReteNode).b1o = function (clause) {
+  protoOf(FamilyArityReteNode).g1q = function (clause) {
     var innerFirst = nestedFirstArgument_1(this, clause);
-    return innerFirst.xu() ? Utils_instance.p1l([this.u1n_1.l1m(clause), this.s1n_1.l1m(clause)]) : innerFirst.st() ? Utils_instance.p1l([this.u1n_1.l1m(clause), this.t1n_1.l1m(clause)]) : innerFirst.tu() ? Utils_instance.p1l([this.u1n_1.l1m(clause), this.s1n_1.l1m(clause), this.t1n_1.l1m(clause), this.v1n_1.l1m(clause)]) : Utils_instance.p1l([this.u1n_1.l1m(clause), this.v1n_1.l1m(clause)]);
+    return innerFirst.xu() ? Utils_instance.u1n([this.z1p_1.q1o(clause), this.x1p_1.q1o(clause)]) : innerFirst.st() ? Utils_instance.u1n([this.z1p_1.q1o(clause), this.y1p_1.q1o(clause)]) : innerFirst.tu() ? Utils_instance.u1n([this.z1p_1.q1o(clause), this.x1p_1.q1o(clause), this.y1p_1.q1o(clause), this.a1q_1.q1o(clause)]) : Utils_instance.u1n([this.z1p_1.q1o(clause), this.a1q_1.q1o(clause)]);
   };
-  protoOf(FamilyArityReteNode).a1o = function (clause) {
+  protoOf(FamilyArityReteNode).f1q = function (clause) {
     var innerFirst = nestedFirstArgument_1(this, clause);
-    return innerFirst.xu() ? Utils_instance.m1l([this.u1n_1.k1m(clause), this.s1n_1.k1m(clause)]) : innerFirst.st() ? Utils_instance.m1l([this.u1n_1.k1m(clause), this.t1n_1.k1m(clause)]) : innerFirst.tu() ? Utils_instance.m1l([this.u1n_1.k1m(clause), this.s1n_1.k1m(clause), this.t1n_1.k1m(clause), this.v1n_1.k1m(clause)]) : Utils_instance.m1l([this.u1n_1.k1m(clause), this.v1n_1.k1m(clause)]);
+    return innerFirst.xu() ? Utils_instance.r1n([this.z1p_1.p1o(clause), this.x1p_1.p1o(clause)]) : innerFirst.st() ? Utils_instance.r1n([this.z1p_1.p1o(clause), this.y1p_1.p1o(clause)]) : innerFirst.tu() ? Utils_instance.r1n([this.z1p_1.p1o(clause), this.x1p_1.p1o(clause), this.y1p_1.p1o(clause), this.a1q_1.p1o(clause)]) : Utils_instance.r1n([this.z1p_1.p1o(clause), this.a1q_1.p1o(clause)]);
   };
-  protoOf(FamilyArityReteNode).z1n = function (clause) {
+  protoOf(FamilyArityReteNode).e1q = function (clause) {
     var innerFirst = nestedFirstArgument_1(this, clause);
-    return innerFirst.xu() ? Utils_instance.p1l([this.u1n_1.k1m(clause), this.s1n_1.k1m(clause)]) : innerFirst.st() ? Utils_instance.p1l([this.u1n_1.k1m(clause), this.t1n_1.k1m(clause)]) : innerFirst.tu() ? Utils_instance.p1l([this.u1n_1.k1m(clause), this.s1n_1.k1m(clause), this.t1n_1.k1m(clause), this.v1n_1.k1m(clause)]) : Utils_instance.p1l([this.u1n_1.k1m(clause), this.v1n_1.k1m(clause)]);
+    return innerFirst.xu() ? Utils_instance.u1n([this.z1p_1.p1o(clause), this.x1p_1.p1o(clause)]) : innerFirst.st() ? Utils_instance.u1n([this.z1p_1.p1o(clause), this.y1p_1.p1o(clause)]) : innerFirst.tu() ? Utils_instance.u1n([this.z1p_1.p1o(clause), this.x1p_1.p1o(clause), this.y1p_1.p1o(clause), this.a1q_1.p1o(clause)]) : Utils_instance.u1n([this.z1p_1.p1o(clause), this.a1q_1.p1o(clause)]);
   };
-  protoOf(FamilyArityReteNode).x1n = function (clause) {
+  protoOf(FamilyArityReteNode).c1q = function (clause) {
     var innerFirst = nestedFirstArgument_1(this, clause);
     var tmp;
     if (innerFirst.xu()) {
-      var tmp0_elvis_lhs = this.u1n_1.j1m(clause);
-      tmp = tmp0_elvis_lhs == null ? this.s1n_1.j1m(clause) : tmp0_elvis_lhs;
+      var tmp0_elvis_lhs = this.z1p_1.o1o(clause);
+      tmp = tmp0_elvis_lhs == null ? this.x1p_1.o1o(clause) : tmp0_elvis_lhs;
     } else if (innerFirst.st()) {
-      var tmp1_elvis_lhs = this.u1n_1.j1m(clause);
-      tmp = tmp1_elvis_lhs == null ? this.t1n_1.j1m(clause) : tmp1_elvis_lhs;
+      var tmp1_elvis_lhs = this.z1p_1.o1o(clause);
+      tmp = tmp1_elvis_lhs == null ? this.y1p_1.o1o(clause) : tmp1_elvis_lhs;
     } else if (innerFirst.tu()) {
-      var tmp2_elvis_lhs = this.u1n_1.j1m(clause);
-      var tmp3_elvis_lhs = tmp2_elvis_lhs == null ? this.s1n_1.j1m(clause) : tmp2_elvis_lhs;
-      var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? this.t1n_1.j1m(clause) : tmp3_elvis_lhs;
-      tmp = tmp4_elvis_lhs == null ? this.v1n_1.j1m(clause) : tmp4_elvis_lhs;
+      var tmp2_elvis_lhs = this.z1p_1.o1o(clause);
+      var tmp3_elvis_lhs = tmp2_elvis_lhs == null ? this.x1p_1.o1o(clause) : tmp2_elvis_lhs;
+      var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? this.y1p_1.o1o(clause) : tmp3_elvis_lhs;
+      tmp = tmp4_elvis_lhs == null ? this.a1q_1.o1o(clause) : tmp4_elvis_lhs;
     } else {
-      var tmp5_elvis_lhs = this.u1n_1.j1m(clause);
-      tmp = tmp5_elvis_lhs == null ? this.v1n_1.j1m(clause) : tmp5_elvis_lhs;
+      var tmp5_elvis_lhs = this.z1p_1.o1o(clause);
+      tmp = tmp5_elvis_lhs == null ? this.a1q_1.o1o(clause) : tmp5_elvis_lhs;
     }
     return tmp;
   };
-  protoOf(FamilyArityReteNode).y1n = function (clause) {
+  protoOf(FamilyArityReteNode).d1q = function (clause) {
     var innerFirst = nestedFirstArgument_1(this, clause);
     var tmp;
     if (innerFirst.xu()) {
-      tmp = Utils_instance.v1l(this.s1n_1.j1m(clause), this.u1n_1.j1m(clause));
+      tmp = Utils_instance.a1o(this.x1p_1.o1o(clause), this.z1p_1.o1o(clause));
     } else if (innerFirst.st()) {
-      tmp = Utils_instance.v1l(this.t1n_1.j1m(clause), this.u1n_1.j1m(clause));
+      tmp = Utils_instance.a1o(this.y1p_1.o1o(clause), this.z1p_1.o1o(clause));
     } else if (innerFirst.tu()) {
-      tmp = Utils_instance.v1l(Utils_instance.v1l(this.s1n_1.j1m(clause), this.t1n_1.j1m(clause)), Utils_instance.v1l(this.u1n_1.j1m(clause), this.v1n_1.j1m(clause)));
+      tmp = Utils_instance.a1o(Utils_instance.a1o(this.x1p_1.o1o(clause), this.y1p_1.o1o(clause)), Utils_instance.a1o(this.z1p_1.o1o(clause), this.a1q_1.o1o(clause)));
     } else {
-      tmp = Utils_instance.v1l(this.u1n_1.j1m(clause), this.v1n_1.j1m(clause));
+      tmp = Utils_instance.a1o(this.z1p_1.o1o(clause), this.a1q_1.o1o(clause));
     }
     return tmp;
   };
-  protoOf(FamilyArityReteNode).v1k = function () {
-    this.w1n_1.ap();
+  protoOf(FamilyArityReteNode).a1n = function () {
+    this.b1q_1.ap();
   };
   function isGlobal_1($this, $receiver) {
-    return $receiver.fu() && Utils_instance.l1l($receiver.castToRule().dw(), $this.f1o_1).tu();
+    return $receiver.fu() && Utils_instance.q1n($receiver.castToRule().dw(), $this.k1q_1).tu();
   }
   function nestedArity($this, $receiver) {
     var tmp0_safe_receiver = $receiver.asRule();
     var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.dw();
-    var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : Utils_instance.j1l(tmp1_safe_receiver, $this.f1o_1);
+    var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : Utils_instance.o1n(tmp1_safe_receiver, $this.k1q_1);
     var tmp;
     if (tmp2_elvis_lhs == null) {
       // Inline function 'kotlin.error' call
@@ -2385,36 +2385,36 @@
     return tmp;
   }
   function nestedArity_0($this, $receiver) {
-    return Utils_instance.j1l(ensureNotNull($receiver.q1k().dw()), $this.f1o_1);
+    return Utils_instance.o1n(ensureNotNull($receiver.v1m().dw()), $this.k1q_1);
   }
   function regenerateCache_1($this) {
     var tmp;
-    if ($this.e1o_1) {
+    if ($this.j1q_1) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = $this.g1o_1.j2();
+      var this_0 = $this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.u1k();
+        var tmp$ret$2 = item.z1m();
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
       var tmp_1 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_1 = $this.g1o_1.j2();
+      var this_1 = $this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
       var _iterator__ex2g4s_0 = this_1.n();
       while (_iterator__ex2g4s_0.q()) {
         var item_0 = _iterator__ex2g4s_0.r();
-        var tmp$ret$5 = item_0.u1k();
+        var tmp$ret$5 = item_0.z1m();
         destination_0.l(tmp$ret$5);
       }
-      tmp = tmp_1.r1l(destination_0);
+      tmp = tmp_1.w1n(destination_0);
     }
     return dequeOf_0(tmp);
   }
@@ -2429,30 +2429,30 @@
   }
   function FunctorIndexingNode$retractAllIndexed$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function FunctorIndexingNode(unificator, ordered, nestingLevel) {
     FunctorNode.call(this, unificator);
-    this.e1o_1 = ordered;
-    this.f1o_1 = nestingLevel;
+    this.j1q_1 = ordered;
+    this.k1q_1 = nestingLevel;
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.g1o_1 = LinkedHashMap_init_$Create$();
+    tmp.l1q_1 = LinkedHashMap_init_$Create$();
     var tmp_0 = this;
     var tmp_1 = Companion_instance_1;
-    tmp_0.h1o_1 = tmp_1.yo(FunctorIndexingNode$regenerateCache$ref(this));
+    tmp_0.m1q_1 = tmp_1.yo(FunctorIndexingNode$regenerateCache$ref(this));
   }
   protoOf(FunctorIndexingNode).s = function () {
-    var tmp = asSequence(this.g1o_1.j2());
+    var tmp = asSequence(this.l1q_1.j2());
     return sum(map(tmp, FunctorIndexingNode$_get_size_$lambda_vcufvm));
   };
-  protoOf(FunctorIndexingNode).r1i = function () {
+  protoOf(FunctorIndexingNode).w1k = function () {
     var tmp;
-    if (this.g1o_1.h()) {
+    if (this.l1q_1.h()) {
       tmp = true;
     } else {
-      var tmp0 = this.g1o_1.j2();
+      var tmp0 = this.l1q_1.j2();
       var tmp$ret$0;
       $l$block_0: {
         // Inline function 'kotlin.collections.all' call
@@ -2469,7 +2469,7 @@
         var _iterator__ex2g4s = tmp0.n();
         while (_iterator__ex2g4s.q()) {
           var element = _iterator__ex2g4s.r();
-          if (!element.r1i()) {
+          if (!element.w1k()) {
             tmp$ret$0 = false;
             break $l$block_0;
           }
@@ -2480,71 +2480,71 @@
     }
     return tmp;
   };
-  protoOf(FunctorIndexingNode).u1i = function (clause) {
-    var tmp0_safe_receiver = this.g1o_1.h2(nestedArity(this, clause));
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u1i(clause);
+  protoOf(FunctorIndexingNode).z1k = function (clause) {
+    var tmp0_safe_receiver = this.l1q_1.h2(nestedArity(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z1k(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(FunctorIndexingNode).s1k = function (clause) {
-    var tmp0 = this.g1o_1;
+  protoOf(FunctorIndexingNode).x1m = function (clause) {
+    var tmp0 = this.l1q_1;
     // Inline function 'kotlin.collections.getOrPut' call
     var key = nestedArity_0(this, clause);
     var value = tmp0.h2(key);
     var tmp;
     if (value == null) {
-      var answer = new FamilyArityIndexingNode(this.m1i(), this.e1o_1, this.f1o_1);
+      var answer = new FamilyArityIndexingNode(this.r1k(), this.j1q_1, this.k1q_1);
       tmp0.k4(key, answer);
       tmp = answer;
     } else {
       tmp = value;
     }
-    tmp.s1k(clause.z1l(this));
+    tmp.x1m(clause.e1o(this));
   };
-  protoOf(FunctorIndexingNode).t1k = function (clause) {
-    var tmp0 = this.g1o_1;
+  protoOf(FunctorIndexingNode).y1m = function (clause) {
+    var tmp0 = this.l1q_1;
     // Inline function 'kotlin.collections.getOrPut' call
     var key = nestedArity_0(this, clause);
     var value = tmp0.h2(key);
     var tmp;
     if (value == null) {
-      var answer = new FamilyArityIndexingNode(this.m1i(), this.e1o_1, this.f1o_1);
+      var answer = new FamilyArityIndexingNode(this.r1k(), this.j1q_1, this.k1q_1);
       tmp0.k4(key, answer);
       tmp = answer;
     } else {
       tmp = value;
     }
-    tmp.t1k(clause.z1l(this));
+    tmp.y1m(clause.e1o(this));
   };
-  protoOf(FunctorIndexingNode).e1j = function (clause) {
-    var tmp0_safe_receiver = this.g1o_1.h2(nestedArity(this, clause));
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1j(clause);
+  protoOf(FunctorIndexingNode).j1l = function (clause) {
+    var tmp0_safe_receiver = this.l1q_1.h2(nestedArity(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j1l(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(FunctorIndexingNode).u1k = function () {
-    return asSequence(this.h1o_1.e2());
+  protoOf(FunctorIndexingNode).z1m = function () {
+    return asSequence(this.m1q_1.e2());
   };
-  protoOf(FunctorIndexingNode).j1m = function (clause) {
+  protoOf(FunctorIndexingNode).o1o = function (clause) {
     var tmp;
     if (isGlobal_1(this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.g1o_1.j2();
+      var this_0 = this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.m1m(clause);
+        var tmp$ret$2 = item.r1o(clause);
         destination.l(tmp$ret$2);
       }
-      var tmp0 = tmp_0.n1l(destination);
+      var tmp0 = tmp_0.s1n(destination);
       var tmp$ret$3;
       $l$block: {
         // Inline function 'kotlin.sequences.firstOrNull' call
         var _iterator__ex2g4s_0 = tmp0.n();
         while (_iterator__ex2g4s_0.q()) {
           var element = _iterator__ex2g4s_0.r();
-          if (this.m1i().match(element.q1k(), clause)) {
+          if (this.r1k().match(clause, element.v1m())) {
             tmp$ret$3 = element;
             break $l$block;
           }
@@ -2553,125 +2553,125 @@
       }
       tmp = tmp$ret$3;
     } else {
-      var tmp0_safe_receiver = this.g1o_1.h2(nestedArity(this, clause));
-      tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j1m(clause);
+      var tmp0_safe_receiver = this.l1q_1.h2(nestedArity(this, clause));
+      tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.o1o(clause);
     }
     return tmp;
   };
-  protoOf(FunctorIndexingNode).k1m = function (clause) {
+  protoOf(FunctorIndexingNode).p1o = function (clause) {
     var tmp;
     if (isGlobal_1(this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.g1o_1.j2();
+      var this_0 = this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.m1m(clause);
+        var tmp$ret$2 = item.r1o(clause);
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
-      var tmp0_safe_receiver = this.g1o_1.h2(nestedArity(this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.k1m(clause);
+      var tmp0_safe_receiver = this.l1q_1.h2(nestedArity(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p1o(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
   };
-  protoOf(FunctorIndexingNode).l1m = function (clause) {
+  protoOf(FunctorIndexingNode).q1o = function (clause) {
     var tmp;
     if (isGlobal_1(this, clause)) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.g1o_1.j2();
+      var this_0 = this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.m1m(clause);
+        var tmp$ret$2 = item.r1o(clause);
         destination.l(tmp$ret$2);
       }
-      var tmp_1 = tmp_0.n1l(destination);
+      var tmp_1 = tmp_0.s1n(destination);
       var partialResult = toList(filter(tmp_1, FunctorIndexingNode$retractAllIndexed$lambda(this, clause)));
       // Inline function 'kotlin.collections.isNotEmpty' call
       if (!partialResult.h()) {
-        this.v1k();
+        this.a1n();
         // Inline function 'kotlin.collections.forEach' call
         var _iterator__ex2g4s_0 = partialResult.n();
         while (_iterator__ex2g4s_0.q()) {
           var element = _iterator__ex2g4s_0.r();
-          element.f1m();
+          element.k1o();
         }
       }
       tmp = asSequence(partialResult);
     } else {
-      var tmp0_safe_receiver = this.g1o_1.h2(nestedArity(this, clause));
-      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.l1m(clause);
+      var tmp0_safe_receiver = this.l1q_1.h2(nestedArity(this, clause));
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.q1o(clause);
       tmp = tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
     }
     return tmp;
   };
-  protoOf(FunctorIndexingNode).m1m = function (clause) {
+  protoOf(FunctorIndexingNode).r1o = function (clause) {
     var tmp;
-    if (this.e1o_1) {
+    if (this.j1q_1) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.g1o_1.j2();
+      var this_0 = this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.m1m(clause);
+        var tmp$ret$2 = item.r1o(clause);
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
       var tmp_1 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_1 = this.g1o_1.j2();
+      var this_1 = this.l1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
       var _iterator__ex2g4s_0 = this_1.n();
       while (_iterator__ex2g4s_0.q()) {
         var item_0 = _iterator__ex2g4s_0.r();
-        var tmp$ret$5 = item_0.m1m(clause);
+        var tmp$ret$5 = item_0.r1o(clause);
         destination_0.l(tmp$ret$5);
       }
-      tmp = tmp_1.r1l(destination_0);
+      tmp = tmp_1.w1n(destination_0);
     }
     return tmp;
   };
-  protoOf(FunctorIndexingNode).v1k = function () {
-    this.h1o_1.ap();
+  protoOf(FunctorIndexingNode).a1n = function () {
+    this.m1q_1.ap();
   };
   function FunctorNode(unificator) {
     AbstractReteNode.call(this, unificator);
   }
   function assignHigherIndex($this, clause) {
     var tmp = Companion_instance_7;
-    $this.o1o_1 = add($this.o1o_1, get_ONE());
-    return tmp.b1m($this.o1o_1, clause, [$this]);
+    $this.t1q_1 = add($this.t1q_1, get_ONE());
+    return tmp.g1o($this.t1q_1, clause, [$this]);
   }
   function assignLowerIndex($this, clause) {
     var tmp = Companion_instance_7;
-    $this.n1o_1 = subtract($this.n1o_1, get_ONE());
-    return tmp.b1m($this.n1o_1, clause, [$this]);
+    $this.s1q_1 = subtract($this.s1q_1, get_ONE());
+    return tmp.g1o($this.s1q_1, clause, [$this]);
   }
   function regenerateCache_2($this) {
     var tmp;
-    if ($this.j1o_1) {
-      var tmp_0 = Utils_instance.m1l([$this.m1o_1.u1k(), $this.l1o_1.u1k()]);
+    if ($this.o1q_1) {
+      var tmp_0 = Utils_instance.r1n([$this.r1q_1.z1m(), $this.q1q_1.z1m()]);
       tmp = map(tmp_0, RootNode$regenerateCache$lambda);
     } else {
       var tmp_1 = Utils_instance;
-      var tmp_2 = $this.m1o_1.u1k();
+      var tmp_2 = $this.r1q_1.z1m();
       var tmp_3 = map(tmp_2, RootNode$regenerateCache$lambda_0);
-      var tmp_4 = $this.l1o_1.u1k();
-      tmp = tmp_1.s1l([tmp_3, map(tmp_4, RootNode$regenerateCache$lambda_1)]);
+      var tmp_4 = $this.q1q_1.z1m();
+      tmp = tmp_1.x1n([tmp_3, map(tmp_4, RootNode$regenerateCache$lambda_1)]);
     }
     return dequeOf_0(tmp);
   }
@@ -2699,146 +2699,146 @@
     };
   }
   function RootNode$regenerateCache$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function RootNode$regenerateCache$lambda_0(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function RootNode$regenerateCache$lambda_1(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function RootNode(unificator, clauses, isOrdered) {
-    this.i1o_1 = unificator;
-    this.j1o_1 = isOrdered;
+    this.n1q_1 = unificator;
+    this.o1q_1 = isOrdered;
     var tmp = this;
     var tmp_0 = Companion_instance_1;
-    tmp.k1o_1 = tmp_0.yo(RootNode$regenerateCache$ref(this));
-    this.l1o_1 = new RuleNode(this.i1o_1, this.j1o_1);
-    this.m1o_1 = new DirectiveIndex(this.i1o_1, this.j1o_1);
-    this.n1o_1 = 0n;
-    this.o1o_1 = 0n;
+    tmp.p1q_1 = tmp_0.yo(RootNode$regenerateCache$ref(this));
+    this.q1q_1 = new RuleNode(this.n1q_1, this.o1q_1);
+    this.r1q_1 = new DirectiveIndex(this.n1q_1, this.o1q_1);
+    this.s1q_1 = 0n;
+    this.t1q_1 = 0n;
     // Inline function 'kotlin.collections.forEach' call
     var _iterator__ex2g4s = clauses.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      this.z1i(element);
+      this.e1l(element);
     }
   }
-  protoOf(RootNode).m1i = function () {
-    return this.i1o_1;
+  protoOf(RootNode).r1k = function () {
+    return this.n1q_1;
   };
-  protoOf(RootNode).u1j = function () {
-    return this.j1o_1;
+  protoOf(RootNode).z1l = function () {
+    return this.o1q_1;
   };
   protoOf(RootNode).s = function () {
-    return this.m1o_1.s() + this.l1o_1.s() | 0;
+    return this.r1q_1.s() + this.q1q_1.s() | 0;
   };
-  protoOf(RootNode).r1i = function () {
-    return this.m1o_1.r1i() && this.l1o_1.r1i();
+  protoOf(RootNode).w1k = function () {
+    return this.r1q_1.w1k() && this.q1q_1.w1k();
   };
-  protoOf(RootNode).w1i = function () {
-    return asSequence(this.k1o_1.e2());
+  protoOf(RootNode).b1l = function () {
+    return asSequence(this.p1q_1.e2());
   };
-  protoOf(RootNode).p1i = function () {
-    var tmp = this.m1o_1.u1k();
+  protoOf(RootNode).u1k = function () {
+    var tmp = this.r1q_1.z1m();
     return map(tmp, RootNode$_get_directives_$lambda_9lfp1g);
   };
-  protoOf(RootNode).q1i = function () {
-    var tmp = this.l1o_1.u1k();
+  protoOf(RootNode).v1k = function () {
+    var tmp = this.q1q_1.z1m();
     return map(tmp, RootNode$_get_rules_$lambda_py6utr);
   };
-  protoOf(RootNode).u1i = function (clause) {
+  protoOf(RootNode).z1k = function (clause) {
     var tmp;
     if (clause.gu()) {
-      tmp = this.m1o_1.u1i(clause);
+      tmp = this.r1q_1.z1k(clause);
     } else {
-      tmp = this.l1o_1.u1i(clause);
+      tmp = this.q1q_1.z1k(clause);
     }
     return tmp;
   };
-  protoOf(RootNode).c1j = function (clause) {
+  protoOf(RootNode).h1l = function (clause) {
     var tmp;
     if (clause.gu()) {
-      tmp = this.m1o_1.c1j(clause);
+      tmp = this.r1q_1.h1l(clause);
     } else {
-      tmp = this.l1o_1.c1j(clause);
+      tmp = this.q1q_1.h1l(clause);
     }
     return tmp;
   };
-  protoOf(RootNode).e1j = function (clause) {
+  protoOf(RootNode).j1l = function (clause) {
     var tmp;
     if (clause.gu()) {
-      tmp = this.m1o_1.e1j(clause);
+      tmp = this.r1q_1.j1l(clause);
     } else {
-      tmp = this.l1o_1.e1j(clause);
+      tmp = this.q1q_1.j1l(clause);
     }
     return tmp;
   };
-  protoOf(RootNode).h1j = function () {
-    return new RootNode(this.i1o_1, asIterable(this.w1i()), this.j1o_1);
+  protoOf(RootNode).m1l = function () {
+    return new RootNode(this.n1q_1, asIterable(this.b1l()), this.o1q_1);
   };
-  protoOf(RootNode).y1j = function (clause) {
+  protoOf(RootNode).d1m = function (clause) {
     var indexed = assignLowerIndex(this, clause);
-    if (this.j1o_1) {
-      this.k1o_1.bp(RootNode$assertA$lambda(clause));
+    if (this.o1q_1) {
+      this.p1q_1.bp(RootNode$assertA$lambda(clause));
       if (clause.gu()) {
-        this.m1o_1.s1k(indexed);
+        this.r1q_1.x1m(indexed);
       } else {
-        this.l1o_1.s1k(indexed);
+        this.q1q_1.x1m(indexed);
       }
     } else {
       throw UnsupportedOperationException_init_$Create$('An unordered ReteTree cannot perform the assertA operation.');
     }
   };
-  protoOf(RootNode).z1i = function (clause) {
+  protoOf(RootNode).e1l = function (clause) {
     var indexed = assignHigherIndex(this, clause);
-    this.k1o_1.bp(RootNode$assertZ$lambda(clause));
+    this.p1q_1.bp(RootNode$assertZ$lambda(clause));
     if (clause.gu()) {
-      this.m1o_1.t1k(indexed);
+      this.r1q_1.y1m(indexed);
     } else {
-      this.l1o_1.t1k(indexed);
+      this.q1q_1.y1m(indexed);
     }
   };
-  protoOf(RootNode).u1k = function () {
-    return asSequence(this.k1o_1.e2());
+  protoOf(RootNode).z1m = function () {
+    return asSequence(this.p1q_1.e2());
   };
-  protoOf(RootNode).v1k = function () {
-    this.k1o_1.ap();
+  protoOf(RootNode).a1n = function () {
+    this.p1q_1.ap();
   };
   function nestedFunctor_1($this, $receiver) {
-    return Utils_instance.k1l(ensureNotNull($receiver.dw()), 0);
+    return Utils_instance.p1n(ensureNotNull($receiver.dw()), 0);
   }
   function nestedFunctor_2($this, $receiver) {
-    return nestedFunctor_1($this, $receiver.q1k());
+    return nestedFunctor_1($this, $receiver.v1m());
   }
   function regenerateCache_3($this) {
     var tmp;
-    if ($this.q1o_1) {
+    if ($this.v1q_1) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = $this.r1o_1.j2();
+      var this_0 = $this.w1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.u1k();
+        var tmp$ret$2 = item.z1m();
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
       var tmp_1 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_1 = $this.r1o_1.j2();
+      var this_1 = $this.w1q_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
       var _iterator__ex2g4s_0 = this_1.n();
       while (_iterator__ex2g4s_0.q()) {
         var item_0 = _iterator__ex2g4s_0.r();
-        var tmp$ret$5 = item_0.u1k();
+        var tmp$ret$5 = item_0.z1m();
         destination_0.l(tmp$ret$5);
       }
-      tmp = tmp_1.r1l(destination_0);
+      tmp = tmp_1.w1n(destination_0);
     }
     return dequeOf_0(tmp);
   }
@@ -2852,71 +2852,71 @@
     return it.s();
   }
   function RuleNode(unificator, ordered) {
-    this.p1o_1 = unificator;
-    this.q1o_1 = ordered;
+    this.u1q_1 = unificator;
+    this.v1q_1 = ordered;
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.r1o_1 = LinkedHashMap_init_$Create$();
+    tmp.w1q_1 = LinkedHashMap_init_$Create$();
     var tmp_0 = this;
     var tmp_1 = Companion_instance_1;
-    tmp_0.s1o_1 = tmp_1.yo(RuleNode$regenerateCache$ref(this));
+    tmp_0.x1q_1 = tmp_1.yo(RuleNode$regenerateCache$ref(this));
   }
-  protoOf(RuleNode).u1i = function (clause) {
-    var tmp0_safe_receiver = this.r1o_1.h2(nestedFunctor_1(this, clause));
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u1i(clause);
+  protoOf(RuleNode).z1k = function (clause) {
+    var tmp0_safe_receiver = this.w1q_1.h2(nestedFunctor_1(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z1k(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(RuleNode).s1k = function (clause) {
+  protoOf(RuleNode).x1m = function (clause) {
     // Inline function 'kotlin.let' call
     var it = nestedFunctor_2(this, clause);
-    if (this.q1o_1) {
+    if (this.v1q_1) {
       // Inline function 'kotlin.collections.getOrPut' call
-      var this_0 = this.r1o_1;
+      var this_0 = this.w1q_1;
       var value = this_0.h2(it);
       var tmp;
       if (value == null) {
-        var answer = new TopLevelFunctorReteNode(this.p1o_1, this.q1o_1, 0);
+        var answer = new TopLevelFunctorReteNode(this.u1q_1, this.v1q_1, 0);
         this_0.k4(it, answer);
         tmp = answer;
       } else {
         tmp = value;
       }
-      tmp.s1k(clause.z1l(this));
+      tmp.x1m(clause.e1o(this));
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
     }
   };
-  protoOf(RuleNode).t1k = function (clause) {
+  protoOf(RuleNode).y1m = function (clause) {
     // Inline function 'kotlin.let' call
     var it = nestedFunctor_2(this, clause);
     // Inline function 'kotlin.collections.getOrPut' call
-    var this_0 = this.r1o_1;
+    var this_0 = this.w1q_1;
     var value = this_0.h2(it);
     var tmp;
     if (value == null) {
-      var answer = new TopLevelFunctorReteNode(this.p1o_1, this.q1o_1, 0);
+      var answer = new TopLevelFunctorReteNode(this.u1q_1, this.v1q_1, 0);
       this_0.k4(it, answer);
       tmp = answer;
     } else {
       tmp = value;
     }
-    tmp.t1k(clause.z1l(this));
+    tmp.y1m(clause.e1o(this));
   };
-  protoOf(RuleNode).c1j = function (clause) {
-    var tmp0_safe_receiver = this.r1o_1.h2(nestedFunctor_1(this, clause));
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1j(clause);
+  protoOf(RuleNode).h1l = function (clause) {
+    var tmp0_safe_receiver = this.w1q_1.h2(nestedFunctor_1(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.h1l(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
   protoOf(RuleNode).s = function () {
-    var tmp = asSequence(this.r1o_1.j2());
+    var tmp = asSequence(this.w1q_1.j2());
     return sum(map(tmp, RuleNode$_get_size_$lambda_xjenvf));
   };
-  protoOf(RuleNode).r1i = function () {
+  protoOf(RuleNode).w1k = function () {
     var tmp;
-    if (this.r1o_1.h()) {
+    if (this.w1q_1.h()) {
       tmp = true;
     } else {
-      var tmp0 = this.r1o_1.j2();
+      var tmp0 = this.w1q_1.j2();
       var tmp$ret$0;
       $l$block_0: {
         // Inline function 'kotlin.collections.all' call
@@ -2933,7 +2933,7 @@
         var _iterator__ex2g4s = tmp0.n();
         while (_iterator__ex2g4s.q()) {
           var element = _iterator__ex2g4s.r();
-          if (!element.r1i()) {
+          if (!element.w1k()) {
             tmp$ret$0 = false;
             break $l$block_0;
           }
@@ -2944,31 +2944,31 @@
     }
     return tmp;
   };
-  protoOf(RuleNode).e1j = function (clause) {
-    var tmp0_safe_receiver = this.r1o_1.h2(nestedFunctor_1(this, clause));
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1j(clause);
+  protoOf(RuleNode).j1l = function (clause) {
+    var tmp0_safe_receiver = this.w1q_1.h2(nestedFunctor_1(this, clause));
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j1l(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(RuleNode).u1k = function () {
-    return asSequence(this.s1o_1.e2());
+  protoOf(RuleNode).z1m = function () {
+    return asSequence(this.x1q_1.e2());
   };
-  protoOf(RuleNode).v1k = function () {
-    this.s1o_1.ap();
+  protoOf(RuleNode).a1n = function () {
+    this.x1q_1.ap();
   };
   function selectArity($this, clause) {
-    return $this.w1o_1.h2(Utils_instance.j1l(ensureNotNull(clause.dw()), $this.v1o_1));
+    return $this.b1r_1.h2(Utils_instance.o1n(ensureNotNull(clause.dw()), $this.a1r_1));
   }
   function chooseAssertionBranch($this, clause, op) {
     // Inline function 'kotlin.let' call
-    var it = Utils_instance.j1l(ensureNotNull(clause.q1k().dw()), $this.v1o_1);
+    var it = Utils_instance.o1n(ensureNotNull(clause.v1m().dw()), $this.a1r_1);
     var tmp;
     if (it === 0) {
       // Inline function 'kotlin.collections.getOrPut' call
-      var this_0 = $this.w1o_1;
+      var this_0 = $this.b1r_1;
       var value = this_0.h2(it);
       var tmp_0;
       if (value == null) {
-        var answer = new ZeroArityReteNode($this.m1i(), $this.u1o_1);
+        var answer = new ZeroArityReteNode($this.r1k(), $this.z1q_1);
         this_0.k4(it, answer);
         tmp_0 = answer;
       } else {
@@ -2977,11 +2977,11 @@
       tmp = tmp_0;
     } else {
       // Inline function 'kotlin.collections.getOrPut' call
-      var this_1 = $this.w1o_1;
+      var this_1 = $this.b1r_1;
       var value_0 = this_1.h2(it);
       var tmp_1;
       if (value_0 == null) {
-        var answer_0 = new FamilyArityReteNode($this.m1i(), $this.u1o_1, $this.v1o_1);
+        var answer_0 = new FamilyArityReteNode($this.r1k(), $this.z1q_1, $this.a1r_1);
         this_1.k4(it, answer_0);
         tmp_1 = answer_0;
       } else {
@@ -2993,32 +2993,32 @@
   }
   function regenerateCache_4($this) {
     var tmp;
-    if ($this.u1o_1) {
+    if ($this.z1q_1) {
       var tmp_0 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_0 = $this.w1o_1.j2();
+      var this_0 = $this.b1r_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.n();
       while (_iterator__ex2g4s.q()) {
         var item = _iterator__ex2g4s.r();
-        var tmp$ret$2 = item.u1k();
+        var tmp$ret$2 = item.z1m();
         destination.l(tmp$ret$2);
       }
-      tmp = tmp_0.n1l(destination);
+      tmp = tmp_0.s1n(destination);
     } else {
       var tmp_1 = Utils_instance;
       // Inline function 'kotlin.collections.map' call
-      var this_1 = $this.w1o_1.j2();
+      var this_1 = $this.b1r_1.j2();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
       var _iterator__ex2g4s_0 = this_1.n();
       while (_iterator__ex2g4s_0.q()) {
         var item_0 = _iterator__ex2g4s_0.r();
-        var tmp$ret$5 = item_0.u1k();
+        var tmp$ret$5 = item_0.z1m();
         destination_0.l(tmp$ret$5);
       }
-      tmp = tmp_1.r1l(destination_0);
+      tmp = tmp_1.w1n(destination_0);
     }
     return dequeOf_0(tmp);
   }
@@ -3033,25 +3033,25 @@
   }
   function TopLevelFunctorReteNode(unificator, ordered, nestingLevel) {
     FunctorNode.call(this, unificator);
-    this.u1o_1 = ordered;
-    this.v1o_1 = nestingLevel;
+    this.z1q_1 = ordered;
+    this.a1r_1 = nestingLevel;
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.w1o_1 = LinkedHashMap_init_$Create$();
+    tmp.b1r_1 = LinkedHashMap_init_$Create$();
     var tmp_0 = this;
     var tmp_1 = Companion_instance_1;
-    tmp_0.x1o_1 = tmp_1.yo(TopLevelFunctorReteNode$regenerateCache$ref(this));
+    tmp_0.c1r_1 = tmp_1.yo(TopLevelFunctorReteNode$regenerateCache$ref(this));
   }
   protoOf(TopLevelFunctorReteNode).s = function () {
-    var tmp = asSequence(this.w1o_1.j2());
+    var tmp = asSequence(this.b1r_1.j2());
     return sum(map(tmp, TopLevelFunctorReteNode$_get_size_$lambda_6i36rr));
   };
-  protoOf(TopLevelFunctorReteNode).r1i = function () {
+  protoOf(TopLevelFunctorReteNode).w1k = function () {
     var tmp;
-    if (this.w1o_1.h()) {
+    if (this.b1r_1.h()) {
       tmp = true;
     } else {
-      var tmp0 = this.w1o_1.j2();
+      var tmp0 = this.b1r_1.j2();
       var tmp$ret$0;
       $l$block_0: {
         // Inline function 'kotlin.collections.all' call
@@ -3068,7 +3068,7 @@
         var _iterator__ex2g4s = tmp0.n();
         while (_iterator__ex2g4s.q()) {
           var element = _iterator__ex2g4s.r();
-          if (!element.r1i()) {
+          if (!element.w1k()) {
             tmp$ret$0 = false;
             break $l$block_0;
           }
@@ -3079,90 +3079,90 @@
     }
     return tmp;
   };
-  protoOf(TopLevelFunctorReteNode).u1i = function (clause) {
+  protoOf(TopLevelFunctorReteNode).z1k = function (clause) {
     var tmp0_safe_receiver = selectArity(this, clause);
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u1i(clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z1k(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(TopLevelFunctorReteNode).s1k = function (clause) {
-    var tmp = clause.z1l(this);
+  protoOf(TopLevelFunctorReteNode).x1m = function (clause) {
+    var tmp = clause.e1o(this);
     chooseAssertionBranch(this, tmp, ReteNode$assertA$ref());
   };
-  protoOf(TopLevelFunctorReteNode).t1k = function (clause) {
-    var tmp = clause.z1l(this);
+  protoOf(TopLevelFunctorReteNode).y1m = function (clause) {
+    var tmp = clause.e1o(this);
     chooseAssertionBranch(this, tmp, ReteNode$assertZ$ref());
   };
-  protoOf(TopLevelFunctorReteNode).c1j = function (clause) {
+  protoOf(TopLevelFunctorReteNode).h1l = function (clause) {
     var tmp0_safe_receiver = selectArity(this, clause);
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1j(clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.h1l(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(TopLevelFunctorReteNode).e1j = function (clause) {
+  protoOf(TopLevelFunctorReteNode).j1l = function (clause) {
     var tmp0_safe_receiver = selectArity(this, clause);
-    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.e1j(clause);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j1l(clause);
     return tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs;
   };
-  protoOf(TopLevelFunctorReteNode).u1k = function () {
-    return asSequence(this.x1o_1.e2());
+  protoOf(TopLevelFunctorReteNode).z1m = function () {
+    return asSequence(this.c1r_1.e2());
   };
-  protoOf(TopLevelFunctorReteNode).v1k = function () {
-    this.x1o_1.ap();
+  protoOf(TopLevelFunctorReteNode).a1n = function () {
+    this.c1r_1.ap();
   };
   function ZeroArityReteNode$retractFirst$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function ZeroArityReteNode$get$lambda(this$0, $clause) {
     return function (it) {
-      return this$0.m1i().match(it.q1k(), $clause);
+      return this$0.r1k().match($clause, it.v1m());
     };
   }
   function ZeroArityReteNode$get$lambda_0(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function ZeroArityReteNode$retractAll$lambda(it) {
-    return it.q1k();
+    return it.v1m();
   }
   function ZeroArityReteNode(unificator, ordered) {
     ArityNode.call(this, unificator);
-    this.z1o_1 = ordered;
-    this.a1p_1 = dequeOf([]);
+    this.e1r_1 = ordered;
+    this.f1r_1 = dequeOf([]);
   }
-  protoOf(ZeroArityReteNode).c1j = function (clause) {
-    var tmp = this.r1k(this.a1p_1, clause);
+  protoOf(ZeroArityReteNode).h1l = function (clause) {
+    var tmp = this.w1m(this.f1r_1, clause);
     return buffered(take(map(tmp, ZeroArityReteNode$retractFirst$lambda), 1));
   };
   protoOf(ZeroArityReteNode).s = function () {
-    return this.a1p_1.s();
+    return this.f1r_1.s();
   };
-  protoOf(ZeroArityReteNode).r1i = function () {
-    return this.a1p_1.h();
+  protoOf(ZeroArityReteNode).w1k = function () {
+    return this.f1r_1.h();
   };
-  protoOf(ZeroArityReteNode).u1i = function (clause) {
-    var tmp = asSequence(this.a1p_1);
+  protoOf(ZeroArityReteNode).z1k = function (clause) {
+    var tmp = asSequence(this.f1r_1);
     var tmp_0 = filter(tmp, ZeroArityReteNode$get$lambda(this, clause));
     return map(tmp_0, ZeroArityReteNode$get$lambda_0);
   };
-  protoOf(ZeroArityReteNode).s1k = function (clause) {
-    if (this.z1o_1) {
-      addFirst(this.a1p_1, Companion_instance_8.h1m(clause.z1l(this), this));
+  protoOf(ZeroArityReteNode).x1m = function (clause) {
+    if (this.e1r_1) {
+      addFirst(this.f1r_1, Companion_instance_8.m1o(clause.e1o(this), this));
     } else {
-      this.t1k(clause);
+      this.y1m(clause);
     }
   };
-  protoOf(ZeroArityReteNode).t1k = function (clause) {
-    this.a1p_1.l(Companion_instance_8.h1m(clause.z1l(this), this));
+  protoOf(ZeroArityReteNode).y1m = function (clause) {
+    this.f1r_1.l(Companion_instance_8.m1o(clause.e1o(this), this));
   };
-  protoOf(ZeroArityReteNode).e1j = function (clause) {
-    var tmp = this.r1k(this.a1p_1, clause);
+  protoOf(ZeroArityReteNode).j1l = function (clause) {
+    var tmp = this.w1m(this.f1r_1, clause);
     return buffered(map(tmp, ZeroArityReteNode$retractAll$lambda));
   };
-  protoOf(ZeroArityReteNode).u1k = function () {
-    return asSequence(this.a1p_1);
+  protoOf(ZeroArityReteNode).z1m = function () {
+    return asSequence(this.f1r_1);
   };
-  protoOf(ZeroArityReteNode).v1k = function () {
+  protoOf(ZeroArityReteNode).a1n = function () {
   };
-  protoOf(ZeroArityReteNode).g1m = function (indexed) {
-    this.a1p_1.z2(indexed);
+  protoOf(ZeroArityReteNode).l1o = function (indexed) {
+    this.f1r_1.z2(indexed);
   };
   function AbstractTheory$get$lambda(it) {
     return it.castToRule();
@@ -3171,49 +3171,49 @@
     return it.castToRule();
   }
   function AbstractTheory(tags) {
-    this.b1p_1 = tags;
+    this.g1r_1 = tags;
   }
   protoOf(AbstractTheory).lr = function () {
-    return this.b1p_1;
+    return this.g1r_1;
   };
-  protoOf(AbstractTheory).c1p = function () {
+  protoOf(AbstractTheory).h1r = function () {
     return this;
   };
   protoOf(AbstractTheory).toImmutableTheory = function () {
-    return this.c1p();
+    return this.h1r();
   };
-  protoOf(AbstractTheory).d1p = function (clause) {
-    return plus_2.call(this, TheoryUtils_instance.i1j(clause));
+  protoOf(AbstractTheory).i1r = function (clause) {
+    return plus_2.call(this, TheoryUtils_instance.n1l(clause));
   };
   protoOf(AbstractTheory).plus = function (clause) {
-    return this.d1p(clause);
+    return this.i1r(clause);
   };
-  protoOf(AbstractTheory).t1i = function (clause) {
+  protoOf(AbstractTheory).y1k = function (clause) {
     return any(this.get(clause));
   };
   protoOf(AbstractTheory).contains = function (clause) {
-    return this.t1i(clause);
+    return this.y1k(clause);
   };
-  protoOf(AbstractTheory).e1p = function (head) {
-    return this.t1i(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
+  protoOf(AbstractTheory).j1r = function (head) {
+    return this.y1k(Companion_instance_2.of(head, [Companion_getInstance().anonymous()]));
   };
   protoOf(AbstractTheory).containsHead = function (head) {
-    return this.e1p(head);
+    return this.j1r(head);
   };
-  protoOf(AbstractTheory).f1p = function (indicator) {
-    return any(this.g1p(indicator));
+  protoOf(AbstractTheory).k1r = function (indicator) {
+    return any(this.l1r(indicator));
   };
   protoOf(AbstractTheory).containsIndicator = function (indicator) {
-    return this.f1p(indicator);
+    return this.k1r(indicator);
   };
-  protoOf(AbstractTheory).h1p = function (head) {
+  protoOf(AbstractTheory).m1r = 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.h1p(head);
+    return this.m1r(head);
   };
-  protoOf(AbstractTheory).g1p = function (indicator) {
+  protoOf(AbstractTheory).l1r = function (indicator) {
     // Inline function 'kotlin.require' call
     if (!indicator.nw()) {
       var message = 'The provided indicator is not well formed: ' + indicator.toString();
@@ -3240,49 +3240,49 @@
     return map(tmp_2, AbstractTheory$get$lambda_0);
   };
   protoOf(AbstractTheory).getByIndicator = function (indicator) {
-    return this.g1p(indicator);
+    return this.l1r(indicator);
   };
-  protoOf(AbstractTheory).i1p = function (indicator) {
+  protoOf(AbstractTheory).n1r = function (indicator) {
     // Inline function 'kotlin.require' call
     if (!indicator.nw()) {
       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.gy()), ensureNotNull(indicator.hy()))).j1p();
+    return this.retractAllByHead(Companion_getInstance_0().template(ensureNotNull(indicator.gy()), ensureNotNull(indicator.hy()))).o1r();
   };
   protoOf(AbstractTheory).abolish = function (indicator) {
-    return this.i1p(indicator);
+    return this.n1r(indicator);
   };
   protoOf(AbstractTheory).toString = function () {
-    return '' + getKClassFromExpression(this).b9() + '{ ' + joinToString(this.w1i(), '. ') + ' }';
+    return '' + getKClassFromExpression(this).b9() + '{ ' + joinToString(this.b1l(), '. ') + ' }';
   };
-  protoOf(AbstractTheory).k1p = function (asPrologText) {
+  protoOf(AbstractTheory).p1r = function (asPrologText) {
     var tmp;
     if (asPrologText) {
-      tmp = joinToString(this.w1i(), '.\n', '', '.\n');
+      tmp = joinToString(this.b1l(), '.\n', '', '.\n');
     } else {
       tmp = this.toString();
     }
     return tmp;
   };
   protoOf(AbstractTheory).toStringAsProlog = function (asPrologText) {
-    return this.k1p(asPrologText);
+    return this.p1r(asPrologText);
   };
   protoOf(AbstractTheory).n = function () {
-    return this.w1i().n();
+    return this.b1l().n();
   };
   protoOf(AbstractTheory).equals = function (other) {
     if (other == null)
       return false;
     if (!isInterface(other, Theory))
       return false;
-    return this.l1p(other, true);
+    return this.q1r(other, true);
   };
-  protoOf(AbstractTheory).l1p = function (other, useVarCompleteName) {
+  protoOf(AbstractTheory).q1r = function (other, useVarCompleteName) {
     if (this === other)
       return true;
-    var i = this.w1i().n();
-    var j = other.w1i().n();
+    var i = this.b1l().n();
+    var j = other.b1l().n();
     while (i.q() && j.q()) {
       if (!i.r().equalsUsingVarCompleteNames(j.r(), useVarCompleteName)) {
         return false;
@@ -3291,7 +3291,7 @@
     return i.q() === j.q();
   };
   protoOf(AbstractTheory).equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
-    return this.l1p(other, useVarCompleteName);
+    return this.q1r(other, useVarCompleteName);
   };
   protoOf(AbstractTheory).hashCode = function () {
     // Inline function 'kotlin.hashCode' call
@@ -3299,7 +3299,7 @@
     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.w1i().n();
+    var _iterator__ex2g4s = this.b1l().n();
     while (_iterator__ex2g4s.q()) {
       var clause = _iterator__ex2g4s.r();
       result = imul(31, result) + clause.hashCode() | 0;
@@ -3316,143 +3316,143 @@
     }
     return i;
   };
-  protoOf(AbstractTheory).r1i = function () {
-    return !this.m1p();
+  protoOf(AbstractTheory).w1k = function () {
+    return !this.r1r();
   };
-  protoOf(AbstractTheory).m1p = function () {
+  protoOf(AbstractTheory).r1r = function () {
     return this.n().q();
   };
-  protoOf(AbstractTheory).n1p = function (unificator) {
+  protoOf(AbstractTheory).s1r = function (unificator) {
     var tmp;
-    if (!equals(unificator, this.m1i())) {
-      tmp = this.o1p(asSequence(this.w1i()), VOID, unificator);
+    if (!equals(unificator, this.r1k())) {
+      tmp = this.t1r(asSequence(this.b1l()), VOID, unificator);
     } else {
       tmp = this;
     }
     return tmp;
   };
   protoOf(AbstractTheory).setUnificator = function (unificator) {
-    return this.n1p(unificator);
+    return this.s1r(unificator);
   };
-  protoOf(AbstractTheory).p1p = function (theory) {
+  protoOf(AbstractTheory).u1r = function (theory) {
     var tmp;
-    if (theory.m1p()) {
-      tmp = this.o1p(plus_0(asSequence(this.w1i()), TheoryUtils_instance.q1p(asSequence(theory.w1i()))));
+    if (theory.r1r()) {
+      tmp = this.t1r(plus_0(asSequence(this.b1l()), TheoryUtils_instance.v1r(asSequence(theory.b1l()))));
     } else {
       tmp = this;
     }
     return tmp;
   };
   protoOf(AbstractTheory).plusTheory = function (theory) {
-    return this.p1p(theory);
+    return this.u1r(theory);
   };
-  protoOf(AbstractTheory).r1p = function (clause) {
-    return this.o1p(plus_0(TheoryUtils_instance.s1p([clause]), asSequence(this.w1i())));
+  protoOf(AbstractTheory).w1r = function (clause) {
+    return this.t1r(plus_0(TheoryUtils_instance.x1r([clause]), asSequence(this.b1l())));
   };
   protoOf(AbstractTheory).assertA = function (clause) {
-    return this.r1p(clause);
+    return this.w1r(clause);
   };
-  protoOf(AbstractTheory).t1p = function (clauses) {
-    return this.o1p(plus_0(TheoryUtils_instance.q1p(asSequence(clauses)), asSequence(this.w1i())));
+  protoOf(AbstractTheory).y1r = function (clauses) {
+    return this.t1r(plus_0(TheoryUtils_instance.v1r(asSequence(clauses)), asSequence(this.b1l())));
   };
   protoOf(AbstractTheory).assertAIterable = function (clauses) {
-    return this.t1p(clauses);
+    return this.y1r(clauses);
   };
-  protoOf(AbstractTheory).u1p = function (clauses) {
-    return this.o1p(plus_0(TheoryUtils_instance.q1p(clauses), asSequence(this.w1i())));
+  protoOf(AbstractTheory).z1r = function (clauses) {
+    return this.t1r(plus_0(TheoryUtils_instance.v1r(clauses), asSequence(this.b1l())));
   };
   protoOf(AbstractTheory).assertASequence = function (clauses) {
-    return this.u1p(clauses);
+    return this.z1r(clauses);
   };
-  protoOf(AbstractTheory).v1p = function (clause) {
-    return this.o1p(plus_0(asSequence(this.w1i()), TheoryUtils_instance.q1p(sequenceOf_0(clause))));
+  protoOf(AbstractTheory).a1s = function (clause) {
+    return this.t1r(plus_0(asSequence(this.b1l()), TheoryUtils_instance.v1r(sequenceOf_0(clause))));
   };
   protoOf(AbstractTheory).assertZ = function (clause) {
-    return this.v1p(clause);
+    return this.a1s(clause);
   };
-  protoOf(AbstractTheory).w1p = function (clauses) {
-    return this.o1p(plus_0(asSequence(this.w1i()), asSequence(TheoryUtils_instance.t1j(clauses))));
+  protoOf(AbstractTheory).b1s = function (clauses) {
+    return this.t1r(plus_0(asSequence(this.b1l()), asSequence(TheoryUtils_instance.y1l(clauses))));
   };
   protoOf(AbstractTheory).assertZIterable = function (clauses) {
-    return this.w1p(clauses);
+    return this.b1s(clauses);
   };
-  protoOf(AbstractTheory).x1p = function (clauses) {
-    return this.o1p(plus_0(asSequence(this.w1i()), TheoryUtils_instance.q1p(clauses)));
+  protoOf(AbstractTheory).c1s = function (clauses) {
+    return this.t1r(plus_0(asSequence(this.b1l()), TheoryUtils_instance.v1r(clauses)));
   };
   protoOf(AbstractTheory).assertZSequence = function (clauses) {
-    return this.x1p(clauses);
+    return this.c1s(clauses);
   };
-  protoOf(AbstractTheory).o1p = function (clauses, tags, unificator, $super) {
+  protoOf(AbstractTheory).t1r = function (clauses, tags, unificator, $super) {
     tags = tags === VOID ? this.lr() : tags;
-    unificator = unificator === VOID ? this.m1i() : unificator;
-    return $super === VOID ? this.y1p(clauses, tags, unificator) : $super.y1p.call(this, clauses, tags, unificator);
+    unificator = unificator === VOID ? this.r1k() : unificator;
+    return $super === VOID ? this.d1s(clauses, tags, unificator) : $super.d1s.call(this, clauses, tags, unificator);
   };
-  protoOf(AbstractTheory).z1p = function (clauses) {
-    return this.a1q(asIterable(clauses));
+  protoOf(AbstractTheory).e1s = function (clauses) {
+    return this.f1s(asIterable(clauses));
   };
   protoOf(AbstractTheory).retractSequence = function (clauses) {
-    return this.z1p(clauses);
+    return this.e1s(clauses);
   };
-  protoOf(AbstractTheory).b1q = function () {
+  protoOf(AbstractTheory).g1s = function () {
     return this;
   };
   protoOf(AbstractTheory).clone = function () {
-    return this.b1q();
+    return this.g1s();
   };
   function Default() {
     Default_instance = this;
-    this.d1q_1 = new IndexedTheoryFactory(Companion_getInstance_1().f1i());
+    this.i1s_1 = new IndexedTheoryFactory(Companion_getInstance_1().k1k());
   }
   protoOf(Default).emptyTheoryWithUnificator = function (unificator) {
-    return this.d1q_1.f1q(unificator);
+    return this.i1s_1.k1s(unificator);
   };
   protoOf(Default).emptyTheory = function () {
-    return this.d1q_1.emptyTheory();
+    return this.i1s_1.emptyTheory();
   };
   protoOf(Default).theoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.d1q_1.g1q(clauses, unificator);
+    return this.i1s_1.l1s(clauses, unificator);
   };
   protoOf(Default).theoryOfIterable = function (clauses) {
-    return this.d1q_1.theoryOfIterable(clauses);
+    return this.i1s_1.theoryOfIterable(clauses);
   };
   protoOf(Default).theoryOfWithUnificator = function (unificator, clauses) {
-    return this.d1q_1.h1q(unificator, clauses);
+    return this.i1s_1.m1s(unificator, clauses);
   };
   protoOf(Default).theoryOf = function (clauses) {
-    return this.d1q_1.theoryOf(clauses);
+    return this.i1s_1.theoryOf(clauses);
   };
   protoOf(Default).theoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.d1q_1.i1q(clauses, unificator);
+    return this.i1s_1.n1s(clauses, unificator);
   };
   protoOf(Default).theoryOfSequence = function (clauses) {
-    return this.d1q_1.theoryOfSequence(clauses);
+    return this.i1s_1.theoryOfSequence(clauses);
   };
   protoOf(Default).emptyMutableTheoryWithUnificator = function (unificator) {
-    return this.d1q_1.j1q(unificator);
+    return this.i1s_1.o1s(unificator);
   };
   protoOf(Default).emptyMutableTheory = function () {
-    return this.d1q_1.emptyMutableTheory();
+    return this.i1s_1.emptyMutableTheory();
   };
   protoOf(Default).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.d1q_1.k1q(clauses, unificator);
+    return this.i1s_1.p1s(clauses, unificator);
   };
   protoOf(Default).mutableTheoryOfIterable = function (clauses) {
-    return this.d1q_1.mutableTheoryOfIterable(clauses);
+    return this.i1s_1.mutableTheoryOfIterable(clauses);
   };
   protoOf(Default).mutableTheoryOfWithUnificator = function (unificator, clauses) {
-    return this.d1q_1.l1q(unificator, clauses);
+    return this.i1s_1.q1s(unificator, clauses);
   };
   protoOf(Default).mutableTheoryOf = function (clauses) {
-    return this.d1q_1.mutableTheoryOf(clauses);
+    return this.i1s_1.mutableTheoryOf(clauses);
   };
   protoOf(Default).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.d1q_1.m1q(clauses, unificator);
+    return this.i1s_1.r1s(clauses, unificator);
   };
   protoOf(Default).mutableTheoryOfSequence = function (clauses) {
-    return this.d1q_1.mutableTheoryOfSequence(clauses);
+    return this.i1s_1.mutableTheoryOfSequence(clauses);
   };
-  protoOf(Default).m1i = function () {
-    return this.d1q_1.e1q_1;
+  protoOf(Default).r1k = function () {
+    return this.i1s_1.j1s_1;
   };
   var Default_instance;
   function Default_getInstance() {
@@ -3461,113 +3461,113 @@
     return Default_instance;
   }
   function IndexedTheoryFactory(unificator) {
-    this.e1q_1 = unificator;
+    this.j1s_1 = unificator;
   }
-  protoOf(IndexedTheoryFactory).m1i = function () {
-    return this.e1q_1;
+  protoOf(IndexedTheoryFactory).r1k = function () {
+    return this.j1s_1;
   };
-  protoOf(IndexedTheoryFactory).f1q = function (unificator) {
+  protoOf(IndexedTheoryFactory).k1s = function (unificator) {
     return IndexedTheory_init_$Create$(unificator, emptyList());
   };
   protoOf(IndexedTheoryFactory).emptyTheoryWithUnificator = function (unificator) {
-    return this.f1q(unificator);
+    return this.k1s(unificator);
   };
-  protoOf(IndexedTheoryFactory).g1q = function (clauses, unificator) {
+  protoOf(IndexedTheoryFactory).l1s = function (clauses, unificator) {
     return IndexedTheory_init_$Create$(unificator, clauses);
   };
   protoOf(IndexedTheoryFactory).theoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.g1q(clauses, unificator);
+    return this.l1s(clauses, unificator);
   };
-  protoOf(IndexedTheoryFactory).h1q = function (unificator, clauses) {
+  protoOf(IndexedTheoryFactory).m1s = function (unificator, clauses) {
     return IndexedTheory_init_$Create$(unificator, asIterable_0(clauses));
   };
   protoOf(IndexedTheoryFactory).theoryOfWithUnificator = function (unificator, clauses) {
-    return this.h1q(unificator, clauses);
+    return this.m1s(unificator, clauses);
   };
-  protoOf(IndexedTheoryFactory).i1q = function (clauses, unificator) {
+  protoOf(IndexedTheoryFactory).n1s = function (clauses, unificator) {
     return IndexedTheory_init_$Create$_0(unificator, clauses);
   };
   protoOf(IndexedTheoryFactory).theoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.i1q(clauses, unificator);
+    return this.n1s(clauses, unificator);
   };
-  protoOf(IndexedTheoryFactory).j1q = function (unificator) {
+  protoOf(IndexedTheoryFactory).o1s = function (unificator) {
     return MutableIndexedTheory_init_$Create$(unificator, emptyList());
   };
   protoOf(IndexedTheoryFactory).emptyMutableTheoryWithUnificator = function (unificator) {
-    return this.j1q(unificator);
+    return this.o1s(unificator);
   };
-  protoOf(IndexedTheoryFactory).k1q = function (clauses, unificator) {
+  protoOf(IndexedTheoryFactory).p1s = function (clauses, unificator) {
     return MutableIndexedTheory_init_$Create$(unificator, clauses);
   };
   protoOf(IndexedTheoryFactory).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.k1q(clauses, unificator);
+    return this.p1s(clauses, unificator);
   };
-  protoOf(IndexedTheoryFactory).l1q = function (unificator, clauses) {
+  protoOf(IndexedTheoryFactory).q1s = function (unificator, clauses) {
     return MutableIndexedTheory_init_$Create$(unificator, asIterable_0(clauses));
   };
   protoOf(IndexedTheoryFactory).mutableTheoryOfWithUnificator = function (unificator, clauses) {
-    return this.l1q(unificator, clauses);
+    return this.q1s(unificator, clauses);
   };
-  protoOf(IndexedTheoryFactory).m1q = function (clauses, unificator) {
+  protoOf(IndexedTheoryFactory).r1s = function (clauses, unificator) {
     return MutableIndexedTheory_init_$Create$_0(unificator, clauses);
   };
   protoOf(IndexedTheoryFactory).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.m1q(clauses, unificator);
+    return this.r1s(clauses, unificator);
   };
   function Default_0() {
     Default_instance_0 = this;
-    this.n1q_1 = new ListedTheoryFactory(Companion_getInstance_1().f1i());
+    this.s1s_1 = new ListedTheoryFactory(Companion_getInstance_1().k1k());
   }
   protoOf(Default_0).emptyTheoryWithUnificator = function (unificator) {
-    return this.n1q_1.f1q(unificator);
+    return this.s1s_1.k1s(unificator);
   };
   protoOf(Default_0).emptyTheory = function () {
-    return this.n1q_1.emptyTheory();
+    return this.s1s_1.emptyTheory();
   };
   protoOf(Default_0).theoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.n1q_1.g1q(clauses, unificator);
+    return this.s1s_1.l1s(clauses, unificator);
   };
   protoOf(Default_0).theoryOfIterable = function (clauses) {
-    return this.n1q_1.theoryOfIterable(clauses);
+    return this.s1s_1.theoryOfIterable(clauses);
   };
   protoOf(Default_0).theoryOfWithUnificator = function (unificator, clauses) {
-    return this.n1q_1.h1q(unificator, clauses);
+    return this.s1s_1.m1s(unificator, clauses);
   };
   protoOf(Default_0).theoryOf = function (clauses) {
-    return this.n1q_1.theoryOf(clauses);
+    return this.s1s_1.theoryOf(clauses);
   };
   protoOf(Default_0).theoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.n1q_1.i1q(clauses, unificator);
+    return this.s1s_1.n1s(clauses, unificator);
   };
   protoOf(Default_0).theoryOfSequence = function (clauses) {
-    return this.n1q_1.theoryOfSequence(clauses);
+    return this.s1s_1.theoryOfSequence(clauses);
   };
   protoOf(Default_0).emptyMutableTheoryWithUnificator = function (unificator) {
-    return this.n1q_1.j1q(unificator);
+    return this.s1s_1.o1s(unificator);
   };
   protoOf(Default_0).emptyMutableTheory = function () {
-    return this.n1q_1.emptyMutableTheory();
+    return this.s1s_1.emptyMutableTheory();
   };
   protoOf(Default_0).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.n1q_1.k1q(clauses, unificator);
+    return this.s1s_1.p1s(clauses, unificator);
   };
   protoOf(Default_0).mutableTheoryOfIterable = function (clauses) {
-    return this.n1q_1.mutableTheoryOfIterable(clauses);
+    return this.s1s_1.mutableTheoryOfIterable(clauses);
   };
   protoOf(Default_0).mutableTheoryOfWithUnificator = function (unificator, clauses) {
-    return this.n1q_1.l1q(unificator, clauses);
+    return this.s1s_1.q1s(unificator, clauses);
   };
   protoOf(Default_0).mutableTheoryOf = function (clauses) {
-    return this.n1q_1.mutableTheoryOf(clauses);
+    return this.s1s_1.mutableTheoryOf(clauses);
   };
   protoOf(Default_0).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.n1q_1.m1q(clauses, unificator);
+    return this.s1s_1.r1s(clauses, unificator);
   };
   protoOf(Default_0).mutableTheoryOfSequence = function (clauses) {
-    return this.n1q_1.mutableTheoryOfSequence(clauses);
+    return this.s1s_1.mutableTheoryOfSequence(clauses);
   };
-  protoOf(Default_0).m1i = function () {
-    return this.n1q_1.o1q_1;
+  protoOf(Default_0).r1k = function () {
+    return this.s1s_1.t1s_1;
   };
   var Default_instance_0;
   function Default_getInstance_0() {
@@ -3576,58 +3576,58 @@
     return Default_instance_0;
   }
   function ListedTheoryFactory(unificator) {
-    this.o1q_1 = unificator;
+    this.t1s_1 = unificator;
   }
-  protoOf(ListedTheoryFactory).m1i = function () {
-    return this.o1q_1;
+  protoOf(ListedTheoryFactory).r1k = function () {
+    return this.t1s_1;
   };
-  protoOf(ListedTheoryFactory).f1q = function (unificator) {
+  protoOf(ListedTheoryFactory).k1s = function (unificator) {
     return ListedTheory_init_$Create$(unificator, emptyList());
   };
   protoOf(ListedTheoryFactory).emptyTheoryWithUnificator = function (unificator) {
-    return this.f1q(unificator);
+    return this.k1s(unificator);
   };
-  protoOf(ListedTheoryFactory).g1q = function (clauses, unificator) {
+  protoOf(ListedTheoryFactory).l1s = function (clauses, unificator) {
     return ListedTheory_init_$Create$(unificator, clauses);
   };
   protoOf(ListedTheoryFactory).theoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.g1q(clauses, unificator);
+    return this.l1s(clauses, unificator);
   };
-  protoOf(ListedTheoryFactory).h1q = function (unificator, clauses) {
+  protoOf(ListedTheoryFactory).m1s = function (unificator, clauses) {
     return ListedTheory_init_$Create$(unificator, asIterable_0(clauses));
   };
   protoOf(ListedTheoryFactory).theoryOfWithUnificator = function (unificator, clauses) {
-    return this.h1q(unificator, clauses);
+    return this.m1s(unificator, clauses);
   };
-  protoOf(ListedTheoryFactory).i1q = function (clauses, unificator) {
+  protoOf(ListedTheoryFactory).n1s = function (clauses, unificator) {
     return ListedTheory_init_$Create$_0(unificator, clauses);
   };
   protoOf(ListedTheoryFactory).theoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.i1q(clauses, unificator);
+    return this.n1s(clauses, unificator);
   };
-  protoOf(ListedTheoryFactory).j1q = function (unificator) {
+  protoOf(ListedTheoryFactory).o1s = function (unificator) {
     return MutableListedTheory_init_$Create$(unificator, emptyList());
   };
   protoOf(ListedTheoryFactory).emptyMutableTheoryWithUnificator = function (unificator) {
-    return this.j1q(unificator);
+    return this.o1s(unificator);
   };
-  protoOf(ListedTheoryFactory).k1q = function (clauses, unificator) {
+  protoOf(ListedTheoryFactory).p1s = function (clauses, unificator) {
     return MutableListedTheory_init_$Create$(unificator, clauses);
   };
   protoOf(ListedTheoryFactory).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.k1q(clauses, unificator);
+    return this.p1s(clauses, unificator);
   };
-  protoOf(ListedTheoryFactory).l1q = function (unificator, clauses) {
+  protoOf(ListedTheoryFactory).q1s = function (unificator, clauses) {
     return MutableListedTheory_init_$Create$(unificator, asIterable_0(clauses));
   };
   protoOf(ListedTheoryFactory).mutableTheoryOfWithUnificator = function (unificator, clauses) {
-    return this.l1q(unificator, clauses);
+    return this.q1s(unificator, clauses);
   };
-  protoOf(ListedTheoryFactory).m1q = function (clauses, unificator) {
+  protoOf(ListedTheoryFactory).r1s = function (clauses, unificator) {
     return MutableListedTheory_init_$Create$_0(unificator, clauses);
   };
   protoOf(ListedTheoryFactory).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.m1q(clauses, unificator);
+    return this.r1s(clauses, unificator);
   };
   function Companion_4() {
   }
@@ -3706,24 +3706,24 @@
   }
   function Success_0(theory, clauses) {
     RetractResult.call(this);
-    this.v1q_1 = theory;
-    this.w1q_1 = clauses;
+    this.a1t_1 = theory;
+    this.b1t_1 = clauses;
   }
-  protoOf(Success_0).j1p = function () {
-    return this.v1q_1;
+  protoOf(Success_0).o1r = function () {
+    return this.a1t_1;
   };
-  protoOf(Success_0).w1i = function () {
-    return this.w1q_1;
+  protoOf(Success_0).b1l = function () {
+    return this.b1t_1;
   };
-  protoOf(Success_0).p1j = function () {
-    return first_0(this.w1q_1);
+  protoOf(Success_0).u1l = function () {
+    return first_0(this.b1t_1);
   };
   protoOf(Success_0).toString = function () {
-    return 'Success(theory=' + toString(this.v1q_1) + ', clauses=' + toString(this.w1q_1) + ')';
+    return 'Success(theory=' + toString(this.a1t_1) + ', clauses=' + toString(this.b1t_1) + ')';
   };
   protoOf(Success_0).hashCode = function () {
-    var result = hashCode(this.v1q_1);
-    result = imul(result, 31) + hashCode(this.w1q_1) | 0;
+    var result = hashCode(this.a1t_1);
+    result = imul(result, 31) + hashCode(this.b1t_1) | 0;
     return result;
   };
   protoOf(Success_0).equals = function (other) {
@@ -3731,37 +3731,37 @@
       return true;
     if (!(other instanceof Success_0))
       return false;
-    if (!equals(this.v1q_1, other.v1q_1))
+    if (!equals(this.a1t_1, other.a1t_1))
       return false;
-    if (!equals(this.w1q_1, other.w1q_1))
+    if (!equals(this.b1t_1, other.b1t_1))
       return false;
     return true;
   };
   function Failure_0(theory) {
     RetractResult.call(this);
-    this.x1q_1 = theory;
+    this.c1t_1 = theory;
   }
-  protoOf(Failure_0).j1p = function () {
-    return this.x1q_1;
+  protoOf(Failure_0).o1r = function () {
+    return this.c1t_1;
   };
-  protoOf(Failure_0).w1i = function () {
+  protoOf(Failure_0).b1l = function () {
     return null;
   };
-  protoOf(Failure_0).p1j = function () {
+  protoOf(Failure_0).u1l = function () {
     return null;
   };
   protoOf(Failure_0).toString = function () {
-    return 'Failure(theory=' + toString(this.x1q_1) + ')';
+    return 'Failure(theory=' + toString(this.c1t_1) + ')';
   };
   protoOf(Failure_0).hashCode = function () {
-    return hashCode(this.x1q_1);
+    return hashCode(this.c1t_1);
   };
   protoOf(Failure_0).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Failure_0))
       return false;
-    if (!equals(this.x1q_1, other.x1q_1))
+    if (!equals(this.c1t_1, other.c1t_1))
       return false;
     return true;
   };
@@ -3773,31 +3773,31 @@
     return this.indexedOfSequence(unificator, emptySequence());
   };
   protoOf(Companion_5).emptyWithDefaultUnificator = function () {
-    return this.empty(Companion_getInstance_1().f1i());
+    return this.empty(Companion_getInstance_1().k1k());
   };
   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().f1i(), clause.slice());
+    return this.indexedOf(Companion_getInstance_1().k1k(), 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().f1i(), clauses);
+    return this.indexedOfIterable(Companion_getInstance_1().k1k(), 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().f1i(), clauses);
+    return this.indexedOfSequence(Companion_getInstance_1().k1k(), 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().f1i(), clauses.slice());
+    return this.indexedOfScopes(Companion_getInstance_1().k1k(), clauses.slice());
   };
   protoOf(Companion_5).emptyIndexed = function (unificator) {
     return this.indexedOfIterable(unificator, emptyList());
@@ -3890,7 +3890,7 @@
   }
   function TheoryUtils() {
   }
-  protoOf(TheoryUtils).i1j = function (clause) {
+  protoOf(TheoryUtils).n1l = function (clause) {
     // Inline function 'kotlin.also' call
     // Inline function 'kotlin.require' call
     if (!clause.nw()) {
@@ -3899,18 +3899,18 @@
     }
     return clause;
   };
-  protoOf(TheoryUtils).s1p = function (clauses) {
+  protoOf(TheoryUtils).x1r = function (clauses) {
     // Inline function 'kotlin.also' call
     var this_0 = asSequence_0(clauses);
     actualCheck(TheoryUtils_instance, this_0);
     return this_0;
   };
-  protoOf(TheoryUtils).t1j = function (clauses) {
+  protoOf(TheoryUtils).y1l = function (clauses) {
     // Inline function 'kotlin.also' call
     actualCheck(TheoryUtils_instance, asSequence(clauses));
     return clauses;
   };
-  protoOf(TheoryUtils).q1p = function (clauses) {
+  protoOf(TheoryUtils).v1r = function (clauses) {
     // Inline function 'kotlin.also' call
     actualCheck(TheoryUtils_instance, clauses);
     return clauses;
@@ -3920,81 +3920,81 @@
     return TheoryUtils_instance;
   }
   function AbstractIndexedTheory$clauses$$inlined$Iterable$1(this$0) {
-    this.y1q_1 = this$0;
+    this.d1t_1 = this$0;
   }
   protoOf(AbstractIndexedTheory$clauses$$inlined$Iterable$1).n = function () {
-    return this.y1q_1.b1r().n();
+    return this.d1t_1.g1t().n();
   };
   function AbstractIndexedTheory(queue, tags) {
     AbstractTheory.call(this, tags);
-    this.a1r_1 = queue;
+    this.f1t_1 = queue;
   }
-  protoOf(AbstractIndexedTheory).m1i = function () {
-    return this.b1r().m1i();
+  protoOf(AbstractIndexedTheory).r1k = function () {
+    return this.g1t().r1k();
   };
-  protoOf(AbstractIndexedTheory).b1r = function () {
-    return this.a1r_1;
+  protoOf(AbstractIndexedTheory).g1t = function () {
+    return this.f1t_1;
   };
-  protoOf(AbstractIndexedTheory).p1i = function () {
-    return this.b1r().o1i();
+  protoOf(AbstractIndexedTheory).u1k = function () {
+    return this.g1t().t1k();
   };
-  protoOf(AbstractIndexedTheory).q1i = function () {
-    return this.b1r().q1i();
+  protoOf(AbstractIndexedTheory).v1k = function () {
+    return this.g1t().v1k();
   };
-  protoOf(AbstractIndexedTheory).w1i = function () {
+  protoOf(AbstractIndexedTheory).b1l = function () {
     // Inline function 'kotlin.collections.Iterable' call
     return new AbstractIndexedTheory$clauses$$inlined$Iterable$1(this);
   };
-  protoOf(AbstractIndexedTheory).u1i = function (clause) {
-    return this.b1r().u1i(clause);
+  protoOf(AbstractIndexedTheory).z1k = function (clause) {
+    return this.g1t().z1k(clause);
   };
   protoOf(AbstractIndexedTheory).get = function (clause) {
-    return this.u1i(clause);
+    return this.z1k(clause);
   };
   protoOf(AbstractIndexedTheory).s = function () {
-    return fromInt(this.b1r().s());
+    return fromInt(this.g1t().s());
   };
-  protoOf(AbstractIndexedTheory).r1i = function () {
-    return this.b1r().isEmpty();
+  protoOf(AbstractIndexedTheory).w1k = function () {
+    return this.g1t().isEmpty();
   };
-  protoOf(AbstractIndexedTheory).m1p = function () {
-    return !this.r1i();
+  protoOf(AbstractIndexedTheory).r1r = function () {
+    return !this.w1k();
   };
   function AbstractListedTheory(unificator, clauses, tags) {
     AbstractTheory.call(this, tags);
-    this.d1r_1 = clauses;
-    this.e1r_1 = unificator;
+    this.i1t_1 = clauses;
+    this.j1t_1 = unificator;
   }
-  protoOf(AbstractListedTheory).w1i = function () {
-    return this.d1r_1;
+  protoOf(AbstractListedTheory).b1l = function () {
+    return this.i1t_1;
   };
-  protoOf(AbstractListedTheory).f1r = function (_set____db54di) {
-    this.e1r_1 = _set____db54di;
+  protoOf(AbstractListedTheory).k1t = function (_set____db54di) {
+    this.j1t_1 = _set____db54di;
   };
-  protoOf(AbstractListedTheory).m1i = function () {
-    return this.e1r_1;
+  protoOf(AbstractListedTheory).r1k = function () {
+    return this.j1t_1;
   };
-  protoOf(AbstractListedTheory).u1i = function (clause) {
+  protoOf(AbstractListedTheory).z1k = function (clause) {
     // Inline function 'kotlin.collections.filter' call
-    var tmp0 = this.w1i();
+    var tmp0 = this.b1l();
     // Inline function 'kotlin.collections.filterTo' call
     var destination = ArrayList_init_$Create$_0();
     var _iterator__ex2g4s = tmp0.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      if (this.m1i().match(element, clause)) {
+      if (this.r1k().match(clause, element)) {
         destination.l(element);
       }
     }
     return asSequence(destination);
   };
   protoOf(AbstractListedTheory).get = function (clause) {
-    return this.u1i(clause);
+    return this.z1k(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.t1j(clauses);
+    TheoryUtils_instance.y1l(clauses);
     return $this;
   }
   function IndexedTheory_init_$Create$(unificator, clauses, tags) {
@@ -4009,14 +4009,14 @@
     return IndexedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(IndexedTheory)));
   }
   function _get_hashCodeCache__ny3r0q_0($this) {
-    var tmp0 = $this.i1r_1;
+    var tmp0 = $this.n1t_1;
     var tmp = KProperty1;
     // Inline function 'kotlin.getValue' call
     getPropertyCallableRef('hashCodeCache', 1, tmp, IndexedTheory$_get_hashCodeCache_$ref_4wtmhh(), null);
     return tmp0.e2();
   }
   function _get_sizeCache__6eswog($this) {
-    var tmp0 = $this.j1r_1;
+    var tmp0 = $this.o1t_1;
     var tmp = KProperty1;
     // Inline function 'kotlin.getValue' call
     getPropertyCallableRef('sizeCache', 1, tmp, IndexedTheory$_get_sizeCache_$ref_fqi1u9(), null);
@@ -4045,42 +4045,42 @@
   function IndexedTheory(queue, tags) {
     AbstractIndexedTheory.call(this, queue, tags);
     var tmp = this;
-    tmp.i1r_1 = lazy(IndexedTheory$hashCodeCache$delegate$lambda(this));
+    tmp.n1t_1 = lazy(IndexedTheory$hashCodeCache$delegate$lambda(this));
     var tmp_0 = this;
-    tmp_0.j1r_1 = lazy(IndexedTheory$sizeCache$delegate$lambda(this));
+    tmp_0.o1t_1 = lazy(IndexedTheory$sizeCache$delegate$lambda(this));
   }
-  protoOf(IndexedTheory).y1p = function (clauses, tags, unificator) {
+  protoOf(IndexedTheory).d1s = function (clauses, tags, unificator) {
     return IndexedTheory_init_$Create$_0(unificator, clauses, tags);
   };
-  protoOf(IndexedTheory).s1q = function (clause) {
-    var newTheory = Companion_instance_4.ofIterable(this.m1i(), this.w1i());
+  protoOf(IndexedTheory).x1s = function (clause) {
+    var newTheory = Companion_instance_4.ofIterable(this.r1k(), this.b1l());
     var retracted = newTheory.retrieveFirst(clause);
-    return retracted.q1j() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.o1j(), this.lr()), ensureNotNull(retracted.w1i()));
+    return retracted.v1l() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.t1l(), this.lr()), ensureNotNull(retracted.b1l()));
   };
   protoOf(IndexedTheory).retract = function (clause) {
-    return this.s1q(clause);
+    return this.x1s(clause);
   };
-  protoOf(IndexedTheory).p1p = function (theory) {
-    return this.r1i() ? theory.toImmutableTheory() : theory.r1i() ? this : protoOf(AbstractIndexedTheory).p1p.call(this, theory);
+  protoOf(IndexedTheory).u1r = function (theory) {
+    return this.w1k() ? theory.toImmutableTheory() : theory.w1k() ? this : protoOf(AbstractIndexedTheory).u1r.call(this, theory);
   };
   protoOf(IndexedTheory).plusTheory = function (theory) {
-    return this.p1p(theory);
+    return this.u1r(theory);
   };
-  protoOf(IndexedTheory).p1q = function () {
-    return Companion_instance_9.indexedOfIterable(this.m1i(), this);
+  protoOf(IndexedTheory).u1s = function () {
+    return Companion_instance_9.indexedOfIterable(this.r1k(), this);
   };
   protoOf(IndexedTheory).toMutableTheory = function () {
-    return this.p1q();
+    return this.u1s();
   };
-  protoOf(IndexedTheory).a1q = function (clauses) {
-    var newTheory = Companion_instance_5.ofIterable(this.m1i(), this.w1i());
+  protoOf(IndexedTheory).f1s = function (clauses) {
+    var newTheory = Companion_instance_5.ofIterable(this.r1k(), this.b1l());
     var removed = dequeOf([]);
     var _iterator__ex2g4s = clauses.n();
     while (_iterator__ex2g4s.q()) {
       var clause = _iterator__ex2g4s.r();
-      var result = newTheory.l1j(clause);
+      var result = newTheory.q1l(clause);
       if (result.d10()) {
-        removed.w(ensureNotNull(result.w1i()));
+        removed.w(ensureNotNull(result.b1l()));
       }
     }
     var tmp;
@@ -4092,15 +4092,15 @@
     return tmp;
   };
   protoOf(IndexedTheory).retractIterable = function (clauses) {
-    return this.a1q(clauses);
+    return this.f1s(clauses);
   };
-  protoOf(IndexedTheory).e1j = function (clause) {
-    var newTheory = Companion_instance_4.ofIterable(this.m1i(), this.w1i());
-    var retracted = newTheory.d1j(clause);
-    return retracted.q1j() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.o1j(), this.lr()), ensureNotNull(retracted.w1i()));
+  protoOf(IndexedTheory).j1l = function (clause) {
+    var newTheory = Companion_instance_4.ofIterable(this.r1k(), this.b1l());
+    var retracted = newTheory.i1l(clause);
+    return retracted.v1l() ? new Failure_0(this) : new Success_0(new IndexedTheory(retracted.t1l(), this.lr()), ensureNotNull(retracted.b1l()));
   };
   protoOf(IndexedTheory).retractAll = function (clause) {
-    return this.e1j(clause);
+    return this.j1l(clause);
   };
   protoOf(IndexedTheory).hashCode = function () {
     return _get_hashCodeCache__ny3r0q_0(this);
@@ -4113,7 +4113,7 @@
     if (tags === this.lr()) {
       tmp = this;
     } else {
-      tmp = new IndexedTheory(this.b1r(), tags);
+      tmp = new IndexedTheory(this.g1t(), tags);
     }
     return tmp;
   };
@@ -4123,7 +4123,7 @@
   function ListedTheory_init_$Init$(unificator, clauses, tags, $this) {
     tags = tags === VOID ? emptyMap() : tags;
     ListedTheory.call($this, unificator, toList_0(clauses), tags);
-    TheoryUtils_instance.t1j(clauses);
+    TheoryUtils_instance.y1l(clauses);
     return $this;
   }
   function ListedTheory_init_$Create$(unificator, clauses, tags) {
@@ -4132,21 +4132,21 @@
   function ListedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
     tags = tags === VOID ? emptyMap() : tags;
     ListedTheory.call($this, unificator, toList(clauses), tags);
-    TheoryUtils_instance.q1p(clauses);
+    TheoryUtils_instance.v1r(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.n1r_1;
+    var tmp0 = $this.s1t_1;
     var tmp = KProperty1;
     // Inline function 'kotlin.getValue' call
     getPropertyCallableRef('hashCodeCache', 1, tmp, ListedTheory$_get_hashCodeCache_$ref_jbnoxj(), null);
     return tmp0.e2();
   }
   function _get_sizeCache__6eswog_0($this) {
-    var tmp0 = $this.o1r_1;
+    var tmp0 = $this.t1t_1;
     var tmp = KProperty1;
     // Inline function 'kotlin.getValue' call
     getPropertyCallableRef('sizeCache', 1, tmp, ListedTheory$_get_sizeCache_$ref_3h5dr1(), null);
@@ -4175,22 +4175,22 @@
   function ListedTheory(unificator, clauses, tags) {
     AbstractListedTheory.call(this, unificator, clauses, tags);
     var tmp = this;
-    tmp.n1r_1 = lazy(ListedTheory$hashCodeCache$delegate$lambda(this));
+    tmp.s1t_1 = lazy(ListedTheory$hashCodeCache$delegate$lambda(this));
     var tmp_0 = this;
-    tmp_0.o1r_1 = lazy(ListedTheory$sizeCache$delegate$lambda(this));
+    tmp_0.t1t_1 = lazy(ListedTheory$sizeCache$delegate$lambda(this));
   }
-  protoOf(ListedTheory).y1p = function (clauses, tags, unificator) {
+  protoOf(ListedTheory).d1s = function (clauses, tags, unificator) {
     return ListedTheory_init_$Create$_0(unificator, clauses, tags);
   };
-  protoOf(ListedTheory).s1q = function (clause) {
+  protoOf(ListedTheory).x1s = function (clause) {
     // Inline function 'kotlin.collections.filter' call
-    var tmp0 = this.w1i();
+    var tmp0 = this.b1l();
     // Inline function 'kotlin.collections.filterTo' call
     var destination = ArrayList_init_$Create$_0();
     var _iterator__ex2g4s = tmp0.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      if (this.m1i().match(element, clause)) {
+      if (this.r1k().match(clause, element)) {
         destination.l(element);
       }
     }
@@ -4201,7 +4201,7 @@
     } else {
       var toBeActuallyRetracted = first(retractability);
       // Inline function 'kotlin.collections.filter' call
-      var tmp0_0 = this.w1i();
+      var tmp0_0 = this.b1l();
       // Inline function 'kotlin.collections.filterTo' call
       var destination_0 = ArrayList_init_$Create$_0();
       var _iterator__ex2g4s_0 = tmp0_0.n();
@@ -4212,21 +4212,21 @@
         }
       }
       var newTheory = destination_0;
-      tmp = new Success_0(new ListedTheory(this.m1i(), newTheory, this.lr()), listOf_0(toBeActuallyRetracted));
+      tmp = new Success_0(new ListedTheory(this.r1k(), newTheory, this.lr()), listOf_0(toBeActuallyRetracted));
     }
     return tmp;
   };
   protoOf(ListedTheory).retract = function (clause) {
-    return this.s1q(clause);
+    return this.x1s(clause);
   };
-  protoOf(ListedTheory).p1q = function () {
-    return Companion_instance_9.listedOfIterable(this.m1i(), this);
+  protoOf(ListedTheory).u1s = function () {
+    return Companion_instance_9.listedOfIterable(this.r1k(), this);
   };
   protoOf(ListedTheory).toMutableTheory = function () {
-    return this.p1q();
+    return this.u1s();
   };
-  protoOf(ListedTheory).a1q = function (clauses) {
-    var residual = dequeOf_1(this.w1i());
+  protoOf(ListedTheory).f1s = function (clauses) {
+    var residual = dequeOf_1(this.b1l());
     var removed = dequeOf([]);
     var i = residual.n();
     while (i.q()) {
@@ -4247,7 +4247,7 @@
         var _iterator__ex2g4s = clauses.n();
         while (_iterator__ex2g4s.q()) {
           var element = _iterator__ex2g4s.r();
-          if (this.m1i().match(element, current)) {
+          if (this.r1k().match(current, element)) {
             tmp$ret$0 = true;
             break $l$block_0;
           }
@@ -4263,22 +4263,22 @@
     if (removed.h()) {
       tmp_0 = new Failure_0(this);
     } else {
-      tmp_0 = new Success_0(new ListedTheory(this.m1i(), residual, this.lr()), removed);
+      tmp_0 = new Success_0(new ListedTheory(this.r1k(), residual, this.lr()), removed);
     }
     return tmp_0;
   };
   protoOf(ListedTheory).retractIterable = function (clauses) {
-    return this.a1q(clauses);
+    return this.f1s(clauses);
   };
-  protoOf(ListedTheory).e1j = function (clause) {
+  protoOf(ListedTheory).j1l = function (clause) {
     // Inline function 'kotlin.collections.filter' call
-    var tmp0 = this.w1i();
+    var tmp0 = this.b1l();
     // Inline function 'kotlin.collections.filterTo' call
     var destination = ArrayList_init_$Create$_0();
     var _iterator__ex2g4s = tmp0.n();
     while (_iterator__ex2g4s.q()) {
       var element = _iterator__ex2g4s.r();
-      if (this.m1i().match(element, clause)) {
+      if (this.r1k().match(clause, element)) {
         destination.l(element);
       }
     }
@@ -4288,13 +4288,13 @@
       tmp = new Failure_0(this);
     } else {
       // Inline function 'kotlin.collections.partition' call
-      var this_0 = toList_0(this.w1i());
+      var this_0 = toList_0(this.b1l());
       var first = ArrayList_init_$Create$_0();
       var second = ArrayList_init_$Create$_0();
       var _iterator__ex2g4s_0 = this_0.n();
       while (_iterator__ex2g4s_0.q()) {
         var element_0 = _iterator__ex2g4s_0.r();
-        if (this.m1i().match(element_0, clause)) {
+        if (this.r1k().match(clause, element_0)) {
           first.l(element_0);
         } else {
           second.l(element_0);
@@ -4303,12 +4303,12 @@
       var partitionedClauses = new Pair(first, second);
       var newTheory = partitionedClauses.second;
       var toBeActuallyRetracted = partitionedClauses.first;
-      tmp = new Success_0(new ListedTheory(this.m1i(), newTheory, this.lr()), toBeActuallyRetracted);
+      tmp = new Success_0(new ListedTheory(this.r1k(), newTheory, this.lr()), toBeActuallyRetracted);
     }
     return tmp;
   };
   protoOf(ListedTheory).retractAll = function (clause) {
-    return this.e1j(clause);
+    return this.j1l(clause);
   };
   protoOf(ListedTheory).hashCode = function () {
     return _get_hashCodeCache__ny3r0q_1(this);
@@ -4317,21 +4317,21 @@
     return _get_sizeCache__6eswog_0(this);
   };
   protoOf(ListedTheory).b10 = function (tags) {
-    return tags === this.lr() ? this : new ListedTheory(this.m1i(), this.w1i(), tags);
+    return tags === this.lr() ? this : new ListedTheory(this.r1k(), this.b1l(), tags);
   };
   protoOf(ListedTheory).resetTags = function (tags) {
     return this.b10(tags);
   };
-  protoOf(ListedTheory).p1p = function (theory) {
-    return this.r1i() ? theory.toImmutableTheory() : theory.r1i() ? this : protoOf(AbstractListedTheory).p1p.call(this, theory);
+  protoOf(ListedTheory).u1r = function (theory) {
+    return this.w1k() ? theory.toImmutableTheory() : theory.w1k() ? this : protoOf(AbstractListedTheory).u1r.call(this, theory);
   };
   protoOf(ListedTheory).plusTheory = function (theory) {
-    return this.p1p(theory);
+    return this.u1r(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.t1j(clauses);
+    TheoryUtils_instance.y1l(clauses);
     return $this;
   }
   function MutableIndexedTheory_init_$Create$(unificator, clauses, tags) {
@@ -4346,54 +4346,54 @@
     return MutableIndexedTheory_init_$Init$_0(unificator, clauses, tags, objectCreate(protoOf(MutableIndexedTheory)));
   }
   function toRetractResult($this, $receiver) {
-    return $receiver.d10() ? new Success_0($this, ensureNotNull($receiver.w1i())) : new Failure_0($this);
+    return $receiver.d10() ? new Success_0($this, ensureNotNull($receiver.b1l())) : new Failure_0($this);
   }
   function MutableIndexedTheory$retract$lambda(this$0) {
     return function (it) {
-      return this$0.r1r_1.b1j(it);
+      return this$0.w1t_1.g1l(it);
     };
   }
   function MutableIndexedTheory$retract$lambda_0(it) {
     return it.d10();
   }
   function MutableIndexedTheory$retract$lambda_1(it) {
-    return asSequence(ensureNotNull(it.w1i()));
+    return asSequence(ensureNotNull(it.b1l()));
   }
   function MutableIndexedTheory(queue, tags) {
     AbstractIndexedTheory.call(this, queue, tags);
-    this.r1r_1 = queue;
+    this.w1t_1 = queue;
   }
-  protoOf(MutableIndexedTheory).b1r = function () {
-    return this.r1r_1;
+  protoOf(MutableIndexedTheory).g1t = function () {
+    return this.w1t_1;
   };
-  protoOf(MutableIndexedTheory).n1p = function (unificator) {
-    return protoOf(AbstractIndexedTheory).n1p.call(this, unificator).toMutableTheory();
+  protoOf(MutableIndexedTheory).s1r = function (unificator) {
+    return protoOf(AbstractIndexedTheory).s1r.call(this, unificator).toMutableTheory();
   };
   protoOf(MutableIndexedTheory).setUnificator = function (unificator) {
-    return this.n1p(unificator);
+    return this.s1r(unificator);
   };
-  protoOf(MutableIndexedTheory).p1q = function () {
+  protoOf(MutableIndexedTheory).u1s = function () {
     return toMutableTheory.call(this);
   };
   protoOf(MutableIndexedTheory).toMutableTheory = function () {
-    return this.p1q();
+    return this.u1s();
   };
-  protoOf(MutableIndexedTheory).w1i = function () {
-    return toList_0(this.r1r_1);
+  protoOf(MutableIndexedTheory).b1l = function () {
+    return toList_0(this.w1t_1);
   };
   protoOf(MutableIndexedTheory).n = function () {
-    return this.r1r_1.n();
+    return this.w1t_1.n();
   };
-  protoOf(MutableIndexedTheory).y1p = function (clauses, tags, unificator) {
+  protoOf(MutableIndexedTheory).d1s = function (clauses, tags, unificator) {
     return MutableIndexedTheory_init_$Create$_0(unificator, clauses, tags);
   };
-  protoOf(MutableIndexedTheory).s1q = function (clause) {
-    return toRetractResult(this, this.r1r_1.b1j(clause));
+  protoOf(MutableIndexedTheory).x1s = function (clause) {
+    return toRetractResult(this, this.w1t_1.g1l(clause));
   };
   protoOf(MutableIndexedTheory).retract = function (clause) {
-    return this.s1q(clause);
+    return this.x1s(clause);
   };
-  protoOf(MutableIndexedTheory).a1q = function (clauses) {
+  protoOf(MutableIndexedTheory).f1s = 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);
@@ -4407,126 +4407,126 @@
     return tmp_2;
   };
   protoOf(MutableIndexedTheory).retractIterable = function (clauses) {
-    return this.a1q(clauses);
+    return this.f1s(clauses);
   };
-  protoOf(MutableIndexedTheory).e1j = function (clause) {
-    return toRetractResult(this, this.r1r_1.d1j(clause));
+  protoOf(MutableIndexedTheory).j1l = function (clause) {
+    return toRetractResult(this, this.w1t_1.i1l(clause));
   };
   protoOf(MutableIndexedTheory).retractAll = function (clause) {
-    return this.e1j(clause);
+    return this.j1l(clause);
   };
-  protoOf(MutableIndexedTheory).d1p = function (clause) {
-    return this.v1p(TheoryUtils_instance.i1j(clause));
+  protoOf(MutableIndexedTheory).i1r = function (clause) {
+    return this.a1s(TheoryUtils_instance.n1l(clause));
   };
   protoOf(MutableIndexedTheory).plus = function (clause) {
-    return this.d1p(clause);
+    return this.i1r(clause);
   };
-  protoOf(MutableIndexedTheory).p1p = function (theory) {
+  protoOf(MutableIndexedTheory).u1r = function (theory) {
     var tmp;
     if (theory === this) {
-      tmp = this.w1p(toList_0(theory));
+      tmp = this.b1s(toList_0(theory));
     } else {
-      tmp = this.w1p(theory);
+      tmp = this.b1s(theory);
     }
     return tmp;
   };
   protoOf(MutableIndexedTheory).plusTheory = function (theory) {
-    return this.p1p(theory);
+    return this.u1r(theory);
   };
-  protoOf(MutableIndexedTheory).r1p = function (clause) {
+  protoOf(MutableIndexedTheory).w1r = function (clause) {
     // Inline function 'kotlin.also' call
-    this.r1r_1.j1j(TheoryUtils_instance.i1j(clause));
+    this.w1t_1.o1l(TheoryUtils_instance.n1l(clause));
     return this;
   };
   protoOf(MutableIndexedTheory).assertA = function (clause) {
-    return this.r1p(clause);
+    return this.w1r(clause);
   };
-  protoOf(MutableIndexedTheory).t1p = function (clauses) {
+  protoOf(MutableIndexedTheory).y1r = function (clauses) {
     // Inline function 'kotlin.also' call
-    var _iterator__ex2g4s = asReversed(toList_0(TheoryUtils_instance.t1j(clauses))).n();
+    var _iterator__ex2g4s = asReversed(toList_0(TheoryUtils_instance.y1l(clauses))).n();
     while (_iterator__ex2g4s.q()) {
       var clause = _iterator__ex2g4s.r();
-      this.r1r_1.j1j(clause);
+      this.w1t_1.o1l(clause);
     }
     return this;
   };
   protoOf(MutableIndexedTheory).assertAIterable = function (clauses) {
-    return this.t1p(clauses);
+    return this.y1r(clauses);
   };
-  protoOf(MutableIndexedTheory).u1p = function (clauses) {
-    return this.t1p(asIterable(clauses));
+  protoOf(MutableIndexedTheory).z1r = function (clauses) {
+    return this.y1r(asIterable(clauses));
   };
   protoOf(MutableIndexedTheory).assertASequence = function (clauses) {
-    return this.u1p(clauses);
+    return this.z1r(clauses);
   };
-  protoOf(MutableIndexedTheory).v1p = function (clause) {
+  protoOf(MutableIndexedTheory).a1s = function (clause) {
     // Inline function 'kotlin.also' call
-    this.r1r_1.k1j(TheoryUtils_instance.i1j(clause));
+    this.w1t_1.p1l(TheoryUtils_instance.n1l(clause));
     return this;
   };
   protoOf(MutableIndexedTheory).assertZ = function (clause) {
-    return this.v1p(clause);
+    return this.a1s(clause);
   };
-  protoOf(MutableIndexedTheory).w1p = function (clauses) {
+  protoOf(MutableIndexedTheory).b1s = function (clauses) {
     // Inline function 'kotlin.also' call
-    this.r1r_1.a1j(TheoryUtils_instance.t1j(clauses));
+    this.w1t_1.f1l(TheoryUtils_instance.y1l(clauses));
     return this;
   };
   protoOf(MutableIndexedTheory).assertZIterable = function (clauses) {
-    return this.w1p(clauses);
+    return this.b1s(clauses);
   };
-  protoOf(MutableIndexedTheory).x1p = function (clauses) {
-    return this.w1p(TheoryUtils_instance.t1j(asIterable(clauses)));
+  protoOf(MutableIndexedTheory).c1s = function (clauses) {
+    return this.b1s(TheoryUtils_instance.y1l(asIterable(clauses)));
   };
   protoOf(MutableIndexedTheory).assertZSequence = function (clauses) {
-    return this.x1p(clauses);
+    return this.c1s(clauses);
   };
-  protoOf(MutableIndexedTheory).z1p = function (clauses) {
-    return this.a1q(asIterable(clauses));
+  protoOf(MutableIndexedTheory).e1s = function (clauses) {
+    return this.f1s(asIterable(clauses));
   };
   protoOf(MutableIndexedTheory).retractSequence = function (clauses) {
-    return this.z1p(clauses);
+    return this.e1s(clauses);
   };
-  protoOf(MutableIndexedTheory).i1p = function (indicator) {
-    return protoOf(AbstractIndexedTheory).i1p.call(this, indicator).toMutableTheory();
+  protoOf(MutableIndexedTheory).n1r = function (indicator) {
+    return protoOf(AbstractIndexedTheory).n1r.call(this, indicator).toMutableTheory();
   };
   protoOf(MutableIndexedTheory).abolish = function (indicator) {
-    return this.i1p(indicator);
+    return this.n1r(indicator);
   };
-  protoOf(MutableIndexedTheory).c1p = function () {
-    return Companion_instance_10.indexedOfIterable(this.m1i(), this);
+  protoOf(MutableIndexedTheory).h1r = function () {
+    return Companion_instance_10.indexedOfIterable(this.r1k(), this);
   };
   protoOf(MutableIndexedTheory).toImmutableTheory = function () {
-    return this.c1p();
+    return this.h1r();
   };
   protoOf(MutableIndexedTheory).b10 = function (tags) {
-    return tags === this.lr() ? this : new MutableIndexedTheory(this.r1r_1, tags);
+    return tags === this.lr() ? this : new MutableIndexedTheory(this.w1t_1, tags);
   };
   protoOf(MutableIndexedTheory).resetTags = function (tags) {
     return this.b10(tags);
   };
-  protoOf(MutableIndexedTheory).b1q = function () {
-    return this.o1p(asSequence(this.w1i()));
+  protoOf(MutableIndexedTheory).g1s = function () {
+    return this.t1r(asSequence(this.b1l()));
   };
   protoOf(MutableIndexedTheory).clone = function () {
-    return this.b1q();
+    return this.g1s();
   };
   protoOf(MutableIndexedTheory).assertAFact = function (struct) {
-    return this.q1q(struct);
+    return this.v1s(struct);
   };
   protoOf(MutableIndexedTheory).assertZFact = function (struct) {
-    return this.r1q(struct);
+    return this.w1s(struct);
   };
   protoOf(MutableIndexedTheory).retractByHead = function (head) {
-    return this.t1q(head);
+    return this.y1s(head);
   };
   protoOf(MutableIndexedTheory).retractAllByHead = function (head) {
-    return this.u1q(head);
+    return this.z1s(head);
   };
   function MutableListedTheory_init_$Init$(unificator, clauses, tags, $this) {
     tags = tags === VOID ? emptyMap() : tags;
     MutableListedTheory.call($this, unificator, toMutableList(clauses), tags);
-    TheoryUtils_instance.t1j(clauses);
+    TheoryUtils_instance.y1l(clauses);
     return $this;
   }
   function MutableListedTheory_init_$Create$(unificator, clauses, tags) {
@@ -4535,7 +4535,7 @@
   function MutableListedTheory_init_$Init$_0(unificator, clauses, tags, $this) {
     tags = tags === VOID ? emptyMap() : tags;
     MutableListedTheory.call($this, unificator, toMutableList_0(clauses), tags);
-    TheoryUtils_instance.q1p(clauses);
+    TheoryUtils_instance.v1r(clauses);
     return $this;
   }
   function MutableListedTheory_init_$Create$_0(unificator, clauses, tags) {
@@ -4543,32 +4543,32 @@
   }
   function MutableListedTheory(unificator, clauses, tags) {
     AbstractListedTheory.call(this, unificator, clauses, tags);
-    this.v1r_1 = clauses;
+    this.a1u_1 = clauses;
   }
-  protoOf(MutableListedTheory).w1i = function () {
-    return this.v1r_1;
+  protoOf(MutableListedTheory).b1l = function () {
+    return this.a1u_1;
   };
-  protoOf(MutableListedTheory).n1p = function (unificator) {
-    this.f1r(unificator);
+  protoOf(MutableListedTheory).s1r = function (unificator) {
+    this.k1t(unificator);
     return this;
   };
   protoOf(MutableListedTheory).setUnificator = function (unificator) {
-    return this.n1p(unificator);
+    return this.s1r(unificator);
   };
-  protoOf(MutableListedTheory).p1q = function () {
+  protoOf(MutableListedTheory).u1s = function () {
     return toMutableTheory.call(this);
   };
   protoOf(MutableListedTheory).toMutableTheory = function () {
-    return this.p1q();
+    return this.u1s();
   };
-  protoOf(MutableListedTheory).y1p = function (clauses, tags, unificator) {
+  protoOf(MutableListedTheory).d1s = function (clauses, tags, unificator) {
     return MutableListedTheory_init_$Create$_0(unificator, clauses, tags);
   };
-  protoOf(MutableListedTheory).s1q = function (clause) {
-    var i = this.v1r_1.b4();
+  protoOf(MutableListedTheory).x1s = function (clause) {
+    var i = this.a1u_1.b4();
     while (i.q()) {
       var c = i.r();
-      if (this.m1i().match(c, clause)) {
+      if (this.r1k().match(clause, c)) {
         i.b3();
         return new Success_0(this, listOf_0(c));
       }
@@ -4576,10 +4576,10 @@
     return new Failure_0(this);
   };
   protoOf(MutableListedTheory).retract = function (clause) {
-    return this.s1q(clause);
+    return this.x1s(clause);
   };
-  protoOf(MutableListedTheory).a1q = function (clauses) {
-    var i = this.v1r_1.b4();
+  protoOf(MutableListedTheory).f1s = function (clauses) {
+    var i = this.a1u_1.b4();
     // Inline function 'kotlin.collections.mutableListOf' call
     var retracted = ArrayList_init_$Create$_0();
     while (i.q()) {
@@ -4587,7 +4587,7 @@
       var _iterator__ex2g4s = clauses.n();
       while (_iterator__ex2g4s.q()) {
         var clause = _iterator__ex2g4s.r();
-        if (this.m1i().match(c, clause)) {
+        if (this.r1k().match(clause, c)) {
           retracted.l(c);
           i.b3();
         }
@@ -4602,15 +4602,15 @@
     return tmp;
   };
   protoOf(MutableListedTheory).retractIterable = function (clauses) {
-    return this.a1q(clauses);
+    return this.f1s(clauses);
   };
-  protoOf(MutableListedTheory).e1j = function (clause) {
-    var i = this.v1r_1.b4();
+  protoOf(MutableListedTheory).j1l = function (clause) {
+    var i = this.a1u_1.b4();
     // Inline function 'kotlin.collections.mutableListOf' call
     var retracted = ArrayList_init_$Create$_0();
     while (i.q()) {
       var c = i.r();
-      if (this.m1i().match(c, clause)) {
+      if (this.r1k().match(clause, c)) {
         retracted.l(c);
         i.b3();
       }
@@ -4624,111 +4624,111 @@
     return tmp;
   };
   protoOf(MutableListedTheory).retractAll = function (clause) {
-    return this.e1j(clause);
+    return this.j1l(clause);
   };
-  protoOf(MutableListedTheory).d1p = function (clause) {
-    return this.v1p(clause);
+  protoOf(MutableListedTheory).i1r = function (clause) {
+    return this.a1s(clause);
   };
   protoOf(MutableListedTheory).plus = function (clause) {
-    return this.d1p(clause);
+    return this.i1r(clause);
   };
-  protoOf(MutableListedTheory).p1p = function (theory) {
+  protoOf(MutableListedTheory).u1r = function (theory) {
     var tmp;
     if (theory === this) {
-      tmp = this.w1p(toList_0(theory));
+      tmp = this.b1s(toList_0(theory));
     } else {
-      tmp = this.w1p(theory);
+      tmp = this.b1s(theory);
     }
     return tmp;
   };
   protoOf(MutableListedTheory).plusTheory = function (theory) {
-    return this.p1p(theory);
+    return this.u1r(theory);
   };
-  protoOf(MutableListedTheory).r1p = function (clause) {
+  protoOf(MutableListedTheory).w1r = function (clause) {
     // Inline function 'kotlin.also' call
-    addFirst(this.v1r_1, TheoryUtils_instance.i1j(clause));
+    addFirst(this.a1u_1, TheoryUtils_instance.n1l(clause));
     return this;
   };
   protoOf(MutableListedTheory).assertA = function (clause) {
-    return this.r1p(clause);
+    return this.w1r(clause);
   };
-  protoOf(MutableListedTheory).t1p = function (clauses) {
+  protoOf(MutableListedTheory).y1r = function (clauses) {
     // Inline function 'kotlin.also' call
-    addFirst_0(this.v1r_1, TheoryUtils_instance.t1j(clauses));
+    addFirst_0(this.a1u_1, TheoryUtils_instance.y1l(clauses));
     return this;
   };
   protoOf(MutableListedTheory).assertAIterable = function (clauses) {
-    return this.t1p(clauses);
+    return this.y1r(clauses);
   };
-  protoOf(MutableListedTheory).u1p = function (clauses) {
-    return this.t1p(asIterable(clauses));
+  protoOf(MutableListedTheory).z1r = function (clauses) {
+    return this.y1r(asIterable(clauses));
   };
   protoOf(MutableListedTheory).assertASequence = function (clauses) {
-    return this.u1p(clauses);
+    return this.z1r(clauses);
   };
-  protoOf(MutableListedTheory).v1p = function (clause) {
+  protoOf(MutableListedTheory).a1s = function (clause) {
     // Inline function 'kotlin.also' call
-    this.v1r_1.l(TheoryUtils_instance.i1j(clause));
+    this.a1u_1.l(TheoryUtils_instance.n1l(clause));
     return this;
   };
   protoOf(MutableListedTheory).assertZ = function (clause) {
-    return this.v1p(clause);
+    return this.a1s(clause);
   };
-  protoOf(MutableListedTheory).w1p = function (clauses) {
+  protoOf(MutableListedTheory).b1s = function (clauses) {
     // Inline function 'kotlin.also' call
-    addAll(this.v1r_1, TheoryUtils_instance.t1j(clauses));
+    addAll(this.a1u_1, TheoryUtils_instance.y1l(clauses));
     return this;
   };
   protoOf(MutableListedTheory).assertZIterable = function (clauses) {
-    return this.w1p(clauses);
+    return this.b1s(clauses);
   };
-  protoOf(MutableListedTheory).x1p = function (clauses) {
-    return this.w1p(asIterable(clauses));
+  protoOf(MutableListedTheory).c1s = function (clauses) {
+    return this.b1s(asIterable(clauses));
   };
   protoOf(MutableListedTheory).assertZSequence = function (clauses) {
-    return this.x1p(clauses);
+    return this.c1s(clauses);
   };
-  protoOf(MutableListedTheory).z1p = function (clauses) {
-    return this.a1q(asIterable(clauses));
+  protoOf(MutableListedTheory).e1s = function (clauses) {
+    return this.f1s(asIterable(clauses));
   };
   protoOf(MutableListedTheory).retractSequence = function (clauses) {
-    return this.z1p(clauses);
+    return this.e1s(clauses);
   };
-  protoOf(MutableListedTheory).i1p = function (indicator) {
-    return protoOf(AbstractListedTheory).i1p.call(this, indicator).toMutableTheory();
+  protoOf(MutableListedTheory).n1r = function (indicator) {
+    return protoOf(AbstractListedTheory).n1r.call(this, indicator).toMutableTheory();
   };
   protoOf(MutableListedTheory).abolish = function (indicator) {
-    return this.i1p(indicator);
+    return this.n1r(indicator);
   };
-  protoOf(MutableListedTheory).c1p = function () {
-    return Companion_instance_10.listedOfIterable(this.m1i(), this);
+  protoOf(MutableListedTheory).h1r = function () {
+    return Companion_instance_10.listedOfIterable(this.r1k(), this);
   };
   protoOf(MutableListedTheory).toImmutableTheory = function () {
-    return this.c1p();
+    return this.h1r();
   };
   protoOf(MutableListedTheory).b10 = function (tags) {
-    return tags === this.lr() ? this : new MutableListedTheory(this.m1i(), this.v1r_1, tags);
+    return tags === this.lr() ? this : new MutableListedTheory(this.r1k(), this.a1u_1, tags);
   };
   protoOf(MutableListedTheory).resetTags = function (tags) {
     return this.b10(tags);
   };
-  protoOf(MutableListedTheory).b1q = function () {
-    return this.o1p(asSequence(this.v1r_1));
+  protoOf(MutableListedTheory).g1s = function () {
+    return this.t1r(asSequence(this.a1u_1));
   };
   protoOf(MutableListedTheory).clone = function () {
-    return this.b1q();
+    return this.g1s();
   };
   protoOf(MutableListedTheory).assertAFact = function (struct) {
-    return this.q1q(struct);
+    return this.v1s(struct);
   };
   protoOf(MutableListedTheory).assertZFact = function (struct) {
-    return this.r1q(struct);
+    return this.w1s(struct);
   };
   protoOf(MutableListedTheory).retractByHead = function (head) {
-    return this.t1q(head);
+    return this.y1s(head);
   };
   protoOf(MutableListedTheory).retractAllByHead = function (head) {
-    return this.u1q(head);
+    return this.z1s(head);
   };
   function takeFirstAfterSkipping(_this__u8e3s4, n) {
     var iter = _this__u8e3s4.n();
@@ -4745,29 +4745,29 @@
   }
   //region block: post-declaration
   defineProp(protoOf(RetrieveResult), 'collection', function () {
-    return this.o1j();
+    return this.t1l();
   });
   defineProp(protoOf(RetrieveResult), 'clauses', function () {
-    return this.w1i();
+    return this.b1l();
   });
   defineProp(protoOf(RetrieveResult), 'firstClause', function () {
-    return this.p1j();
+    return this.u1l();
   });
-  protoOf(MutableReteClauseQueue).u1i = get;
-  protoOf(ReteClauseQueue).u1i = get;
-  protoOf(IndexedClause$Companion$wrap$1).q1k = get_innerClause;
-  protoOf(IndexedClause$Companion$wrap$1).z1l = plus_1;
+  protoOf(MutableReteClauseQueue).z1k = get;
+  protoOf(ReteClauseQueue).z1k = get;
+  protoOf(IndexedClause$Companion$wrap$1).v1m = get_innerClause;
+  protoOf(IndexedClause$Companion$wrap$1).e1o = plus_1;
   protoOf(IndexedClause$Companion$wrap$1).hr = compareTo;
   protoOf(IndexedClause$Companion$wrap$1).oc = component1;
   protoOf(IndexedClause$Companion$wrap$1).pc = component2;
-  protoOf(SituatedIndexedClause$Companion$of$1).q1k = get_innerClause;
-  protoOf(SituatedIndexedClause$Companion$of$1).z1l = plus_1;
+  protoOf(SituatedIndexedClause$Companion$of$1).v1m = get_innerClause;
+  protoOf(SituatedIndexedClause$Companion$of$1).e1o = plus_1;
   protoOf(SituatedIndexedClause$Companion$of$1).hr = compareTo;
   protoOf(SituatedIndexedClause$Companion$of$1).oc = component1;
   protoOf(SituatedIndexedClause$Companion$of$1).pc = component2;
-  protoOf(AbstractTheory).c1q = get_isMutable;
-  protoOf(AbstractTheory).q1i = get_rules;
-  protoOf(AbstractTheory).p1i = get_directives;
+  protoOf(AbstractTheory).h1s = get_isMutable;
+  protoOf(AbstractTheory).v1k = get_rules;
+  protoOf(AbstractTheory).u1k = get_directives;
   protoOf(AbstractTheory).assertAFact = assertAFact;
   protoOf(AbstractTheory).assertZFact = assertZFact;
   protoOf(AbstractTheory).retractByHead = retractByHead;
@@ -4791,24 +4791,24 @@
   protoOf(ListedTheoryFactory).mutableTheoryOf = mutableTheoryOf;
   protoOf(ListedTheoryFactory).mutableTheoryOfSequence = mutableTheoryOfSequence;
   defineProp(protoOf(RetractResult), 'theory', function () {
-    return this.j1p();
+    return this.o1r();
   });
   defineProp(protoOf(RetractResult), 'clauses', function () {
-    return this.w1i();
+    return this.b1l();
   });
   defineProp(protoOf(RetractResult), 'firstClause', function () {
-    return this.p1j();
+    return this.u1l();
   });
-  protoOf(MutableIndexedTheory).q1q = assertAFact_0;
-  protoOf(MutableIndexedTheory).r1q = assertZFact_0;
-  protoOf(MutableIndexedTheory).t1q = retractByHead_0;
-  protoOf(MutableIndexedTheory).c1q = get_isMutable_0;
-  protoOf(MutableIndexedTheory).u1q = retractAllByHead_0;
-  protoOf(MutableListedTheory).q1q = assertAFact_0;
-  protoOf(MutableListedTheory).r1q = assertZFact_0;
-  protoOf(MutableListedTheory).t1q = retractByHead_0;
-  protoOf(MutableListedTheory).c1q = get_isMutable_0;
-  protoOf(MutableListedTheory).u1q = retractAllByHead_0;
+  protoOf(MutableIndexedTheory).v1s = assertAFact_0;
+  protoOf(MutableIndexedTheory).w1s = assertZFact_0;
+  protoOf(MutableIndexedTheory).y1s = retractByHead_0;
+  protoOf(MutableIndexedTheory).h1s = get_isMutable_0;
+  protoOf(MutableIndexedTheory).z1s = retractAllByHead_0;
+  protoOf(MutableListedTheory).v1s = assertAFact_0;
+  protoOf(MutableListedTheory).w1s = assertZFact_0;
+  protoOf(MutableListedTheory).y1s = retractByHead_0;
+  protoOf(MutableListedTheory).h1s = get_isMutable_0;
+  protoOf(MutableListedTheory).z1s = retractAllByHead_0;
   //endregion
   //region block: init
   Companion_instance_4 = new Companion();