@jakta/jakta-prolog-incarnation 0.0.0-bootstrap

package/2p-solve-classic.js

@@ -0,0 +1,2832 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './2p-unify.js', './kotlin-kotlin-stdlib.js', './2p-solve.js', './2p-theory.js', './2p-utils.js', './2p-core.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./2p-unify.js'), require('./kotlin-kotlin-stdlib.js'), require('./2p-solve.js'), require('./2p-theory.js'), require('./2p-utils.js'), require('./2p-core.js'));
+  else {
+    if (typeof globalThis['2p-unify'] === 'undefined') {
+      throw new Error("Error loading module '2p-solve-classic'. Its dependency '2p-unify' was not found. Please, check whether '2p-unify' is loaded prior to '2p-solve-classic'.");
+    }
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module '2p-solve-classic'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to '2p-solve-classic'.");
+    }
+    if (typeof globalThis['2p-solve'] === 'undefined') {
+      throw new Error("Error loading module '2p-solve-classic'. Its dependency '2p-solve' was not found. Please, check whether '2p-solve' is loaded prior to '2p-solve-classic'.");
+    }
+    if (typeof globalThis['2p-theory'] === 'undefined') {
+      throw new Error("Error loading module '2p-solve-classic'. Its dependency '2p-theory' was not found. Please, check whether '2p-theory' is loaded prior to '2p-solve-classic'.");
+    }
+    if (typeof globalThis['2p-utils'] === 'undefined') {
+      throw new Error("Error loading module '2p-solve-classic'. Its dependency '2p-utils' was not found. Please, check whether '2p-utils' is loaded prior to '2p-solve-classic'.");
+    }
+    if (typeof globalThis['2p-core'] === 'undefined') {
+      throw new Error("Error loading module '2p-solve-classic'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to '2p-solve-classic'.");
+    }
+    globalThis['2p-solve-classic'] = factory(typeof globalThis['2p-solve-classic'] === 'undefined' ? {} : globalThis['2p-solve-classic'], globalThis['2p-unify'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-solve'], globalThis['2p-theory'], globalThis['2p-utils'], globalThis['2p-core']);
+  }
+}(function (_, kotlin_it_unibo_tuprolog_unify, kotlin_kotlin, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_utils, kotlin_it_unibo_tuprolog_core) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_unify.$_$.a;
+  var VOID = kotlin_kotlin.$_$.b;
+  var Companion_instance = kotlin_it_unibo_tuprolog_solve.$_$.p;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_solve.$_$.l;
+  var Companion_instance_0 = kotlin_it_unibo_tuprolog_theory.$_$.b;
+  var Companion_instance_1 = kotlin_it_unibo_tuprolog_theory.$_$.a;
+  var Companion_instance_2 = kotlin_it_unibo_tuprolog_solve.$_$.a;
+  var Companion_instance_3 = kotlin_it_unibo_tuprolog_solve.$_$.c;
+  var Companion_instance_4 = kotlin_it_unibo_tuprolog_solve.$_$.b;
+  var Companion_instance_5 = kotlin_it_unibo_tuprolog_solve.$_$.d;
+  var equalsLong = kotlin_kotlin.$_$.w4;
+  var toString = kotlin_kotlin.$_$.q6;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var Unit_instance = kotlin_kotlin.$_$.m;
+  var constructCallableReference = kotlin_kotlin.$_$.r5;
+  var AbstractSolver = kotlin_it_unibo_tuprolog_solve.$_$.l1;
+  var protoOf = kotlin_kotlin.$_$.n6;
+  var THROW_CCE = kotlin_kotlin.$_$.ha;
+  var throwUninitializedPropertyAccessException = kotlin_kotlin.$_$.k4;
+  var getAllOperators = kotlin_it_unibo_tuprolog_solve.$_$.z2;
+  var toOperatorSet = kotlin_it_unibo_tuprolog_solve.$_$.b3;
+  var Long = kotlin_kotlin.$_$.ba;
+  var currentTimeInstant = kotlin_it_unibo_tuprolog_solve.$_$.x2;
+  var asSequence = kotlin_kotlin.$_$.k7;
+  var initMetadataForClass = kotlin_kotlin.$_$.y5;
+  var ensureNotNull = kotlin_kotlin.$_$.la;
+  var fromInt = kotlin_kotlin.$_$.x4;
+  var add = kotlin_kotlin.$_$.n4;
+  var hashCode = kotlin_kotlin.$_$.x5;
+  var equals = kotlin_kotlin.$_$.t5;
+  var CoroutineImpl = kotlin_kotlin.$_$.j4;
+  var SequenceScope = kotlin_kotlin.$_$.g7;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.i4;
+  var initMetadataForLambda = kotlin_kotlin.$_$.b6;
+  var sequence = kotlin_kotlin.$_$.k8;
+  var toString_0 = kotlin_kotlin.$_$.ra;
+  var asSequence_0 = kotlin_kotlin.$_$.z1;
+  var emptySequence = kotlin_kotlin.$_$.p7;
+  var plus = kotlin_kotlin.$_$.h8;
+  var KProperty1 = kotlin_kotlin.$_$.f7;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.v5;
+  var flatMap = kotlin_kotlin.$_$.v7;
+  var distinct = kotlin_kotlin.$_$.n7;
+  var cached = kotlin_it_unibo_tuprolog_utils.$_$.r;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_core.$_$.n;
+  var filter = kotlin_kotlin.$_$.s7;
+  var map = kotlin_kotlin.$_$.d8;
+  var toList = kotlin_kotlin.$_$.q8;
+  var Companion_instance_6 = kotlin_it_unibo_tuprolog_solve.$_$.e;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.o;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.q;
+  var Companion_instance_7 = kotlin_it_unibo_tuprolog_utils.$_$.c;
+  var emptySet = kotlin_kotlin.$_$.k2;
+  var compare = kotlin_kotlin.$_$.r4;
+  var lazy = kotlin_kotlin.$_$.na;
+  var contains = kotlin_kotlin.$_$.l7;
+  var createSolver = kotlin_it_unibo_tuprolog_solve.$_$.x;
+  var createMutableSolver = kotlin_it_unibo_tuprolog_solve.$_$.w;
+  var update = kotlin_it_unibo_tuprolog_solve.$_$.y;
+  var apply = kotlin_it_unibo_tuprolog_solve.$_$.v1;
+  var applyIterable = kotlin_it_unibo_tuprolog_solve.$_$.u1;
+  var applySequence = kotlin_it_unibo_tuprolog_solve.$_$.w1;
+  var get_standardInput = kotlin_it_unibo_tuprolog_solve.$_$.y1;
+  var get_standardOutput = kotlin_it_unibo_tuprolog_solve.$_$.z1;
+  var get_standardError = kotlin_it_unibo_tuprolog_solve.$_$.x1;
+  var get_warnings = kotlin_it_unibo_tuprolog_solve.$_$.a2;
+  var get_endTime = kotlin_it_unibo_tuprolog_solve.$_$.s1;
+  var get_remainingTime = kotlin_it_unibo_tuprolog_solve.$_$.t1;
+  var get_elapsedTime = kotlin_it_unibo_tuprolog_solve.$_$.r1;
+  var ExecutionContext = kotlin_it_unibo_tuprolog_solve.$_$.b2;
+  var objectCreate = kotlin_kotlin.$_$.m6;
+  var rawSolverOf = kotlin_it_unibo_tuprolog_solve.$_$.d1;
+  var solverOf = kotlin_it_unibo_tuprolog_solve.$_$.c1;
+  var mutableSolverOf = kotlin_it_unibo_tuprolog_solve.$_$.z;
+  var rawMutableSolverOf = kotlin_it_unibo_tuprolog_solve.$_$.a1;
+  var newBuilder = kotlin_it_unibo_tuprolog_solve.$_$.u2;
+  var get_defaultRuntime = kotlin_it_unibo_tuprolog_solve.$_$.p2;
+  var get_defaultUnificator = kotlin_it_unibo_tuprolog_solve.$_$.r2;
+  var get_defaultFlags = kotlin_it_unibo_tuprolog_solve.$_$.m2;
+  var get_defaultStaticKb = kotlin_it_unibo_tuprolog_solve.$_$.q2;
+  var get_defaultDynamicKb = kotlin_it_unibo_tuprolog_solve.$_$.k2;
+  var get_defaultInputChannel = kotlin_it_unibo_tuprolog_solve.$_$.n2;
+  var get_defaultOutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.o2;
+  var get_defaultErrorChannel = kotlin_it_unibo_tuprolog_solve.$_$.l2;
+  var get_defaultWarningsChannel = kotlin_it_unibo_tuprolog_solve.$_$.s2;
+  var solverWithDefaultBuiltins = kotlin_it_unibo_tuprolog_solve.$_$.v2;
+  var solverWithDefaultBuiltinsAnd = kotlin_it_unibo_tuprolog_solve.$_$.e1;
+  var mutableSolverWithDefaultBuiltins = kotlin_it_unibo_tuprolog_solve.$_$.t2;
+  var mutableSolverWithDefaultBuiltinsAnd = kotlin_it_unibo_tuprolog_solve.$_$.b1;
+  var SolverFactory = kotlin_it_unibo_tuprolog_solve.$_$.w2;
+  var initMetadataForObject = kotlin_kotlin.$_$.c6;
+  var defineProp = kotlin_kotlin.$_$.s5;
+  var listOf = kotlin_kotlin.$_$.x2;
+  var getAllOperators_0 = kotlin_it_unibo_tuprolog_solve.$_$.a3;
+  var to = kotlin_kotlin.$_$.sa;
+  var loadStaticClauses = kotlin_it_unibo_tuprolog_solve.$_$.f2;
+  var loadStaticClausesIterable = kotlin_it_unibo_tuprolog_solve.$_$.g2;
+  var loadStaticClausesSequence = kotlin_it_unibo_tuprolog_solve.$_$.h2;
+  var loadDynamicClauses = kotlin_it_unibo_tuprolog_solve.$_$.e2;
+  var loadDynamicClausesIterable = kotlin_it_unibo_tuprolog_solve.$_$.c2;
+  var loadDynamicClausesSequence = kotlin_it_unibo_tuprolog_solve.$_$.d2;
+  var MutableSolver = kotlin_it_unibo_tuprolog_solve.$_$.i2;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.z5;
+  var NoSuchElementException_init_$Create$ = kotlin_kotlin.$_$.h1;
+  var subtract = kotlin_kotlin.$_$.g5;
+  var TimeOutException_init_$Create$ = kotlin_it_unibo_tuprolog_solve.$_$.g1;
+  var NoSuchElementException_init_$Create$_0 = kotlin_kotlin.$_$.i1;
+  var initMetadataForInterface = kotlin_kotlin.$_$.a6;
+  var getKClass = kotlin_kotlin.$_$.e7;
+  var ClassCastException_init_$Create$ = kotlin_kotlin.$_$.z;
+  var Companion_instance_8 = kotlin_it_unibo_tuprolog_solve.$_$.u;
+  var MessageError = kotlin_it_unibo_tuprolog_solve.$_$.i1;
+  var Companion_instance_9 = kotlin_it_unibo_tuprolog_solve.$_$.i;
+  var plus_0 = kotlin_it_unibo_tuprolog_utils.$_$.h1;
+  var LogicError = kotlin_it_unibo_tuprolog_solve.$_$.j1;
+  var toSet = kotlin_kotlin.$_$.s8;
+  var plus_1 = kotlin_kotlin.$_$.n3;
+  var TrackVariables_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.n;
+  var drop = kotlin_kotlin.$_$.o7;
+  var first = kotlin_kotlin.$_$.u7;
+  var Unifier = kotlin_it_unibo_tuprolog_core.$_$.l1;
+  var isInterface = kotlin_kotlin.$_$.f6;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.e1;
+  var ResolutionException = kotlin_it_unibo_tuprolog_solve.$_$.k1;
+  var Companion_instance_10 = kotlin_it_unibo_tuprolog_solve.$_$.j;
+  var extractSignature = kotlin_it_unibo_tuprolog_solve.$_$.y2;
+  var Signature = kotlin_it_unibo_tuprolog_solve.$_$.j2;
+  var Expected_CALLABLE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.v;
+  var cursor = kotlin_it_unibo_tuprolog_utils.$_$.t;
+  var Companion_instance_11 = kotlin_it_unibo_tuprolog_solve.$_$.g;
+  var prepareForExecutionWithUnifier = kotlin_it_unibo_tuprolog_core.$_$.m2;
+  var setOf = kotlin_kotlin.$_$.t3;
+  var Unknown_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.o;
+  var MissingPredicate_init_$Create$ = kotlin_it_unibo_tuprolog_solve.$_$.f1;
+  var Companion_instance_12 = kotlin_it_unibo_tuprolog_solve.$_$.f;
+  var contains_0 = kotlin_kotlin.$_$.c2;
+  var firstOrNull = kotlin_kotlin.$_$.t7;
+  var any = kotlin_kotlin.$_$.i7;
+  var LastCallOptimization_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.m;
+  var buffered = kotlin_it_unibo_tuprolog_utils.$_$.q;
+  var sequenceOf = kotlin_kotlin.$_$.i8;
+  var MagicCut = kotlin_it_unibo_tuprolog_solve.$_$.q1;
+  var sequenceOf_0 = kotlin_kotlin.$_$.j8;
+  var Request = kotlin_it_unibo_tuprolog_solve.$_$.n1;
+  var get_ONE = kotlin_kotlin.$_$.m4;
+  var ExtensionLibrary = kotlin_it_unibo_tuprolog_solve.$_$.m1;
+  var CommonBuiltins_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.t;
+  var listOf_0 = kotlin_kotlin.$_$.y2;
+  var Struct = kotlin_it_unibo_tuprolog_core.$_$.k1;
+  var Companion_instance_13 = kotlin_it_unibo_tuprolog_solve.$_$.h;
+  var Companion_instance_14 = kotlin_it_unibo_tuprolog_solve.$_$.k;
+  var UnaryPredicate = kotlin_it_unibo_tuprolog_solve.$_$.o1;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_solve.$_$.q;
+  var RuleWrapper = kotlin_it_unibo_tuprolog_solve.$_$.p1;
+  var RuleWrapper_init_$Init$ = kotlin_it_unibo_tuprolog_solve.$_$.h1;
+  var EnsureExecutable_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.s;
+  var MagicCut_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.r;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(AbstractClassicSolver, 'AbstractClassicSolver', VOID, AbstractSolver);
+  initMetadataForClass(ChoicePointContext, 'ChoicePointContext');
+  initMetadataForClass(Primitives, 'Primitives', VOID, ChoicePointContext);
+  initMetadataForClass(Rules, 'Rules', VOID, ChoicePointContext);
+  initMetadataForLambda(ChoicePointContext$_get_pathToRoot_$slambda_q0myjn, CoroutineImpl, VOID, [1]);
+  initMetadataForLambda(ClassicExecutionContext$pathToRoot$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForClass(ClassicExecutionContext, 'ClassicExecutionContext', VOID, VOID, [ExecutionContext]);
+  initMetadataForClass(ClassicSolver, 'ClassicSolver', VOID, AbstractClassicSolver);
+  initMetadataForObject(ClassicSolverFactory, 'ClassicSolverFactory', VOID, VOID, [SolverFactory]);
+  initMetadataForClass(MutableClassicSolver, 'MutableClassicSolver', VOID, ClassicSolver, [MutableSolver]);
+  initMetadataForCompanion(Companion);
+  function get_isEndState() {
+    return false;
+  }
+  function asEndState() {
+    return null;
+  }
+  function castToEndState() {
+    var tmp0_elvis_lhs = this.asEndState();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw ClassCastException_init_$Create$('Cannot cast ' + toString(this) + ' to ' + getKClass(EndState).g9());
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  }
+  function clone(context, $super) {
+    context = context === VOID ? this.m8() : context;
+    return $super === VOID ? this.g2z(context) : $super.g2z.call(this, context);
+  }
+  initMetadataForInterface(State, 'State');
+  initMetadataForClass(AbstractState, 'AbstractState', VOID, VOID, [State]);
+  function get_hasOpenAlternatives() {
+    return this.j2e().w1s() && this.m8().b2w();
+  }
+  function get_isEndState_0() {
+    return true;
+  }
+  function asEndState_0() {
+    return this;
+  }
+  function asEndState_1() {
+    return this.f2z();
+  }
+  initMetadataForInterface(EndState, 'EndState', VOID, VOID, [State]);
+  initMetadataForClass(AbstractEndState, 'AbstractEndState', VOID, AbstractState, [EndState]);
+  initMetadataForClass(StateBacktracking, 'StateBacktracking', VOID, AbstractState);
+  initMetadataForClass(StateEnd, 'StateEnd', VOID, AbstractEndState);
+  initMetadataForClass(StateException, 'StateException', VOID, AbstractState, [State]);
+  initMetadataForClass(StateGoalSelection, 'StateGoalSelection', VOID, AbstractState);
+  initMetadataForClass(StateHalt, 'StateHalt', VOID, AbstractEndState, [State]);
+  initMetadataForClass(StateInit, 'StateInit', VOID, AbstractState);
+  initMetadataForClass(StatePrimitiveExecution, 'StatePrimitiveExecution', VOID, AbstractState);
+  initMetadataForClass(StatePrimitiveSelection, 'StatePrimitiveSelection', VOID, AbstractState);
+  initMetadataForClass(StateRuleExecution, 'StateRuleExecution', VOID, AbstractState);
+  initMetadataForClass(CutLimit, 'CutLimit');
+  initMetadataForObject(None, 'None', VOID, CutLimit);
+  initMetadataForClass(Actual, 'Actual', VOID, CutLimit);
+  initMetadataForCompanion(Companion_0);
+  initMetadataForClass(StateRuleSelection, 'StateRuleSelection', VOID, AbstractState);
+  initMetadataForClass(AbstractSolutionIterator, 'AbstractSolutionIterator');
+  initMetadataForClass(SimpleSolutionIterator, 'SimpleSolutionIterator', VOID, AbstractSolutionIterator);
+  initMetadataForObject(DefaultBuiltins, 'DefaultBuiltins', VOID, ExtensionLibrary);
+  initMetadataForObject(Throw, 'Throw', VOID, UnaryPredicate);
+  initMetadataForObject(Call, 'Call', VOID, RuleWrapper);
+  initMetadataForObject(Catch, 'Catch', VOID, RuleWrapper);
+  initMetadataForObject(Comma, 'Comma', VOID, RuleWrapper);
+  initMetadataForObject(Cut, 'Cut', VOID, RuleWrapper);
+  initMetadataForClass(NegationAsFailure, 'NegationAsFailure', VOID, RuleWrapper);
+  initMetadataForObject(Fail, 'Fail', VOID, NegationAsFailure);
+  initMetadataForObject(Success, 'Success', VOID, NegationAsFailure);
+  initMetadataForCompanion(Companion_1);
+  //endregion
+  function AbstractClassicSolver_init_$Init$(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, $this) {
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    staticKb = staticKb === VOID ? Companion_instance_0.empty(unificator) : staticKb;
+    dynamicKb = dynamicKb === VOID ? Companion_instance_1.empty(unificator) : dynamicKb;
+    stdIn = stdIn === VOID ? Companion_instance_2.stdIn() : stdIn;
+    stdOut = stdOut === VOID ? Companion_instance_3.stdOut() : stdOut;
+    stdErr = stdErr === VOID ? Companion_instance_3.stdErr() : stdErr;
+    warnings = warnings === VOID ? Companion_instance_3.warning() : warnings;
+    trustKb = trustKb === VOID ? false : trustKb;
+    AbstractClassicSolver.call($this, unificator, libraries, flags, staticKb, dynamicKb, Companion_instance_4.t1u(stdIn), Companion_instance_5.w1u(stdOut, stdErr, warnings), trustKb);
+    return $this;
+  }
+  function updateCurrentContextAfterStateTransition($this, source, destination, index) {
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!equalsLong(destination.m8().x2u_1, index)) {
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    $this.e2v(destination.m8());
+  }
+  function AbstractClassicSolver$updateCurrentContextAfterStateTransition$ref(p0) {
+    return constructCallableReference(function (p0_0, p1, p2) {
+      var tmp0 = p0;
+      updateCurrentContextAfterStateTransition(tmp0, p0_0, p1, p2);
+      return Unit_instance;
+    }, 3, 0, 83, 'updateCurrentContextAfterStateTransition', [p0]);
+  }
+  function AbstractClassicSolver(unificator, libraries, flags, initialStaticKb, initialDynamicKb, inputChannels, outputChannels, trustKb) {
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    initialStaticKb = initialStaticKb === VOID ? Companion_instance_0.empty(unificator) : initialStaticKb;
+    initialDynamicKb = initialDynamicKb === VOID ? Companion_instance_1.empty(unificator) : initialDynamicKb;
+    inputChannels = inputChannels === VOID ? Companion_instance_4.fromStandard() : inputChannels;
+    outputChannels = outputChannels === VOID ? Companion_instance_5.fromStandard() : outputChannels;
+    trustKb = trustKb === VOID ? false : trustKb;
+    AbstractSolver.call(this, unificator, libraries, flags, initialStaticKb, initialDynamicKb, inputChannels, outputChannels, trustKb);
+  }
+  protoOf(AbstractClassicSolver).e2v = function (_set____db54di) {
+    this.d2v_1 = _set____db54di;
+  };
+  protoOf(AbstractClassicSolver).m27 = function (_set____db54di) {
+    return this.e2v(_set____db54di instanceof ClassicExecutionContext ? _set____db54di : THROW_CCE());
+  };
+  protoOf(AbstractClassicSolver).k27 = function () {
+    var tmp = this.d2v_1;
+    if (!(tmp == null))
+      return tmp;
+    else {
+      throwUninitializedPropertyAccessException('currentContext');
+    }
+  };
+  protoOf(AbstractClassicSolver).l27 = function (unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, trustKb) {
+    return new ClassicExecutionContext(VOID, unificator, libraries, flags, trustKb ? staticKb.toImmutableTheory() : Companion_instance_0.empty(unificator), trustKb ? dynamicKb.toMutableTheory() : Companion_instance_1.empty(unificator), toOperatorSet(getAllOperators(libraries, [])), inputChannels, outputChannels, VOID, VOID, VOID, VOID, VOID, VOID, new Long(0, 0));
+  };
+  protoOf(AbstractClassicSolver).s27 = function (goal, options) {
+    var tmp0_unificator = this.x1h();
+    var tmp1_libraries = this.u1r();
+    var tmp2_flags = this.v1r();
+    var tmp3_staticKb = this.w1r().toImmutableTheory();
+    var tmp4_dynamicKb = this.x1r().toMutableTheory();
+    var tmp5_operators = this.d1s();
+    var tmp6_inputChannels = this.y1r();
+    var tmp7_outputChannels = this.z1r();
+    var tmp8_customData = this.k27().m2u_1;
+    var tmp9_startTime = currentTimeInstant();
+    var tmp10_maxDuration = options.a1u();
+    this.e2v(new ClassicExecutionContext(VOID, tmp0_unificator, tmp1_libraries, tmp2_flags, tmp3_staticKb, tmp4_dynamicKb, tmp5_operators, tmp6_inputChannels, tmp7_outputChannels, tmp8_customData, VOID, goal, VOID, VOID, VOID, tmp9_startTime, tmp10_maxDuration));
+    var tmp = new StateInit(this.k27());
+    return asSequence(this.f2v(tmp, AbstractClassicSolver$updateCurrentContextAfterStateTransition$ref(this)));
+  };
+  protoOf(AbstractClassicSolver).copy = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
+    return this.copy(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof AbstractClassicSolver) ? $super : THROW_CCE());
+  };
+  function Primitives(alternatives, executionContext, parent, depth) {
+    ChoicePointContext.call(this, alternatives, executionContext, parent, depth);
+    this.k2v_1 = alternatives;
+    this.l2v_1 = executionContext;
+    this.m2v_1 = parent;
+    this.n2v_1 = depth;
+  }
+  protoOf(Primitives).o2v = function () {
+    return this.k2v_1;
+  };
+  protoOf(Primitives).p2v = function () {
+    return this.l2v_1;
+  };
+  protoOf(Primitives).q2v = function () {
+    return this.m2v_1;
+  };
+  protoOf(Primitives).r2v = function () {
+    return this.n2v_1;
+  };
+  protoOf(Primitives).toString = function () {
+    return protoOf(ChoicePointContext).toString.call(this);
+  };
+  protoOf(Primitives).s2v = function () {
+    return 'Primitives';
+  };
+  protoOf(Primitives).t2v = function (context) {
+    var tmp0_$this = ensureNotNull(this.l2v_1);
+    var tmp1_primitives = this.k2v_1;
+    // Inline function 'kotlin.Long.plus' call
+    var this_0 = context.x2u_1;
+    var tmp2_step = add(this_0, fromInt(1));
+    var tmp3_startTime = context.s2u_1;
+    var tmp4_flags = context.g2u_1;
+    var tmp5_dynamicKb = context.i2u_1;
+    var tmp6_staticKb = context.h2u_1;
+    var tmp7_operators = context.j2u_1;
+    var tmp8_inputChannels = context.k2u_1;
+    var tmp9_outputChannels = context.l2u_1;
+    var tmp10_libraries = context.f2u_1;
+    var tmp11_customData = context.m2u_1.discardEphemeral();
+    var tempContext = tmp0_$this.u2v(VOID, VOID, tmp10_libraries, tmp4_flags, tmp6_staticKb, tmp5_dynamicKb, tmp7_operators, tmp8_inputChannels, tmp9_outputChannels, tmp11_customData, VOID, VOID, VOID, VOID, tmp1_primitives, tmp3_startTime, VOID, VOID, VOID, VOID, tmp2_step);
+    var nextChoicePointContext = this.v2v(this.k2v_1.ro(), tempContext);
+    return tempContext.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, nextChoicePointContext);
+  };
+  protoOf(Primitives).w2v = function (alternatives, executionContext, parent, depth) {
+    return new Primitives(alternatives, executionContext, parent, depth);
+  };
+  protoOf(Primitives).v2v = function (alternatives, executionContext, parent, depth, $super) {
+    alternatives = alternatives === VOID ? this.k2v_1 : alternatives;
+    executionContext = executionContext === VOID ? this.l2v_1 : executionContext;
+    parent = parent === VOID ? this.m2v_1 : parent;
+    depth = depth === VOID ? this.n2v_1 : depth;
+    return $super === VOID ? this.w2v(alternatives, executionContext, parent, depth) : $super.w2v.call(this, alternatives, executionContext, parent, depth);
+  };
+  protoOf(Primitives).hashCode = function () {
+    var result = hashCode(this.k2v_1);
+    result = imul(result, 31) + (this.l2v_1 == null ? 0 : this.l2v_1.hashCode()) | 0;
+    result = imul(result, 31) + (this.m2v_1 == null ? 0 : hashCode(this.m2v_1)) | 0;
+    result = imul(result, 31) + this.n2v_1 | 0;
+    return result;
+  };
+  protoOf(Primitives).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Primitives))
+      return false;
+    if (!equals(this.k2v_1, other.k2v_1))
+      return false;
+    if (!equals(this.l2v_1, other.l2v_1))
+      return false;
+    if (!equals(this.m2v_1, other.m2v_1))
+      return false;
+    if (!(this.n2v_1 === other.n2v_1))
+      return false;
+    return true;
+  };
+  function Rules(alternatives, executionContext, parent, depth) {
+    ChoicePointContext.call(this, alternatives, executionContext, parent, depth);
+    this.j2w_1 = alternatives;
+    this.k2w_1 = executionContext;
+    this.l2w_1 = parent;
+    this.m2w_1 = depth;
+  }
+  protoOf(Rules).o2v = function () {
+    return this.j2w_1;
+  };
+  protoOf(Rules).p2v = function () {
+    return this.k2w_1;
+  };
+  protoOf(Rules).q2v = function () {
+    return this.l2w_1;
+  };
+  protoOf(Rules).r2v = function () {
+    return this.m2w_1;
+  };
+  protoOf(Rules).toString = function () {
+    return protoOf(ChoicePointContext).toString.call(this);
+  };
+  protoOf(Rules).s2v = function () {
+    return 'Rules';
+  };
+  protoOf(Rules).t2v = function (context) {
+    var tmp0_$this = ensureNotNull(this.k2w_1);
+    var tmp1_rules = this.j2w_1;
+    // Inline function 'kotlin.Long.plus' call
+    var this_0 = context.x2u_1;
+    var tmp2_step = add(this_0, fromInt(1));
+    var tmp3_startTime = context.s2u_1;
+    var tmp4_flags = context.g2u_1;
+    var tmp5_dynamicKb = context.i2u_1;
+    var tmp6_staticKb = context.h2u_1;
+    var tmp7_operators = context.j2u_1;
+    var tmp8_inputChannels = context.k2u_1;
+    var tmp9_outputChannels = context.l2u_1;
+    var tmp10_libraries = context.f2u_1;
+    var tmp11_customData = context.m2u_1.discardEphemeral();
+    var tempContext = tmp0_$this.u2v(VOID, VOID, tmp10_libraries, tmp4_flags, tmp6_staticKb, tmp5_dynamicKb, tmp7_operators, tmp8_inputChannels, tmp9_outputChannels, tmp11_customData, VOID, VOID, VOID, tmp1_rules, VOID, tmp3_startTime, VOID, VOID, VOID, VOID, tmp2_step);
+    var nextChoicePointContext = this.n2w(this.j2w_1.ro(), tempContext);
+    return tempContext.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, nextChoicePointContext);
+  };
+  protoOf(Rules).o2w = function (alternatives, executionContext, parent, depth) {
+    return new Rules(alternatives, executionContext, parent, depth);
+  };
+  protoOf(Rules).n2w = function (alternatives, executionContext, parent, depth, $super) {
+    alternatives = alternatives === VOID ? this.j2w_1 : alternatives;
+    executionContext = executionContext === VOID ? this.k2w_1 : executionContext;
+    parent = parent === VOID ? this.l2w_1 : parent;
+    depth = depth === VOID ? this.m2w_1 : depth;
+    return $super === VOID ? this.o2w(alternatives, executionContext, parent, depth) : $super.o2w.call(this, alternatives, executionContext, parent, depth);
+  };
+  protoOf(Rules).hashCode = function () {
+    var result = hashCode(this.j2w_1);
+    result = imul(result, 31) + (this.k2w_1 == null ? 0 : this.k2w_1.hashCode()) | 0;
+    result = imul(result, 31) + (this.l2w_1 == null ? 0 : hashCode(this.l2w_1)) | 0;
+    result = imul(result, 31) + this.m2w_1 | 0;
+    return result;
+  };
+  protoOf(Rules).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Rules))
+      return false;
+    if (!equals(this.j2w_1, other.j2w_1))
+      return false;
+    if (!equals(this.k2w_1, other.k2w_1))
+      return false;
+    if (!equals(this.l2w_1, other.l2w_1))
+      return false;
+    if (!(this.m2w_1 === other.m2w_1))
+      return false;
+    return true;
+  };
+  function ChoicePointContext$_get_pathToRoot_$slambda_q0myjn(this$0, resultContinuation) {
+    this.x2w_1 = this$0;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(ChoicePointContext$_get_pathToRoot_$slambda_q0myjn).a2x = function ($this$sequence, $completion) {
+    var tmp = this.b2x($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(ChoicePointContext$_get_pathToRoot_$slambda_q0myjn).f9 = function (p1, $completion) {
+    return this.a2x(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(ChoicePointContext$_get_pathToRoot_$slambda_q0myjn).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 4;
+            this.z2w_1 = this.x2w_1;
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!!(this.z2w_1 == null)) {
+              this.g8_1 = 3;
+              continue $sm;
+            }
+
+            this.g8_1 = 2;
+            suspendResult = this.y2w_1.nc(ensureNotNull(this.z2w_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.z2w_1 = this.z2w_1.q2v();
+            this.g8_1 = 1;
+            continue $sm;
+          case 3:
+            return Unit_instance;
+          case 4:
+            throw this.j8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 4) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(ChoicePointContext$_get_pathToRoot_$slambda_q0myjn).b2x = function ($this$sequence, completion) {
+    var i = new ChoicePointContext$_get_pathToRoot_$slambda_q0myjn(this.x2w_1, completion);
+    i.y2w_1 = $this$sequence;
+    return i;
+  };
+  function ChoicePointContext$_get_pathToRoot_$slambda_q0myjn_0(this$0, resultContinuation) {
+    var i = new ChoicePointContext$_get_pathToRoot_$slambda_q0myjn(this$0, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.a2x($this$sequence, $completion);
+    }, 1);
+  }
+  function ChoicePointContext(alternatives, executionContext, parent, depth) {
+    depth = depth === VOID ? 0 : depth;
+    this.x2v_1 = alternatives;
+    this.y2v_1 = executionContext;
+    this.z2v_1 = parent;
+    this.a2w_1 = depth;
+  }
+  protoOf(ChoicePointContext).o2v = function () {
+    return this.x2v_1;
+  };
+  protoOf(ChoicePointContext).p2v = function () {
+    return this.y2v_1;
+  };
+  protoOf(ChoicePointContext).q2v = function () {
+    return this.z2v_1;
+  };
+  protoOf(ChoicePointContext).r2v = function () {
+    return this.a2w_1;
+  };
+  protoOf(ChoicePointContext).b2w = function () {
+    var tmp0 = this.c2w();
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.any' call
+      var _iterator__ex2g4s = tmp0.m();
+      while (_iterator__ex2g4s.p()) {
+        var element = _iterator__ex2g4s.q();
+        if (element.o2v().to()) {
+          tmp$ret$0 = true;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = false;
+    }
+    return tmp$ret$0;
+  };
+  protoOf(ChoicePointContext).c2w = function () {
+    return sequence(ChoicePointContext$_get_pathToRoot_$slambda_q0myjn_0(this, null));
+  };
+  protoOf(ChoicePointContext).d2w = function () {
+    var tmp0_safe_receiver = this.p2v();
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.w2u_1;
+  };
+  protoOf(ChoicePointContext).e2w = function () {
+    var tmp0_safe_receiver = this.p2v();
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.d2u_1;
+  };
+  protoOf(ChoicePointContext).toString = function () {
+    var tmp = this.s2v() + '(' + ('alternatives=' + toString(this.o2v()) + ', ');
+    var tmp_0;
+    if (this.p2v() === null) {
+      tmp_0 = 'executionContext=' + toString_0(this.p2v()) + ', ';
+    } else {
+      'executionContextDepth=' + this.d2w() + ', ';
+      tmp_0 = 'executionContextProcedure=' + toString_0(this.e2w()) + ', ';
+    }
+    return tmp + tmp_0 + ('depth=' + this.r2v()) + ')';
+  };
+  function appendRules(_this__u8e3s4, alternatives, executionContext) {
+    executionContext = executionContext === VOID ? null : executionContext;
+    return new Rules(alternatives, executionContext, _this__u8e3s4, nextDepth(_this__u8e3s4));
+  }
+  function nextDepth(_this__u8e3s4) {
+    return _this__u8e3s4 == null ? 0 : _this__u8e3s4.r2v() + 1 | 0;
+  }
+  function appendPrimitives(_this__u8e3s4, alternatives, executionContext) {
+    executionContext = executionContext === VOID ? null : executionContext;
+    return new Primitives(alternatives, executionContext, _this__u8e3s4, nextDepth(_this__u8e3s4));
+  }
+  function _get_locallyInterestingVariables__39cqti($this) {
+    var tmp = asSequence_0($this.y2u_1);
+    var tmp0_safe_receiver = $this.p2u_1.so();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.jt();
+    return plus(tmp, tmp1_elvis_lhs == null ? emptySequence() : tmp1_elvis_lhs);
+  }
+  function _get_interestingVariables__k6uw5o($this) {
+    var tmp0 = $this.b2v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('interestingVariables', 1, tmp, ClassicExecutionContext$_get_interestingVariables_$ref_xwa4zu(), null);
+    return tmp0.c2();
+  }
+  function ClassicExecutionContext$pathToRoot$slambda(this$0, resultContinuation) {
+    this.k2x_1 = this$0;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(ClassicExecutionContext$pathToRoot$slambda).n2x = function ($this$sequence, $completion) {
+    var tmp = this.o2x($this$sequence, $completion);
+    tmp.i8_1 = Unit_instance;
+    tmp.j8_1 = null;
+    return tmp.o8();
+  };
+  protoOf(ClassicExecutionContext$pathToRoot$slambda).f9 = function (p1, $completion) {
+    return this.n2x(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(ClassicExecutionContext$pathToRoot$slambda).o8 = function () {
+    var suspendResult = this.i8_1;
+    $sm: do
+      try {
+        var tmp = this.g8_1;
+        switch (tmp) {
+          case 0:
+            this.h8_1 = 4;
+            this.m2x_1 = this.k2x_1;
+            this.g8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!!(this.m2x_1 == null)) {
+              this.g8_1 = 3;
+              continue $sm;
+            }
+
+            this.g8_1 = 2;
+            suspendResult = this.l2x_1.nc(this.m2x_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.m2x_1 = this.m2x_1.v2u_1;
+            this.g8_1 = 1;
+            continue $sm;
+          case 3:
+            return Unit_instance;
+          case 4:
+            throw this.j8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.h8_1 === 4) {
+          throw e;
+        } else {
+          this.g8_1 = this.h8_1;
+          this.j8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(ClassicExecutionContext$pathToRoot$slambda).o2x = function ($this$sequence, completion) {
+    var i = new ClassicExecutionContext$pathToRoot$slambda(this.k2x_1, completion);
+    i.l2x_1 = $this$sequence;
+    return i;
+  };
+  function ClassicExecutionContext$pathToRoot$slambda_0(this$0, resultContinuation) {
+    var i = new ClassicExecutionContext$pathToRoot$slambda(this$0, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.n2x($this$sequence, $completion);
+    }, 1);
+  }
+  function ClassicExecutionContext$currentGoal$delegate$lambda(this$0) {
+    return function () {
+      var tmp;
+      if (this$0.p2u_1.uo()) {
+        tmp = null;
+      } else {
+        var tmp0_safe_receiver = this$0.p2u_1.so();
+        tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.applySubstitution(this$0.n2u_1);
+      }
+      return tmp;
+    };
+  }
+  function ClassicExecutionContext$_get_currentGoal_$ref_ulveh3() {
+    return constructCallableReference(function (p0) {
+      return p0.p2x();
+    }, 1, 0, 84);
+  }
+  function ClassicExecutionContext$interestingVariables$delegate$lambda$lambda(it) {
+    return _get_locallyInterestingVariables__39cqti(it);
+  }
+  function ClassicExecutionContext$interestingVariables$delegate$lambda(this$0) {
+    return function () {
+      var tmp = plus(_get_locallyInterestingVariables__39cqti(this$0), this$0.o2u_1.jt());
+      return cached(distinct(plus(tmp, flatMap(this$0.z2u_1, ClassicExecutionContext$interestingVariables$delegate$lambda$lambda))));
+    };
+  }
+  function ClassicExecutionContext$_get_interestingVariables_$ref_xwa4zu() {
+    return constructCallableReference(function (p0) {
+      return _get_interestingVariables__k6uw5o(p0);
+    }, 1, 0, 85);
+  }
+  function ClassicExecutionContext$logicStackTrace$delegate$lambda$lambda(it) {
+    return it.q2x();
+  }
+  function ClassicExecutionContext$logicStackTrace$delegate$lambda$lambda_0(this$0) {
+    return function (it) {
+      var tmp0_elvis_lhs = it.d2u_1;
+      return tmp0_elvis_lhs == null ? Companion_getInstance_1().of('?-', [this$0.o2u_1]) : tmp0_elvis_lhs;
+    };
+  }
+  function ClassicExecutionContext$logicStackTrace$delegate$lambda(this$0) {
+    return function () {
+      var tmp = filter(this$0.z2u_1, ClassicExecutionContext$logicStackTrace$delegate$lambda$lambda);
+      return toList(map(tmp, ClassicExecutionContext$logicStackTrace$delegate$lambda$lambda_0(this$0)));
+    };
+  }
+  function ClassicExecutionContext$_get_logicStackTrace_$ref_p35zx2() {
+    return constructCallableReference(function (p0) {
+      return p0.r1r();
+    }, 1, 0, 86);
+  }
+  function ClassicExecutionContext(procedure, unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, substitution, query, goals, rules, primitives, startTime, maxDuration, choicePoints, parent, depth, step, relevantVariables) {
+    procedure = procedure === VOID ? null : procedure;
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    staticKb = staticKb === VOID ? Companion_instance_0.empty(unificator) : staticKb;
+    dynamicKb = dynamicKb === VOID ? Companion_instance_1.empty(unificator) : dynamicKb;
+    operators = operators === VOID ? toOperatorSet(getAllOperators(libraries, [staticKb, dynamicKb])) : operators;
+    inputChannels = inputChannels === VOID ? Companion_instance_4.fromStandard() : inputChannels;
+    outputChannels = outputChannels === VOID ? Companion_instance_5.fromStandard() : outputChannels;
+    customData = customData === VOID ? Companion_instance_6.empty() : customData;
+    substitution = substitution === VOID ? Companion_getInstance_2().empty() : substitution;
+    query = query === VOID ? Companion_getInstance_3().ys_1 : query;
+    goals = goals === VOID ? Companion_instance_7.empty() : goals;
+    rules = rules === VOID ? Companion_instance_7.empty() : rules;
+    primitives = primitives === VOID ? Companion_instance_7.empty() : primitives;
+    maxDuration = maxDuration === VOID ? new Long(-1, 2147483647) : maxDuration;
+    choicePoints = choicePoints === VOID ? null : choicePoints;
+    parent = parent === VOID ? null : parent;
+    depth = depth === VOID ? 0 : depth;
+    step = step === VOID ? new Long(0, 0) : step;
+    relevantVariables = relevantVariables === VOID ? emptySet() : relevantVariables;
+    this.d2u_1 = procedure;
+    this.e2u_1 = unificator;
+    this.f2u_1 = libraries;
+    this.g2u_1 = flags;
+    this.h2u_1 = staticKb;
+    this.i2u_1 = dynamicKb;
+    this.j2u_1 = operators;
+    this.k2u_1 = inputChannels;
+    this.l2u_1 = outputChannels;
+    this.m2u_1 = customData;
+    this.n2u_1 = substitution;
+    this.o2u_1 = query;
+    this.p2u_1 = goals;
+    this.q2u_1 = rules;
+    this.r2u_1 = primitives;
+    this.s2u_1 = startTime;
+    this.t2u_1 = maxDuration;
+    this.u2u_1 = choicePoints;
+    this.v2u_1 = parent;
+    this.w2u_1 = depth;
+    this.x2u_1 = step;
+    this.y2u_1 = relevantVariables;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!(this.w2u_1 === 0 && this.v2u_1 == null || (this.w2u_1 > 0 && !(this.v2u_1 == null)))) {
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!(compare(this.s2u_1, new Long(0, 0)) >= 0)) {
+      var message_0 = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!(compare(this.t2u_1, new Long(0, 0)) >= 0)) {
+      var message_1 = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+    var tmp = this;
+    tmp.z2u_1 = sequence(ClassicExecutionContext$pathToRoot$slambda_0(this, null));
+    var tmp_0 = this;
+    tmp_0.a2v_1 = lazy(ClassicExecutionContext$currentGoal$delegate$lambda(this));
+    var tmp_1 = this;
+    tmp_1.b2v_1 = lazy(ClassicExecutionContext$interestingVariables$delegate$lambda(this));
+    var tmp_2 = this;
+    tmp_2.c2v_1 = lazy(ClassicExecutionContext$logicStackTrace$delegate$lambda(this));
+  }
+  protoOf(ClassicExecutionContext).p1r = function () {
+    return this.d2u_1;
+  };
+  protoOf(ClassicExecutionContext).x1h = function () {
+    return this.e2u_1;
+  };
+  protoOf(ClassicExecutionContext).u1r = function () {
+    return this.f2u_1;
+  };
+  protoOf(ClassicExecutionContext).v1r = function () {
+    return this.g2u_1;
+  };
+  protoOf(ClassicExecutionContext).w1r = function () {
+    return this.h2u_1;
+  };
+  protoOf(ClassicExecutionContext).x1r = function () {
+    return this.i2u_1;
+  };
+  protoOf(ClassicExecutionContext).d1s = function () {
+    return this.j2u_1;
+  };
+  protoOf(ClassicExecutionContext).y1r = function () {
+    return this.k2u_1;
+  };
+  protoOf(ClassicExecutionContext).z1r = function () {
+    return this.l2u_1;
+  };
+  protoOf(ClassicExecutionContext).s1r = function () {
+    return this.m2u_1;
+  };
+  protoOf(ClassicExecutionContext).q1r = function () {
+    return this.n2u_1;
+  };
+  protoOf(ClassicExecutionContext).k1r = function () {
+    return this.s2u_1;
+  };
+  protoOf(ClassicExecutionContext).m1r = function () {
+    return this.t2u_1;
+  };
+  protoOf(ClassicExecutionContext).r2x = function () {
+    return this.w2u_1 === 0;
+  };
+  protoOf(ClassicExecutionContext).b2w = function () {
+    var tmp0_safe_receiver = this.u2u_1;
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.b2w();
+    return tmp1_elvis_lhs == null ? false : tmp1_elvis_lhs;
+  };
+  protoOf(ClassicExecutionContext).q2x = function () {
+    return this.v2u_1 == null || (this.w2u_1 - this.v2u_1.w2u_1 | 0) >= 1;
+  };
+  protoOf(ClassicExecutionContext).p2x = function () {
+    var tmp0 = this.a2v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('currentGoal', 1, tmp, ClassicExecutionContext$_get_currentGoal_$ref_ulveh3(), null);
+    return tmp0.c2();
+  };
+  protoOf(ClassicExecutionContext).s2x = function (variable) {
+    return contains(_get_interestingVariables__k6uw5o(this), variable);
+  };
+  protoOf(ClassicExecutionContext).r1r = function () {
+    var tmp0 = this.c2v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('logicStackTrace', 1, tmp, ClassicExecutionContext$_get_logicStackTrace_$ref_p35zx2(), null);
+    return tmp0.c2();
+  };
+  protoOf(ClassicExecutionContext).t1r = function (unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels) {
+    return ClassicSolver_init_$Create$(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, true);
+  };
+  protoOf(ClassicExecutionContext).createSolver = function (unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, $super) {
+    return this.createSolver(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, ($super == null ? true : $super instanceof ClassicExecutionContext) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicExecutionContext).a1s = function (unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels) {
+    return MutableClassicSolver_init_$Create$(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, true);
+  };
+  protoOf(ClassicExecutionContext).createMutableSolver = function (unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, $super) {
+    return this.createMutableSolver(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, ($super == null ? true : $super instanceof ClassicExecutionContext) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicExecutionContext).c1s = function (unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData) {
+    return this.u2v(VOID, unificator, libraries, flags, staticKb, dynamicKb.toMutableTheory(), operators, inputChannels, outputChannels, customData);
+  };
+  protoOf(ClassicExecutionContext).update = function (unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, $super) {
+    return this.update(unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, ($super == null ? true : $super instanceof ClassicExecutionContext) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicExecutionContext).t2x = function (sideEffect) {
+    var tmp = apply.call(this, sideEffect);
+    return tmp instanceof ClassicExecutionContext ? tmp : THROW_CCE();
+  };
+  protoOf(ClassicExecutionContext).apply = function (sideEffect) {
+    return this.t2x(sideEffect);
+  };
+  protoOf(ClassicExecutionContext).u2x = function (sideEffects) {
+    var tmp = applyIterable.call(this, sideEffects);
+    return tmp instanceof ClassicExecutionContext ? tmp : THROW_CCE();
+  };
+  protoOf(ClassicExecutionContext).applyIterable = function (sideEffects) {
+    return this.u2x(sideEffects);
+  };
+  protoOf(ClassicExecutionContext).v2x = function (sideEffects) {
+    var tmp = applySequence.call(this, sideEffects);
+    return tmp instanceof ClassicExecutionContext ? tmp : THROW_CCE();
+  };
+  protoOf(ClassicExecutionContext).applySequence = function (sideEffects) {
+    return this.v2x(sideEffects);
+  };
+  protoOf(ClassicExecutionContext).toString = function () {
+    return 'ClassicExecutionContext(' + ('step=' + this.x2u_1.toString() + ', ') + ('depth=' + this.w2u_1 + ', ') + ('substitution=' + toString(this.n2u_1) + ', ') + ('logicStackTrace=' + toString(this.r1r()) + ', ') + ('goals=' + toString(this.p2u_1) + ', ') + ('rules=' + toString(this.q2u_1) + ', ') + ('primitives=' + toString(this.r2u_1) + ', ') + ('startTime=' + this.s2u_1.toString() + ', ') + ('endTime=' + this.l1r().toString() + ', ') + ('maxDuration=' + this.t2u_1.toString() + ', ') + ('unificator=' + toString(this.e2u_1) + ', ') + ('choicePoints=' + toString_0(this.u2u_1)) + ')';
+  };
+  protoOf(ClassicExecutionContext).w2x = function (procedure, unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, substitution, query, goals, rules, primitives, startTime, maxDuration, choicePoints, parent, depth, step, relevantVariables) {
+    return new ClassicExecutionContext(procedure, unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, substitution, query, goals, rules, primitives, startTime, maxDuration, choicePoints, parent, depth, step, relevantVariables);
+  };
+  protoOf(ClassicExecutionContext).u2v = function (procedure, unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, substitution, query, goals, rules, primitives, startTime, maxDuration, choicePoints, parent, depth, step, relevantVariables, $super) {
+    procedure = procedure === VOID ? this.d2u_1 : procedure;
+    unificator = unificator === VOID ? this.e2u_1 : unificator;
+    libraries = libraries === VOID ? this.f2u_1 : libraries;
+    flags = flags === VOID ? this.g2u_1 : flags;
+    staticKb = staticKb === VOID ? this.h2u_1 : staticKb;
+    dynamicKb = dynamicKb === VOID ? this.i2u_1 : dynamicKb;
+    operators = operators === VOID ? this.j2u_1 : operators;
+    inputChannels = inputChannels === VOID ? this.k2u_1 : inputChannels;
+    outputChannels = outputChannels === VOID ? this.l2u_1 : outputChannels;
+    customData = customData === VOID ? this.m2u_1 : customData;
+    substitution = substitution === VOID ? this.n2u_1 : substitution;
+    query = query === VOID ? this.o2u_1 : query;
+    goals = goals === VOID ? this.p2u_1 : goals;
+    rules = rules === VOID ? this.q2u_1 : rules;
+    primitives = primitives === VOID ? this.r2u_1 : primitives;
+    startTime = startTime === VOID ? this.s2u_1 : startTime;
+    maxDuration = maxDuration === VOID ? this.t2u_1 : maxDuration;
+    choicePoints = choicePoints === VOID ? this.u2u_1 : choicePoints;
+    parent = parent === VOID ? this.v2u_1 : parent;
+    depth = depth === VOID ? this.w2u_1 : depth;
+    step = step === VOID ? this.x2u_1 : step;
+    relevantVariables = relevantVariables === VOID ? this.y2u_1 : relevantVariables;
+    return $super === VOID ? this.w2x(procedure, unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, substitution, query, goals, rules, primitives, startTime, maxDuration, choicePoints, parent, depth, step, relevantVariables) : $super.w2x.call(this, procedure, unificator, libraries, flags, staticKb, dynamicKb, operators, inputChannels, outputChannels, customData, substitution, query, goals, rules, primitives, startTime, maxDuration, choicePoints, parent, depth, step, relevantVariables);
+  };
+  protoOf(ClassicExecutionContext).hashCode = function () {
+    var result = this.d2u_1 == null ? 0 : this.d2u_1.hashCode();
+    result = imul(result, 31) + hashCode(this.e2u_1) | 0;
+    result = imul(result, 31) + hashCode(this.f2u_1) | 0;
+    result = imul(result, 31) + this.g2u_1.hashCode() | 0;
+    result = imul(result, 31) + hashCode(this.h2u_1) | 0;
+    result = imul(result, 31) + hashCode(this.i2u_1) | 0;
+    result = imul(result, 31) + this.j2u_1.hashCode() | 0;
+    result = imul(result, 31) + hashCode(this.k2u_1) | 0;
+    result = imul(result, 31) + hashCode(this.l2u_1) | 0;
+    result = imul(result, 31) + this.m2u_1.hashCode() | 0;
+    result = imul(result, 31) + hashCode(this.n2u_1) | 0;
+    result = imul(result, 31) + this.o2u_1.hashCode() | 0;
+    result = imul(result, 31) + hashCode(this.p2u_1) | 0;
+    result = imul(result, 31) + hashCode(this.q2u_1) | 0;
+    result = imul(result, 31) + hashCode(this.r2u_1) | 0;
+    result = imul(result, 31) + this.s2u_1.hashCode() | 0;
+    result = imul(result, 31) + this.t2u_1.hashCode() | 0;
+    result = imul(result, 31) + (this.u2u_1 == null ? 0 : hashCode(this.u2u_1)) | 0;
+    result = imul(result, 31) + (this.v2u_1 == null ? 0 : this.v2u_1.hashCode()) | 0;
+    result = imul(result, 31) + this.w2u_1 | 0;
+    result = imul(result, 31) + this.x2u_1.hashCode() | 0;
+    result = imul(result, 31) + hashCode(this.y2u_1) | 0;
+    return result;
+  };
+  protoOf(ClassicExecutionContext).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof ClassicExecutionContext))
+      return false;
+    if (!equals(this.d2u_1, other.d2u_1))
+      return false;
+    if (!equals(this.e2u_1, other.e2u_1))
+      return false;
+    if (!equals(this.f2u_1, other.f2u_1))
+      return false;
+    if (!this.g2u_1.equals(other.g2u_1))
+      return false;
+    if (!equals(this.h2u_1, other.h2u_1))
+      return false;
+    if (!equals(this.i2u_1, other.i2u_1))
+      return false;
+    if (!this.j2u_1.equals(other.j2u_1))
+      return false;
+    if (!equals(this.k2u_1, other.k2u_1))
+      return false;
+    if (!equals(this.l2u_1, other.l2u_1))
+      return false;
+    if (!this.m2u_1.equals(other.m2u_1))
+      return false;
+    if (!equals(this.n2u_1, other.n2u_1))
+      return false;
+    if (!this.o2u_1.equals(other.o2u_1))
+      return false;
+    if (!equals(this.p2u_1, other.p2u_1))
+      return false;
+    if (!equals(this.q2u_1, other.q2u_1))
+      return false;
+    if (!equals(this.r2u_1, other.r2u_1))
+      return false;
+    if (!equalsLong(this.s2u_1, other.s2u_1))
+      return false;
+    if (!equalsLong(this.t2u_1, other.t2u_1))
+      return false;
+    if (!equals(this.u2u_1, other.u2u_1))
+      return false;
+    if (!equals(this.v2u_1, other.v2u_1))
+      return false;
+    if (!(this.w2u_1 === other.w2u_1))
+      return false;
+    if (!equalsLong(this.x2u_1, other.x2u_1))
+      return false;
+    if (!equals(this.y2u_1, other.y2u_1))
+      return false;
+    return true;
+  };
+  function ClassicSolver_init_$Init$(unificator, libraries, flags, initialStaticKb, initialDynamicKb, inputChannels, outputChannels, trustKb, $this) {
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    initialStaticKb = initialStaticKb === VOID ? Companion_instance_0.empty(unificator) : initialStaticKb;
+    initialDynamicKb = initialDynamicKb === VOID ? Companion_instance_1.empty(unificator) : initialDynamicKb;
+    inputChannels = inputChannels === VOID ? Companion_instance_4.fromStandard() : inputChannels;
+    outputChannels = outputChannels === VOID ? Companion_instance_5.fromStandard() : outputChannels;
+    trustKb = trustKb === VOID ? false : trustKb;
+    AbstractClassicSolver.call($this, unificator, libraries, flags, initialStaticKb, initialDynamicKb, inputChannels, outputChannels, trustKb);
+    ClassicSolver.call($this);
+    return $this;
+  }
+  function ClassicSolver_init_$Create$(unificator, libraries, flags, initialStaticKb, initialDynamicKb, inputChannels, outputChannels, trustKb) {
+    return ClassicSolver_init_$Init$(unificator, libraries, flags, initialStaticKb, initialDynamicKb, inputChannels, outputChannels, trustKb, objectCreate(protoOf(ClassicSolver)));
+  }
+  function ClassicSolver_init_$Init$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, $this) {
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    staticKb = staticKb === VOID ? Companion_instance_0.empty(unificator) : staticKb;
+    dynamicKb = dynamicKb === VOID ? Companion_instance_1.empty(unificator) : dynamicKb;
+    stdIn = stdIn === VOID ? Companion_instance_2.stdIn() : stdIn;
+    stdOut = stdOut === VOID ? Companion_instance_3.stdOut() : stdOut;
+    stdErr = stdErr === VOID ? Companion_instance_3.stdErr() : stdErr;
+    warnings = warnings === VOID ? Companion_instance_3.warning() : warnings;
+    trustKb = trustKb === VOID ? false : trustKb;
+    AbstractClassicSolver_init_$Init$(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, $this);
+    ClassicSolver.call($this);
+    return $this;
+  }
+  function ClassicSolver_init_$Create$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb) {
+    return ClassicSolver_init_$Init$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, objectCreate(protoOf(ClassicSolver)));
+  }
+  protoOf(ClassicSolver).f2v = function (initialState, onStateTransition) {
+    return Companion_instance_15.y2x(initialState, onStateTransition);
+  };
+  protoOf(ClassicSolver).e1u = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return ClassicSolver_init_$Create$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
+  };
+  protoOf(ClassicSolver).copy = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
+    return this.copy(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof ClassicSolver) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicSolver).m1p = function () {
+    return this.copy();
+  };
+  protoOf(ClassicSolver).clone = function () {
+    return this.m1p();
+  };
+  function ClassicSolver() {
+  }
+  function ClassicSolverFactory() {
+  }
+  protoOf(ClassicSolverFactory).g1u = function () {
+    return DefaultBuiltins_getInstance();
+  };
+  protoOf(ClassicSolverFactory).r1u = function (unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs) {
+    return ClassicSolver_init_$Create$(unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs);
+  };
+  protoOf(ClassicSolverFactory).rawSolverOf = function (unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs, $super) {
+    return this.rawSolverOf(unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs, ($super == null ? true : $super instanceof ClassicSolverFactory) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicSolverFactory).x1u = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return ClassicSolver_init_$Create$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
+  };
+  protoOf(ClassicSolverFactory).solverOf = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
+    return this.solverOf(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof ClassicSolverFactory) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicSolverFactory).z1u = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return MutableClassicSolver_init_$Create$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
+  };
+  protoOf(ClassicSolverFactory).mutableSolverOf = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
+    return this.mutableSolverOf(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof ClassicSolverFactory) ? $super : THROW_CCE());
+  };
+  protoOf(ClassicSolverFactory).b1v = function (unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs) {
+    return MutableClassicSolver_init_$Create$(unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs);
+  };
+  protoOf(ClassicSolverFactory).rawMutableSolverOf = function (unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs, $super) {
+    return this.rawMutableSolverOf(unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs, ($super == null ? true : $super instanceof ClassicSolverFactory) ? $super : THROW_CCE());
+  };
+  var ClassicSolverFactory_instance;
+  function ClassicSolverFactory_getInstance() {
+    return ClassicSolverFactory_instance;
+  }
+  function MutableClassicSolver_init_$Init$(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, trustKb, $this) {
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    staticKb = staticKb === VOID ? Companion_instance_0.empty(unificator) : staticKb;
+    dynamicKb = dynamicKb === VOID ? Companion_instance_1.empty(unificator) : dynamicKb;
+    inputChannels = inputChannels === VOID ? Companion_instance_4.fromStandard() : inputChannels;
+    outputChannels = outputChannels === VOID ? Companion_instance_5.fromStandard() : outputChannels;
+    trustKb = trustKb === VOID ? false : trustKb;
+    ClassicSolver_init_$Init$(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, trustKb, $this);
+    MutableClassicSolver.call($this);
+    return $this;
+  }
+  function MutableClassicSolver_init_$Create$(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, trustKb) {
+    return MutableClassicSolver_init_$Init$(unificator, libraries, flags, staticKb, dynamicKb, inputChannels, outputChannels, trustKb, objectCreate(protoOf(MutableClassicSolver)));
+  }
+  function MutableClassicSolver_init_$Init$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, $this) {
+    unificator = unificator === VOID ? Companion_getInstance().q1h() : unificator;
+    libraries = libraries === VOID ? Companion_instance.empty() : libraries;
+    flags = flags === VOID ? Companion_getInstance_0().empty() : flags;
+    staticKb = staticKb === VOID ? Companion_instance_0.empty(unificator) : staticKb;
+    dynamicKb = dynamicKb === VOID ? Companion_instance_1.empty(unificator) : dynamicKb;
+    stdIn = stdIn === VOID ? Companion_instance_2.stdIn() : stdIn;
+    stdOut = stdOut === VOID ? Companion_instance_3.stdOut() : stdOut;
+    stdErr = stdErr === VOID ? Companion_instance_3.stdErr() : stdErr;
+    warnings = warnings === VOID ? Companion_instance_3.warning() : warnings;
+    trustKb = trustKb === VOID ? false : trustKb;
+    ClassicSolver_init_$Init$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, $this);
+    MutableClassicSolver.call($this);
+    return $this;
+  }
+  function MutableClassicSolver_init_$Create$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb) {
+    return MutableClassicSolver_init_$Init$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, trustKb, objectCreate(protoOf(MutableClassicSolver)));
+  }
+  function MutableClassicSolver$loadLibrary$lambda($library) {
+    return function ($this$updateContext) {
+      var newRuntime = $this$updateContext.f2u_1.plusLibrary($library);
+      return $this$updateContext.u2v(VOID, VOID, newRuntime, VOID, VOID, VOID, $this$updateContext.j2u_1.plusOperatorSet(toOperatorSet(getAllOperators(newRuntime, []))));
+    };
+  }
+  function MutableClassicSolver$unloadLibrary$lambda($library) {
+    return function ($this$updateContext) {
+      var newRuntime = $this$updateContext.f2u_1.plusLibrary($library);
+      return $this$updateContext.u2v(VOID, VOID, newRuntime, VOID, VOID, VOID, toOperatorSet(getAllOperators(newRuntime, [$this$updateContext.h2u_1, $this$updateContext.i2u_1])));
+    };
+  }
+  function MutableClassicSolver$setRuntime$lambda($libraries) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, $libraries, VOID, VOID, VOID, toOperatorSet(getAllOperators($libraries, [$this$updateContext.h2u_1, $this$updateContext.i2u_1])));
+    };
+  }
+  function MutableClassicSolver$resetStaticKb$lambda($this$updateContext) {
+    return $this$updateContext.u2v(VOID, VOID, VOID, VOID, Companion_instance_0.empty($this$updateContext.e2u_1), VOID, toOperatorSet(getAllOperators($this$updateContext.f2u_1, [$this$updateContext.i2u_1])));
+  }
+  function MutableClassicSolver$resetDynamicKb$lambda($this$updateContext) {
+    return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, Companion_instance_1.empty($this$updateContext.e2u_1), toOperatorSet(getAllOperators($this$updateContext.f2u_1, [$this$updateContext.h2u_1])));
+  }
+  function MutableClassicSolver$assertA$lambda($clause) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $this$updateContext.i2u_1.c1p($clause), $this$updateContext.j2u_1.plusOperatorSet(toOperatorSet(getAllOperators_0(listOf($clause)))));
+    };
+  }
+  function MutableClassicSolver$assertA$lambda_0($fact) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $this$updateContext.i2u_1.b1q($fact));
+    };
+  }
+  function MutableClassicSolver$assertZ$lambda($clause) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $this$updateContext.i2u_1.g1p($clause), $this$updateContext.j2u_1.plusOperatorSet(toOperatorSet(getAllOperators_0(listOf($clause)))));
+    };
+  }
+  function MutableClassicSolver$assertZ$lambda_0($fact) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $this$updateContext.i2u_1.c1q($fact));
+    };
+  }
+  function MutableClassicSolver$retract$lambda($result, $clause) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $result.u1o().toMutableTheory(), $this$updateContext.j2u_1.minusOperatorSet(toOperatorSet(getAllOperators_0(listOf($clause)))));
+    };
+  }
+  function MutableClassicSolver$retract$lambda_0($result) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $result.u1o().toMutableTheory());
+    };
+  }
+  function MutableClassicSolver$retractAll$lambda($result) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $result.u1o().toMutableTheory(), $this$updateContext.j2u_1.minusOperatorSet(toOperatorSet(getAllOperators_0($result.u1o()))));
+    };
+  }
+  function MutableClassicSolver$retractAll$lambda_0($result) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, $result.u1o().toMutableTheory());
+    };
+  }
+  function MutableClassicSolver$setFlag$lambda($name, $value) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, $this$updateContext.g2u_1.set($name, $value));
+    };
+  }
+  function MutableClassicSolver$setFlag$lambda_0($flag) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, $this$updateContext.g2u_1.plusPair($flag));
+    };
+  }
+  function MutableClassicSolver$setFlag$lambda_1($flag) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, $this$updateContext.g2u_1.plusNotable($flag));
+    };
+  }
+  function MutableClassicSolver$setStandardInput$lambda($stdIn) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this$updateContext.k2u_1.plus(to('stdin', $stdIn)));
+    };
+  }
+  function MutableClassicSolver$setStandardError$lambda($stdErr) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this$updateContext.l2u_1.plus(to('stderr', $stdErr)));
+    };
+  }
+  function MutableClassicSolver$setStandardOutput$lambda($stdOut) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this$updateContext.l2u_1.plus(to('stdout', $stdOut)));
+    };
+  }
+  function MutableClassicSolver$setWarnings$lambda($warnings) {
+    return function ($this$updateContext) {
+      return $this$updateContext.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, Companion_instance_5.p1v($this$updateContext.l2u_1, $warnings));
+    };
+  }
+  protoOf(MutableClassicSolver).a2y = function (library) {
+    this.j27(MutableClassicSolver$loadLibrary$lambda(library));
+  };
+  protoOf(MutableClassicSolver).loadLibrary = function (library) {
+    return this.a2y(library);
+  };
+  protoOf(MutableClassicSolver).b2y = function (library) {
+    this.j27(MutableClassicSolver$unloadLibrary$lambda(library));
+  };
+  protoOf(MutableClassicSolver).unloadLibrary = function (library) {
+    return this.b2y(library);
+  };
+  protoOf(MutableClassicSolver).c2y = function (libraries) {
+    this.j27(MutableClassicSolver$setRuntime$lambda(libraries));
+  };
+  protoOf(MutableClassicSolver).setLibraries = function (libraries) {
+    return this.c2y(libraries);
+  };
+  protoOf(MutableClassicSolver).d2y = function (theory) {
+    this.n27(theory, VOID, false);
+  };
+  protoOf(MutableClassicSolver).loadStaticKb = function (theory) {
+    return this.d2y(theory);
+  };
+  protoOf(MutableClassicSolver).e2y = function (theory) {
+    this.n27(theory);
+  };
+  protoOf(MutableClassicSolver).appendStaticKb = function (theory) {
+    return this.e2y(theory);
+  };
+  protoOf(MutableClassicSolver).f2y = function () {
+    this.j27(MutableClassicSolver$resetStaticKb$lambda);
+  };
+  protoOf(MutableClassicSolver).resetStaticKb = function () {
+    return this.f2y();
+  };
+  protoOf(MutableClassicSolver).g2y = function (theory) {
+    this.n27(VOID, theory, VOID, false);
+  };
+  protoOf(MutableClassicSolver).loadDynamicKb = function (theory) {
+    return this.g2y(theory);
+  };
+  protoOf(MutableClassicSolver).h2y = function (theory) {
+    this.n27(VOID, theory);
+  };
+  protoOf(MutableClassicSolver).appendDynamicKb = function (theory) {
+    return this.h2y(theory);
+  };
+  protoOf(MutableClassicSolver).i2y = function () {
+    this.j27(MutableClassicSolver$resetDynamicKb$lambda);
+  };
+  protoOf(MutableClassicSolver).resetDynamicKb = function () {
+    return this.i2y();
+  };
+  protoOf(MutableClassicSolver).j1j = function (clause) {
+    this.j27(MutableClassicSolver$assertA$lambda(clause));
+  };
+  protoOf(MutableClassicSolver).assertA = function (clause) {
+    return this.j1j(clause);
+  };
+  protoOf(MutableClassicSolver).j2y = function (fact) {
+    this.j27(MutableClassicSolver$assertA$lambda_0(fact));
+  };
+  protoOf(MutableClassicSolver).assertAFact = function (fact) {
+    return this.j2y(fact);
+  };
+  protoOf(MutableClassicSolver).k1i = function (clause) {
+    this.j27(MutableClassicSolver$assertZ$lambda(clause));
+  };
+  protoOf(MutableClassicSolver).assertZ = function (clause) {
+    return this.k1i(clause);
+  };
+  protoOf(MutableClassicSolver).k2y = function (fact) {
+    this.j27(MutableClassicSolver$assertZ$lambda_0(fact));
+  };
+  protoOf(MutableClassicSolver).assertZFact = function (fact) {
+    return this.k2y(fact);
+  };
+  protoOf(MutableClassicSolver).d1q = function (clause) {
+    var result = this.x1r().retract(clause);
+    this.j27(MutableClassicSolver$retract$lambda(result, clause));
+    return result;
+  };
+  protoOf(MutableClassicSolver).retract = function (clause) {
+    return this.d1q(clause);
+  };
+  protoOf(MutableClassicSolver).e1q = function (fact) {
+    var result = this.x1r().retractByHead(fact);
+    this.j27(MutableClassicSolver$retract$lambda_0(result));
+    return result;
+  };
+  protoOf(MutableClassicSolver).retractByHead = function (fact) {
+    return this.e1q(fact);
+  };
+  protoOf(MutableClassicSolver).p1i = function (clause) {
+    var result = this.x1r().retractAll(clause);
+    this.j27(MutableClassicSolver$retractAll$lambda(result));
+    return result;
+  };
+  protoOf(MutableClassicSolver).retractAll = function (clause) {
+    return this.p1i(clause);
+  };
+  protoOf(MutableClassicSolver).l2y = function (fact) {
+    var result = this.x1r().retractAllByHead(fact);
+    this.j27(MutableClassicSolver$retractAll$lambda_0(result));
+    return result;
+  };
+  protoOf(MutableClassicSolver).retractAllBeHead = function (fact) {
+    return this.l2y(fact);
+  };
+  protoOf(MutableClassicSolver).m2y = function (name, value) {
+    this.j27(MutableClassicSolver$setFlag$lambda(name, value));
+  };
+  protoOf(MutableClassicSolver).setFlag = function (name, value) {
+    return this.m2y(name, value);
+  };
+  protoOf(MutableClassicSolver).n2y = function (flag) {
+    this.j27(MutableClassicSolver$setFlag$lambda_0(flag));
+  };
+  protoOf(MutableClassicSolver).setFlagPair = function (flag) {
+    return this.n2y(flag);
+  };
+  protoOf(MutableClassicSolver).o2y = function (flag) {
+    this.j27(MutableClassicSolver$setFlag$lambda_1(flag));
+  };
+  protoOf(MutableClassicSolver).setFlagNotable = function (flag) {
+    return this.o2y(flag);
+  };
+  protoOf(MutableClassicSolver).p2y = function (stdIn) {
+    this.j27(MutableClassicSolver$setStandardInput$lambda(stdIn));
+  };
+  protoOf(MutableClassicSolver).setStandardInput = function (stdIn) {
+    return this.p2y(stdIn);
+  };
+  protoOf(MutableClassicSolver).q2y = function (stdErr) {
+    this.j27(MutableClassicSolver$setStandardError$lambda(stdErr));
+  };
+  protoOf(MutableClassicSolver).setStandardError = function (stdErr) {
+    return this.q2y(stdErr);
+  };
+  protoOf(MutableClassicSolver).r2y = function (stdOut) {
+    this.j27(MutableClassicSolver$setStandardOutput$lambda(stdOut));
+  };
+  protoOf(MutableClassicSolver).setStandardOutput = function (stdOut) {
+    return this.r2y(stdOut);
+  };
+  protoOf(MutableClassicSolver).s2y = function (warnings) {
+    this.j27(MutableClassicSolver$setWarnings$lambda(warnings));
+  };
+  protoOf(MutableClassicSolver).setWarnings = function (warnings) {
+    return this.s2y(warnings);
+  };
+  protoOf(MutableClassicSolver).e1u = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return MutableClassicSolver_init_$Create$_0(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
+  };
+  protoOf(MutableClassicSolver).copy = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
+    return this.copy(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof MutableClassicSolver) ? $super : THROW_CCE());
+  };
+  protoOf(MutableClassicSolver).m1p = function () {
+    return this.copy();
+  };
+  protoOf(MutableClassicSolver).clone = function () {
+    return this.m1p();
+  };
+  function MutableClassicSolver() {
+  }
+  function SolutionIterator$Companion$of$lambda(_unused_var__etf5q3, _unused_var__etf5q3_0, _unused_var__etf5q3_1) {
+    return Unit_instance;
+  }
+  function Companion() {
+  }
+  protoOf(Companion).y2x = function (initialState, onStateTransition) {
+    return new SimpleSolutionIterator(initialState, onStateTransition);
+  };
+  protoOf(Companion).of = function (initialState, onStateTransition, $super) {
+    var tmp;
+    if (onStateTransition === VOID) {
+      tmp = SolutionIterator$Companion$of$lambda;
+    } else {
+      tmp = onStateTransition;
+    }
+    onStateTransition = tmp;
+    return $super === VOID ? this.y2x(initialState, onStateTransition) : $super.y2x.call(this, initialState, onStateTransition);
+  };
+  var Companion_instance_15;
+  function Companion_getInstance_5() {
+    return Companion_instance_15;
+  }
+  function AbstractEndState(solution, context) {
+    AbstractState.call(this, context);
+    this.v2y_1 = solution;
+    this.w2y_1 = context;
+  }
+  protoOf(AbstractEndState).j2e = function () {
+    return this.v2y_1;
+  };
+  protoOf(AbstractEndState).m8 = function () {
+    return this.w2y_1;
+  };
+  protoOf(AbstractEndState).x2y = function () {
+    throw NoSuchElementException_init_$Create$();
+  };
+  protoOf(AbstractEndState).asEndState = function () {
+    return this.f2z();
+  };
+  function AbstractState$executionTime$delegate$lambda(this$0) {
+    return function () {
+      return this$0.c2z();
+    };
+  }
+  function AbstractState$_get_executionTime_$ref_gwd5wm() {
+    return constructCallableReference(function (p0) {
+      return p0.a2z();
+    }, 1, 0, 87);
+  }
+  function AbstractState(context) {
+    this.y2y_1 = context;
+    var tmp = this;
+    tmp.z2y_1 = lazy(AbstractState$executionTime$delegate$lambda(this));
+  }
+  protoOf(AbstractState).m8 = function () {
+    return this.y2y_1;
+  };
+  protoOf(AbstractState).a2z = function () {
+    var tmp0 = this.z2y_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('executionTime', 1, tmp, AbstractState$_get_executionTime_$ref_gwd5wm(), null);
+    return tmp0.c2();
+  };
+  protoOf(AbstractState).b2z = function () {
+    return compare(subtract(this.a2z(), this.m8().s2u_1), this.m8().t2u_1) > 0;
+  };
+  protoOf(AbstractState).q = function () {
+    var tmp;
+    if (this.b2z()) {
+      var tmp0_exceededDuration = this.m8().t2u_1;
+      var tmp1_context = this.m8();
+      tmp = new StateHalt(TimeOutException_init_$Create$(VOID, VOID, tmp1_context, tmp0_exceededDuration), this.m8().u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z()));
+    } else {
+      tmp = this.x2y();
+    }
+    return tmp;
+  };
+  protoOf(AbstractState).next = function () {
+    return this.q();
+  };
+  protoOf(AbstractState).c2z = function () {
+    return currentTimeInstant();
+  };
+  protoOf(AbstractState).d2z = function () {
+    // Inline function 'kotlin.Long.plus' call
+    var this_0 = this.m8().x2u_1;
+    return add(this_0, fromInt(1));
+  };
+  protoOf(AbstractState).h2z = function (_this__u8e3s4) {
+    var tmp0 = _this__u8e3s4.z2u_1;
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.first' call
+      var _iterator__ex2g4s = tmp0.m();
+      while (_iterator__ex2g4s.p()) {
+        var element = _iterator__ex2g4s.q();
+        var tmp0_safe_receiver = element.d2u_1;
+        var tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.ht();
+        // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+        if (!(tmp === Throw_getInstance().signature.name)) {
+          tmp$ret$0 = element;
+          break $l$block;
+        }
+      }
+      throw NoSuchElementException_init_$Create$_0('Sequence contains no element matching the predicate.');
+    }
+    return tmp$ret$0;
+  };
+  function EndState() {
+  }
+  function State() {
+  }
+  function StateBacktracking(context) {
+    AbstractState.call(this, context);
+    this.k2z_1 = context;
+  }
+  protoOf(StateBacktracking).m8 = function () {
+    return this.k2z_1;
+  };
+  protoOf(StateBacktracking).x2y = function () {
+    var choicePoints = this.k2z_1.u2u_1;
+    var tmp;
+    // Inline function 'kotlin.let' call
+    if (choicePoints === null || !choicePoints.b2w()) {
+      tmp = new StateEnd(Companion_instance_8.no(this.k2z_1.o2u_1), this.k2z_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z()));
+    } else {
+      var tmp0 = ensureNotNull(choicePoints).c2w();
+      var tmp$ret$2;
+      $l$block: {
+        // Inline function 'kotlin.sequences.first' call
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (element.o2v().to()) {
+            tmp$ret$2 = element;
+            break $l$block;
+          }
+        }
+        throw NoSuchElementException_init_$Create$_0('Sequence contains no element matching the predicate.');
+      }
+      var choicePointContext = tmp$ret$2;
+      var nextContext = choicePointContext.t2v(this.k2z_1);
+      var tmp_0;
+      if (nextContext.r2u_1.to()) {
+        tmp_0 = new StatePrimitiveExecution(nextContext);
+      } else {
+        tmp_0 = new StateRuleExecution(nextContext);
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(StateBacktracking).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StateBacktracking).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateBacktracking) ? $super : THROW_CCE());
+  };
+  protoOf(StateBacktracking).l2z = function (context) {
+    return new StateBacktracking(context);
+  };
+  protoOf(StateBacktracking).toString = function () {
+    return 'StateBacktracking(context=' + this.k2z_1.toString() + ')';
+  };
+  protoOf(StateBacktracking).hashCode = function () {
+    return this.k2z_1.hashCode();
+  };
+  protoOf(StateBacktracking).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateBacktracking))
+      return false;
+    if (!this.k2z_1.equals(other.k2z_1))
+      return false;
+    return true;
+  };
+  function StateEnd(solution, context) {
+    AbstractEndState.call(this, solution, context);
+    this.q2z_1 = solution;
+    this.r2z_1 = context;
+  }
+  protoOf(StateEnd).j2e = function () {
+    return this.q2z_1;
+  };
+  protoOf(StateEnd).m8 = function () {
+    return this.r2z_1;
+  };
+  protoOf(StateEnd).b2z = function () {
+    return false;
+  };
+  protoOf(StateEnd).x2y = function () {
+    var tmp;
+    if (this.r2z_1.b2w()) {
+      var tmp0_$this = this.r2z_1;
+      var tmp1_step = this.d2z();
+      var tmp2_startTime = this.c2z();
+      tmp = new StateBacktracking(tmp0_$this.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, tmp2_startTime, VOID, VOID, VOID, VOID, tmp1_step));
+    } else {
+      tmp = protoOf(AbstractEndState).x2y.call(this);
+    }
+    return tmp;
+  };
+  protoOf(StateEnd).g2z = function (context) {
+    return this.s2z(this.q2z_1, context);
+  };
+  protoOf(StateEnd).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateEnd) ? $super : THROW_CCE());
+  };
+  protoOf(StateEnd).s2z = function (solution, context) {
+    return new StateEnd(solution, context);
+  };
+  protoOf(StateEnd).toString = function () {
+    return 'StateEnd(solution=' + toString(this.q2z_1) + ', context=' + this.r2z_1.toString() + ')';
+  };
+  protoOf(StateEnd).hashCode = function () {
+    var result = hashCode(this.q2z_1);
+    result = imul(result, 31) + this.r2z_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(StateEnd).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateEnd))
+      return false;
+    if (!equals(this.q2z_1, other.q2z_1))
+      return false;
+    if (!this.r2z_1.equals(other.r2z_1))
+      return false;
+    return true;
+  };
+  protoOf(StateEnd).asEndState = function () {
+    return this.f2z();
+  };
+  function isCatch($this, $receiver) {
+    var tmp;
+    if ($receiver.bt() === 3) {
+      var tmp_0 = $receiver.ht();
+      // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+      tmp = tmp_0 === Catch_getInstance().signature.name;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  function getExceptionContent($this, $receiver) {
+    var tmp;
+    if ($receiver instanceof MessageError) {
+      tmp = $receiver.c23();
+    } else {
+      tmp = $receiver.e21();
+    }
+    return tmp;
+  }
+  function toPublicException($this, $receiver) {
+    var tmp;
+    if ($receiver instanceof MessageError) {
+      tmp = Companion_instance_9.forUncaughtError($receiver);
+    } else {
+      tmp = $receiver;
+    }
+    return tmp;
+  }
+  function _get_finalState__3aigq8($this) {
+    return new StateHalt(toPublicException($this, $this.v2z_1), $this.w2z_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function _get_handleExceptionInParentContext__yj3v4e($this) {
+    return new StateException($this.v2z_1, ensureNotNull($this.w2z_1.v2u_1).u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function handleStruct($this, unificator, catchGoal, error) {
+    var tmp;
+    if (isCatch($this, catchGoal)) {
+      var catcher = unificator.mgu(catchGoal.get(1), getExceptionContent($this, error));
+      tmp = handleCatch($this, catchGoal, catcher);
+    } else if ($this.w2z_1.r2x()) {
+      tmp = _get_finalState__3aigq8($this);
+    } else {
+      tmp = _get_handleExceptionInParentContext__yj3v4e($this);
+    }
+    return tmp;
+  }
+  function handleCatch($this, catchGoal, catcher) {
+    var tmp;
+    if (catcher.lz()) {
+      var tmp_0 = $this.w2z_1.n2u_1.plus(catcher);
+      var newSubstitution = tmp_0.filterEntry(StateException$handleCatch$lambda($this));
+      var subGoals = catchGoal.get(2).getSubstituted(newSubstitution, []);
+      var newGoals = plus_0(toGoals(subGoals), $this.w2z_1.p2u_1.ro());
+      var tmp0_$this = $this.w2z_1;
+      var tmp1_rules = Companion_instance_7.empty();
+      var tmp2_primitives = Companion_instance_7.empty();
+      var tmp3_substitution = newSubstitution.castToUnifier();
+      var tmp4_step = $this.d2z();
+      tmp = new StateGoalSelection(tmp0_$this.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, tmp3_substitution, VOID, newGoals, tmp1_rules, tmp2_primitives, VOID, VOID, VOID, VOID, VOID, tmp4_step));
+    } else if ($this.w2z_1.r2x()) {
+      tmp = _get_finalState__3aigq8($this);
+    } else {
+      tmp = _get_handleExceptionInParentContext__yj3v4e($this);
+    }
+    return tmp;
+  }
+  function StateException$handleCatch$lambda(this$0) {
+    return function (_destruct__k2r9zo) {
+      // Inline function 'kotlin.collections.component1' call
+      var it = _destruct__k2r9zo.b2();
+      return this$0.w2z_1.s2x(it);
+    };
+  }
+  function StateException(exception, context) {
+    AbstractState.call(this, context);
+    this.v2z_1 = exception;
+    this.w2z_1 = context;
+  }
+  protoOf(StateException).m8 = function () {
+    return this.w2z_1;
+  };
+  protoOf(StateException).x2y = function () {
+    var tmp;
+    if (this.v2z_1 instanceof LogicError) {
+      var catchGoal = ensureNotNull(this.w2z_1.p2x());
+      tmp = catchGoal.nt() ? handleStruct(this, this.w2z_1.e2u_1, catchGoal.castToStruct(), this.v2z_1) : this.w2z_1.r2x() ? _get_finalState__3aigq8(this) : _get_handleExceptionInParentContext__yj3v4e(this);
+    } else {
+      tmp = _get_finalState__3aigq8(this);
+    }
+    return tmp;
+  };
+  protoOf(StateException).g2z = function (context) {
+    return this.x2z(this.v2z_1, context);
+  };
+  protoOf(StateException).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateException) ? $super : THROW_CCE());
+  };
+  protoOf(StateException).x2z = function (exception, context) {
+    return new StateException(exception, context);
+  };
+  protoOf(StateException).toString = function () {
+    return 'StateException(exception=' + this.v2z_1.toString() + ', context=' + this.w2z_1.toString() + ')';
+  };
+  protoOf(StateException).hashCode = function () {
+    var result = hashCode(this.v2z_1);
+    result = imul(result, 31) + this.w2z_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(StateException).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateException))
+      return false;
+    if (!equals(this.v2z_1, other.v2z_1))
+      return false;
+    if (!this.w2z_1.equals(other.w2z_1))
+      return false;
+    return true;
+  };
+  function StateGoalSelection$computeNext$lambda(this$0) {
+    return function (_destruct__k2r9zo) {
+      // Inline function 'kotlin.collections.component1' call
+      var it = _destruct__k2r9zo.b2();
+      return this$0.a30_1.s2x(it);
+    };
+  }
+  function StateGoalSelection(context) {
+    AbstractState.call(this, context);
+    this.a30_1 = context;
+  }
+  protoOf(StateGoalSelection).m8 = function () {
+    return this.a30_1;
+  };
+  protoOf(StateGoalSelection).x2y = function () {
+    var tmp;
+    if (this.a30_1.p2u_1.uo()) {
+      var tmp_0;
+      if (this.a30_1.r2x()) {
+        tmp_0 = new StateEnd(Companion_instance_8.f1t(this.a30_1.o2u_1, this.a30_1.n2u_1), this.a30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z()));
+      } else {
+        // Inline function 'kotlin.let' call
+        var it = ensureNotNull(this.a30_1.v2u_1);
+        var tmp0_choicePoints = this.a30_1.u2u_1;
+        var tmp1_flags = this.a30_1.g2u_1;
+        var tmp2_dynamicKb = this.a30_1.i2u_1;
+        var tmp3_staticKb = this.a30_1.h2u_1;
+        var tmp4_substitution = this.a30_1.n2u_1.fz(StateGoalSelection$computeNext$lambda(this));
+        var tmp5_goals = it.p2u_1.ro();
+        var tmp6_procedure = it.d2u_1;
+        var tmp7_step = this.d2z();
+        var tmp8_startTime = this.a30_1.s2u_1;
+        var tmp9_operators = this.a30_1.j2u_1;
+        var tmp10_inputChannels = this.a30_1.k2u_1;
+        var tmp11_outputChannels = this.a30_1.l2u_1;
+        var tmp12_libraries = this.a30_1.f2u_1;
+        var tmp13_customData = this.a30_1.m2u_1;
+        var tmp$ret$0 = it.u2v(tmp6_procedure, VOID, tmp12_libraries, tmp1_flags, tmp3_staticKb, tmp2_dynamicKb, tmp9_operators, tmp10_inputChannels, tmp11_outputChannels, tmp13_customData, tmp4_substitution, VOID, tmp5_goals, VOID, VOID, tmp8_startTime, VOID, tmp0_choicePoints, VOID, VOID, tmp7_step);
+        tmp_0 = new StateGoalSelection(tmp$ret$0);
+      }
+      tmp = tmp_0;
+    } else if (equals(this.a30_1.g2u_1.get(TrackVariables_getInstance()), TrackVariables_getInstance().j25_1)) {
+      tmp = new StatePrimitiveSelection(this.a30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z(), plus_1(this.a30_1.y2u_1, toSet(ensureNotNull(this.a30_1.p2u_1.so()).jt()))));
+    } else {
+      tmp = new StatePrimitiveSelection(this.a30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z()));
+    }
+    return tmp;
+  };
+  protoOf(StateGoalSelection).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StateGoalSelection).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateGoalSelection) ? $super : THROW_CCE());
+  };
+  protoOf(StateGoalSelection).l2z = function (context) {
+    return new StateGoalSelection(context);
+  };
+  protoOf(StateGoalSelection).toString = function () {
+    return 'StateGoalSelection(context=' + this.a30_1.toString() + ')';
+  };
+  protoOf(StateGoalSelection).hashCode = function () {
+    return this.a30_1.hashCode();
+  };
+  protoOf(StateGoalSelection).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateGoalSelection))
+      return false;
+    if (!this.a30_1.equals(other.a30_1))
+      return false;
+    return true;
+  };
+  function StateHalt(exception, context) {
+    AbstractEndState.call(this, Companion_instance_8.halt(context.o2u_1, exception), context);
+    this.f30_1 = exception;
+    this.g30_1 = context;
+  }
+  protoOf(StateHalt).m8 = function () {
+    return this.g30_1;
+  };
+  protoOf(StateHalt).g2z = function (context) {
+    return this.x2z(this.f30_1, context);
+  };
+  protoOf(StateHalt).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateHalt) ? $super : THROW_CCE());
+  };
+  protoOf(StateHalt).x2z = function (exception, context) {
+    return new StateHalt(exception, context);
+  };
+  protoOf(StateHalt).toString = function () {
+    return 'StateHalt(exception=' + this.f30_1.toString() + ', context=' + this.g30_1.toString() + ')';
+  };
+  protoOf(StateHalt).hashCode = function () {
+    var result = hashCode(this.f30_1);
+    result = imul(result, 31) + this.g30_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(StateHalt).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateHalt))
+      return false;
+    if (!equals(this.f30_1, other.f30_1))
+      return false;
+    if (!this.g30_1.equals(other.g30_1))
+      return false;
+    return true;
+  };
+  protoOf(StateHalt).asEndState = function () {
+    return this.f2z();
+  };
+  function StateInit(context) {
+    AbstractState.call(this, context);
+    this.j30_1 = context;
+  }
+  protoOf(StateInit).m8 = function () {
+    return this.j30_1;
+  };
+  protoOf(StateInit).x2y = function () {
+    var tmp0_$this = this.j30_1;
+    var tmp1_goals = toGoals(this.j30_1.o2u_1);
+    var tmp2_rules = Companion_instance_7.empty();
+    var tmp3_primitives = Companion_instance_7.empty();
+    var tmp4_substitution = Companion_getInstance_2().empty();
+    var tmp5_customData = this.j30_1.m2u_1.preservePersistent();
+    var tmp6_relevantVariables = emptySet();
+    return new StateGoalSelection(appendRulesAndChoicePoints(tmp0_$this.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, tmp5_customData, tmp4_substitution, VOID, tmp1_goals, tmp2_rules, tmp3_primitives, VOID, VOID, null, null, 0, new Long(1, 0), tmp6_relevantVariables), Companion_instance_7.empty()));
+  };
+  protoOf(StateInit).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StateInit).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateInit) ? $super : THROW_CCE());
+  };
+  protoOf(StateInit).l2z = function (context) {
+    return new StateInit(context);
+  };
+  protoOf(StateInit).toString = function () {
+    return 'StateInit(context=' + this.j30_1.toString() + ')';
+  };
+  protoOf(StateInit).hashCode = function () {
+    return this.j30_1.hashCode();
+  };
+  protoOf(StateInit).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateInit))
+      return false;
+    if (!this.j30_1.equals(other.j30_1))
+      return false;
+    return true;
+  };
+  function copyFromCurrentPrimitive($this, $receiver, goals, procedureFromAncestor, substitution) {
+    goals = goals === VOID ? null : goals;
+    procedureFromAncestor = procedureFromAncestor === VOID ? 0 : procedureFromAncestor;
+    substitution = substitution === VOID ? null : substitution;
+    var tmp0_safe_receiver = $receiver.r2u_1.so();
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp = $receiver.u2x(tmp0_safe_receiver.sideEffects);
+    }
+    var tmp1_elvis_lhs = tmp;
+    var ctx = tmp1_elvis_lhs == null ? $receiver : tmp1_elvis_lhs;
+    var tmp4_goals = goals == null ? $receiver.p2u_1 : goals;
+    var tmp_0 = drop($receiver.z2u_1, procedureFromAncestor);
+    var tmp5_procedure = first(map(tmp_0, StatePrimitiveExecution$copyFromCurrentPrimitive$lambda));
+    var tmp6_primitives = Companion_instance_7.empty();
+    var tmp_1 = substitution == null ? $receiver.n2u_1 : substitution;
+    var tmp7_substitution = isInterface(tmp_1, Unifier) ? tmp_1 : THROW_CCE();
+    var tmp8_step = $this.d2z();
+    return ctx.u2v(tmp5_procedure, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, tmp7_substitution, VOID, tmp4_goals, VOID, tmp6_primitives, VOID, VOID, VOID, VOID, VOID, tmp8_step);
+  }
+  function StatePrimitiveExecution$copyFromCurrentPrimitive$lambda(it) {
+    return it.d2u_1;
+  }
+  function StatePrimitiveExecution$computeNext$lambda(this$0) {
+    return function (it) {
+      return new StateGoalSelection(copyFromCurrentPrimitive(this$0, this$0.m30_1, this$0.m30_1.p2u_1.ro(), 1, this$0.m30_1.e2u_1.mergeWithOccurCheck(this$0.m30_1.n2u_1, it.q1r(), false)));
+    };
+  }
+  function StatePrimitiveExecution$computeNext$lambda_0(this$0) {
+    return function (it) {
+      return new StateBacktracking(copyFromCurrentPrimitive(this$0, ensureNotNull(this$0.m30_1.v2u_1)));
+    };
+  }
+  function StatePrimitiveExecution$computeNext$lambda_1(this$0) {
+    return function (it) {
+      return new StateException(it.v1s().updateLastContext(this$0.h2z(this$0.m30_1)), copyFromCurrentPrimitive(this$0, this$0.m30_1));
+    };
+  }
+  function StatePrimitiveExecution$computeNext$lambda_2(it) {
+    throw IllegalStateException_init_$Create$('This should never happen');
+  }
+  function StatePrimitiveExecution(context) {
+    AbstractState.call(this, context);
+    this.m30_1 = context;
+  }
+  protoOf(StatePrimitiveExecution).m8 = function () {
+    return this.m30_1;
+  };
+  protoOf(StatePrimitiveExecution).x2y = function () {
+    var tmp;
+    try {
+      var tmp0_safe_receiver = this.m30_1.r2u_1.so();
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.solution;
+      var tmp_0;
+      if (tmp1_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        var tmp_1 = StatePrimitiveExecution$computeNext$lambda(this);
+        var tmp_2 = StatePrimitiveExecution$computeNext$lambda_0(this);
+        var tmp_3 = StatePrimitiveExecution$computeNext$lambda_1(this);
+        tmp_0 = tmp1_safe_receiver.z1s(tmp_1, tmp_2, tmp_3, StatePrimitiveExecution$computeNext$lambda_2);
+      }
+      var tmp2_elvis_lhs = tmp_0;
+      tmp = tmp2_elvis_lhs == null ? new StateBacktracking(copyFromCurrentPrimitive(this, this.m30_1)) : tmp2_elvis_lhs;
+    } catch ($p) {
+      var tmp_4;
+      if ($p instanceof ResolutionException) {
+        var exception = $p;
+        tmp_4 = new StateException(exception.updateLastContext(this.h2z(this.m30_1)), this.m30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z()));
+      } else {
+        throw $p;
+      }
+      tmp = tmp_4;
+    }
+    return tmp;
+  };
+  protoOf(StatePrimitiveExecution).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StatePrimitiveExecution).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StatePrimitiveExecution) ? $super : THROW_CCE());
+  };
+  protoOf(StatePrimitiveExecution).l2z = function (context) {
+    return new StatePrimitiveExecution(context);
+  };
+  protoOf(StatePrimitiveExecution).toString = function () {
+    return 'StatePrimitiveExecution(context=' + this.m30_1.toString() + ')';
+  };
+  protoOf(StatePrimitiveExecution).hashCode = function () {
+    return this.m30_1.hashCode();
+  };
+  protoOf(StatePrimitiveExecution).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StatePrimitiveExecution))
+      return false;
+    if (!this.m30_1.equals(other.m30_1))
+      return false;
+    return true;
+  };
+  function exceptionalState($this, exception) {
+    return new StateException(exception, $this.p30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function StatePrimitiveSelection(context) {
+    AbstractState.call(this, context);
+    this.p30_1 = context;
+  }
+  protoOf(StatePrimitiveSelection).m8 = function () {
+    return this.p30_1;
+  };
+  protoOf(StatePrimitiveSelection).x2y = function () {
+    // Inline function 'kotlin.with' call
+    var $this$with = this.p30_1;
+    var goal = ensureNotNull($this$with.p2x());
+    var tmp;
+    if (goal.du()) {
+      tmp = exceptionalState(this, Companion_instance_11.forGoal(this.p30_1, extractSignature(ensureNotNull(this.p30_1.d2u_1)), goal.castToVar()));
+    } else if (goal.nt()) {
+      var goalStruct = goal.castToStruct();
+      var signature = extractSignature(goalStruct);
+      var tmp_0;
+      if ($this$with.f2u_1.hasPrimitive(signature)) {
+        var childContext = createChild($this$with);
+        var tmp_1;
+        try {
+          var request = toRequest(childContext, goalStruct, signature, this.a2z());
+          var tmp0_elvis_lhs = $this$with.f2u_1.h2a().f2(signature);
+          var tmp_2;
+          if (tmp0_elvis_lhs == null) {
+            // Inline function 'kotlin.error' call
+            var message = 'Inconsistent behaviour of Library.contains and Library.get';
+            throw IllegalStateException_init_$Create$(toString(message));
+          } else {
+            tmp_2 = tmp0_elvis_lhs;
+          }
+          var primitive = tmp_2;
+          var primitiveExecutions = cursor(primitive.solve(request));
+          tmp_1 = new StatePrimitiveExecution(appendPrimitivesAndChoicePoints(childContext, primitiveExecutions));
+        } catch ($p) {
+          var tmp_3;
+          if ($p instanceof ResolutionException) {
+            var exception = $p;
+            tmp_3 = exceptionalState(this, exception.updateLastContext(this.h2z(childContext)));
+          } else {
+            throw $p;
+          }
+          tmp_1 = tmp_3;
+        }
+        tmp_0 = tmp_1;
+      } else {
+        tmp_0 = new StateRuleSelection(this.p30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, this.d2z()));
+      }
+      tmp = tmp_0;
+    } else {
+      var tmp_4 = Companion_instance_10;
+      var tmp1_safe_receiver = this.p30_1.d2u_1;
+      var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : extractSignature(tmp1_safe_receiver);
+      tmp = exceptionalState(this, tmp_4.forGoal(this.p30_1, tmp2_elvis_lhs == null ? new Signature('?-', 1) : tmp2_elvis_lhs, Expected_CALLABLE_getInstance(), goal));
+    }
+    return tmp;
+  };
+  protoOf(StatePrimitiveSelection).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StatePrimitiveSelection).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StatePrimitiveSelection) ? $super : THROW_CCE());
+  };
+  protoOf(StatePrimitiveSelection).l2z = function (context) {
+    return new StatePrimitiveSelection(context);
+  };
+  protoOf(StatePrimitiveSelection).toString = function () {
+    return 'StatePrimitiveSelection(context=' + this.p30_1.toString() + ')';
+  };
+  protoOf(StatePrimitiveSelection).hashCode = function () {
+    return this.p30_1.hashCode();
+  };
+  protoOf(StatePrimitiveSelection).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StatePrimitiveSelection))
+      return false;
+    if (!this.p30_1.equals(other.p30_1))
+      return false;
+    return true;
+  };
+  function _get_failureState__yid9tw($this) {
+    return new StateBacktracking($this.s30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, Companion_instance_7.empty(), VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function StateRuleExecution(context) {
+    AbstractState.call(this, context);
+    this.s30_1 = context;
+  }
+  protoOf(StateRuleExecution).m8 = function () {
+    return this.s30_1;
+  };
+  protoOf(StateRuleExecution).x2y = function () {
+    // Inline function 'kotlin.with' call
+    var $this$with = this.s30_1;
+    var substitution = $this$with.e2u_1.mgu(ensureNotNull($this$with.p2x()), ensureNotNull($this$with.q2u_1.so()).nv());
+    var tmp;
+    if (substitution.lz()) {
+      var newSubstitution = this.s30_1.n2u_1.plus(substitution).castToUnifier();
+      var subGoals = prepareForExecutionWithUnifier(ensureNotNull(this.s30_1.q2u_1.so()), newSubstitution).ov().getSubstituted(newSubstitution, []);
+      var tmp0_$this = this.s30_1;
+      var tmp1_goals = toGoals(subGoals);
+      var tmp2_rules = Companion_instance_7.empty();
+      var tmp3_step = this.d2z();
+      tmp = new StateGoalSelection(tmp0_$this.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, newSubstitution, VOID, tmp1_goals, tmp2_rules, VOID, VOID, VOID, VOID, VOID, VOID, tmp3_step));
+    } else {
+      tmp = _get_failureState__yid9tw(this);
+    }
+    return tmp;
+  };
+  protoOf(StateRuleExecution).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StateRuleExecution).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateRuleExecution) ? $super : THROW_CCE());
+  };
+  protoOf(StateRuleExecution).l2z = function (context) {
+    return new StateRuleExecution(context);
+  };
+  protoOf(StateRuleExecution).toString = function () {
+    return 'StateRuleExecution(context=' + this.s30_1.toString() + ')';
+  };
+  protoOf(StateRuleExecution).hashCode = function () {
+    return this.s30_1.hashCode();
+  };
+  protoOf(StateRuleExecution).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateRuleExecution))
+      return false;
+    if (!this.s30_1.equals(other.s30_1))
+      return false;
+    return true;
+  };
+  function None() {
+    None_instance = this;
+    CutLimit.call(this);
+    this.t30_1 = -1;
+    this.u30_1 = null;
+  }
+  protoOf(None).v30 = function () {
+    return this.t30_1;
+  };
+  protoOf(None).p1r = function () {
+    return this.u30_1;
+  };
+  protoOf(None).w30 = function () {
+    return true;
+  };
+  var None_instance;
+  function None_getInstance() {
+    if (None_instance == null)
+      new None();
+    return None_instance;
+  }
+  function Actual(depthToCut, procedure) {
+    CutLimit.call(this);
+    this.x30_1 = depthToCut;
+    this.y30_1 = procedure;
+  }
+  protoOf(Actual).v30 = function () {
+    return this.x30_1;
+  };
+  protoOf(Actual).p1r = function () {
+    return this.y30_1;
+  };
+  function CutLimit() {
+  }
+  protoOf(CutLimit).w30 = function () {
+    return false;
+  };
+  function Companion_0() {
+    Companion_instance_16 = this;
+    this.z30_1 = Catch_getInstance().signature;
+    this.a31_1 = setOf([new Signature(',', 2), new Signature(';', 2), new Signature('->', 2)]);
+  }
+  var Companion_instance_16;
+  function Companion_getInstance_6() {
+    if (Companion_instance_16 == null)
+      new Companion_0();
+    return Companion_instance_16;
+  }
+  function _get_failureState__yid9tw_0($this) {
+    return new StateBacktracking($this.d31_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function exceptionalState_0($this, exception) {
+    return new StateException(exception, $this.d31_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function missingProcedure($this, ruleSources, missing) {
+    var unknown = $this.d31_1.g2u_1.get(Unknown_getInstance());
+    var tmp;
+    if (equals(unknown, Unknown_getInstance().p25_1)) {
+      tmp = _get_failureState__yid9tw_0($this);
+    } else {
+      var tmp_0;
+      var tmp$ret$0;
+      $l$block: {
+        // Inline function 'kotlin.sequences.none' call
+        var _iterator__ex2g4s = ruleSources.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (element.containsIndicator(missing.toIndicator())) {
+            tmp$ret$0 = false;
+            break $l$block;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      if (tmp$ret$0) {
+        var tmp_1;
+        if (equals(unknown, Unknown_getInstance().n25_1)) {
+          tmp_1 = exceptionalState_0($this, Companion_instance_12.forProcedure($this.d31_1, missing));
+        } else if (equals(unknown, Unknown_getInstance().o25_1)) {
+          // Inline function 'kotlin.also' call
+          var this_0 = _get_failureState__yid9tw_0($this);
+          $this.d31_1.h1s().write(MissingPredicate_init_$Create$($this.d31_1, missing));
+          tmp_1 = this_0;
+        } else {
+          tmp_1 = _get_failureState__yid9tw_0($this);
+        }
+        tmp_0 = tmp_1;
+      } else {
+        tmp_0 = _get_failureState__yid9tw_0($this);
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  function _get_ignoreState__t4wl8y($this) {
+    return new StateGoalSelection($this.d31_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d31_1.p2u_1.ro(), VOID, VOID, VOID, VOID, VOID, VOID, VOID, $this.d2z()));
+  }
+  function isCut($this, $receiver) {
+    return $receiver.ct() && $receiver.castToAtom().c2() === '!';
+  }
+  function computeCutLimit($this, $receiver, magicCut) {
+    magicCut = magicCut === VOID ? false : magicCut;
+    var tmp;
+    if (magicCut) {
+      tmp = firstOrNull($receiver.z2u_1);
+    } else {
+      var tmp0 = $receiver.z2u_1;
+      var tmp$ret$0;
+      $l$block: {
+        // Inline function 'kotlin.sequences.firstOrNull' call
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          var tmp_0 = Companion_getInstance_6().a31_1;
+          var tmp0_safe_receiver = element.d2u_1;
+          if (!contains_0(tmp_0, tmp0_safe_receiver == null ? null : extractSignature(tmp0_safe_receiver))) {
+            tmp$ret$0 = element;
+            break $l$block;
+          }
+        }
+        tmp$ret$0 = null;
+      }
+      tmp = tmp$ret$0;
+    }
+    var cutLimit = tmp;
+    var tmp_1;
+    if (cutLimit == null) {
+      tmp_1 = None_getInstance();
+    } else {
+      tmp_1 = new Actual(cutLimit.w2u_1, cutLimit.d2u_1);
+    }
+    return tmp_1;
+  }
+  function cutCanBeSkipped($this, cutLimit, executionContext) {
+    return cutLimit.w30() || cutLimit.v30() > executionContext.w2u_1 || (cutLimit.v30() === executionContext.w2u_1 && !equals(cutLimit.p1r(), executionContext.d2u_1));
+  }
+  function performCut($this, $receiver, cutLimit) {
+    var tmp;
+    if ($receiver === null) {
+      tmp = null;
+    } else if (cutCanBeSkipped($this, cutLimit, ensureNotNull($receiver.p2v()))) {
+      tmp = $receiver;
+    } else {
+      var tmp_0 = $receiver.c2w();
+      var cutCandidates = filter(tmp_0, StateRuleSelection$performCut$lambda(cutLimit));
+      var tmp_1;
+      if (any(cutCandidates)) {
+        var tmp$ret$0;
+        $l$block: {
+          // Inline function 'kotlin.sequences.firstOrNull' call
+          var _iterator__ex2g4s = cutCandidates.m();
+          while (_iterator__ex2g4s.p()) {
+            var element = _iterator__ex2g4s.q();
+            if (ensureNotNull(element.p2v()).w2u_1 <= cutLimit.v30()) {
+              tmp$ret$0 = element;
+              break $l$block;
+            }
+          }
+          tmp$ret$0 = null;
+        }
+        var tmp0_safe_receiver = tmp$ret$0;
+        tmp_1 = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.q2v();
+      } else {
+        tmp_1 = $receiver;
+      }
+      tmp = tmp_1;
+    }
+    return tmp;
+  }
+  function _get_isTailRecursive__h5eso7($this, $receiver) {
+    var tmp;
+    if ($receiver.p2u_1.ro().uo() && equals($receiver.g2u_1.get(LastCallOptimization_getInstance()), LastCallOptimization_getInstance().c25_1)) {
+      // Inline function 'kotlin.let' call
+      var tmp0_safe_receiver = ensureNotNull($receiver.p2x()).asStruct();
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : extractSignature(tmp0_safe_receiver);
+      var tmp_0;
+      if (tmp1_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        // Inline function 'kotlin.let' call
+        var tmp_1;
+        var tmp0_safe_receiver_0 = $receiver.d2u_1;
+        if (tmp1_safe_receiver.equals(tmp0_safe_receiver_0 == null ? null : extractSignature(tmp0_safe_receiver_0))) {
+          tmp_1 = !tmp1_safe_receiver.equals(Companion_getInstance_6().z30_1);
+        } else {
+          tmp_1 = false;
+        }
+        tmp_0 = tmp_1;
+      }
+      var tmp2_elvis_lhs = tmp_0;
+      tmp = tmp2_elvis_lhs == null ? false : tmp2_elvis_lhs;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  function selectClauses($this, $receiver, term) {
+    var tmp = $receiver.getByHead(term);
+    // Inline function 'kotlin.let' call
+    var it = ensureRules(map(tmp, StateRuleSelection$selectClauses$lambda));
+    var tmp_0;
+    if ($receiver.n1p()) {
+      tmp_0 = buffered(it);
+    } else {
+      tmp_0 = it;
+    }
+    return tmp_0;
+  }
+  function StateRuleSelection$performCut$lambda($cutLimit) {
+    return function (it) {
+      return equals(ensureNotNull(it.p2v()).d2u_1, $cutLimit.p1r());
+    };
+  }
+  function StateRuleSelection$computeNext$lambda(this$0, $currentGoalStruct) {
+    return function (it) {
+      return selectClauses(this$0, it, $currentGoalStruct);
+    };
+  }
+  function StateRuleSelection$selectClauses$lambda(it) {
+    return it.kt();
+  }
+  function StateRuleSelection(context) {
+    Companion_getInstance_6();
+    AbstractState.call(this, context);
+    this.d31_1 = context;
+  }
+  protoOf(StateRuleSelection).m8 = function () {
+    return this.d31_1;
+  };
+  protoOf(StateRuleSelection).x2y = function () {
+    var currentGoal = ensureNotNull(this.d31_1.p2x());
+    var tmp;
+    if (currentGoal.du()) {
+      tmp = exceptionalState_0(this, Companion_instance_11.forGoal(this.d31_1, extractSignature(ensureNotNull(this.d31_1.d2u_1)), currentGoal.castToVar()));
+    } else if (currentGoal.nt()) {
+      // Inline function 'kotlin.with' call
+      var $this$with = this.d31_1;
+      var currentGoalStruct = currentGoal.castToStruct();
+      var ruleSources = sequenceOf([$this$with.f2u_1.asTheory($this$with.e2u_1), $this$with.h2u_1, $this$with.i2u_1]);
+      var tmp_0;
+      if (currentGoalStruct.eu()) {
+        var tmp_1;
+        if (currentGoalStruct.ft()) {
+          tmp_1 = _get_ignoreState__t4wl8y(this);
+        } else {
+          tmp_1 = _get_failureState__yid9tw_0(this);
+        }
+        tmp_0 = tmp_1;
+      } else {
+        if (isCut(this, currentGoalStruct)) {
+          var cutLimit = computeCutLimit(this, $this$with, currentGoalStruct instanceof MagicCut);
+          // Inline function 'kotlin.let' call
+          var it = _get_ignoreState__t4wl8y(this);
+          tmp_0 = it.l2z(it.a30_1.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, performCut(this, it.a30_1.u2u_1, cutLimit)));
+        } else {
+          var tmp$ret$4;
+          $l$block: {
+            // Inline function 'kotlin.sequences.any' call
+            var _iterator__ex2g4s = ruleSources.m();
+            while (_iterator__ex2g4s.p()) {
+              var element = _iterator__ex2g4s.q();
+              if (element.containsHead(currentGoalStruct)) {
+                tmp$ret$4 = true;
+                break $l$block;
+              }
+            }
+            tmp$ret$4 = false;
+          }
+          if (tmp$ret$4) {
+            var rules = cursor(flatMap(ruleSources, StateRuleSelection$computeNext$lambda(this, currentGoalStruct)));
+            var tmp_2;
+            if (_get_isTailRecursive__h5eso7(this, this.d31_1)) {
+              tmp_2 = new StateRuleExecution(replaceWithChildAppendingRulesAndChoicePoints(this.d31_1, rules));
+            } else {
+              tmp_2 = new StateRuleExecution(createChildAppendingRulesAndChoicePoints(this.d31_1, rules));
+            }
+            tmp_0 = tmp_2;
+          } else {
+            tmp_0 = missingProcedure(this, ruleSources, extractSignature(currentGoalStruct));
+          }
+        }
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = exceptionalState_0(this, Companion_instance_10.forGoal(this.d31_1, extractSignature(ensureNotNull(this.d31_1.d2u_1)), Expected_CALLABLE_getInstance(), currentGoal));
+    }
+    return tmp;
+  };
+  protoOf(StateRuleSelection).g2z = function (context) {
+    return this.l2z(context);
+  };
+  protoOf(StateRuleSelection).clone = function (context, $super) {
+    return this.clone(context, ($super == null ? true : $super instanceof StateRuleSelection) ? $super : THROW_CCE());
+  };
+  protoOf(StateRuleSelection).l2z = function (context) {
+    return new StateRuleSelection(context);
+  };
+  protoOf(StateRuleSelection).toString = function () {
+    return 'StateRuleSelection(context=' + this.d31_1.toString() + ')';
+  };
+  protoOf(StateRuleSelection).hashCode = function () {
+    return this.d31_1.hashCode();
+  };
+  protoOf(StateRuleSelection).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof StateRuleSelection))
+      return false;
+    if (!this.d31_1.equals(other.d31_1))
+      return false;
+    return true;
+  };
+  function appendRulesAndChoicePoints(_this__u8e3s4, rules) {
+    var tmp;
+    if (rules.to()) {
+      tmp = appendRules(_this__u8e3s4.u2u_1, rules.ro(), _this__u8e3s4);
+    } else {
+      tmp = appendRules(_this__u8e3s4.u2u_1, Companion_instance_7.empty(), _this__u8e3s4);
+    }
+    var newChoicePointContext = tmp;
+    return _this__u8e3s4.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, rules, VOID, VOID, VOID, newChoicePointContext);
+  }
+  function toGoals(_this__u8e3s4) {
+    var tmp = unfoldGoals(_this__u8e3s4);
+    return cursor(map(tmp, toGoals$lambda));
+  }
+  function unfoldGoals(_this__u8e3s4) {
+    var tmp;
+    if (_this__u8e3s4.st()) {
+      var tmp_0 = _this__u8e3s4.castToTuple().xr();
+      tmp = flatMap(tmp_0, unfoldGoals$lambda);
+    } else {
+      tmp = sequenceOf_0(_this__u8e3s4);
+    }
+    return tmp;
+  }
+  function createChild(_this__u8e3s4, inferProcedureFromGoals) {
+    inferProcedureFromGoals = inferProcedureFromGoals === VOID ? true : inferProcedureFromGoals;
+    var currentGoal = ensureNotNull(_this__u8e3s4.p2x()).castToStruct();
+    var tmp0_goals = toGoals(currentGoal);
+    var tmp1_procedure = inferProcedureFromGoals ? currentGoal : _this__u8e3s4.d2u_1;
+    var tmp2_depth = _this__u8e3s4.w2u_1 + 1 | 0;
+    // Inline function 'kotlin.Long.plus' call
+    var this_0 = _this__u8e3s4.x2u_1;
+    var tmp3_step = add(this_0, fromInt(1));
+    var tmp4_relevantVariables = emptySet();
+    return _this__u8e3s4.u2v(tmp1_procedure, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, tmp0_goals, VOID, VOID, VOID, VOID, VOID, _this__u8e3s4, tmp2_depth, tmp3_step, tmp4_relevantVariables);
+  }
+  function toRequest(_this__u8e3s4, goal, signature, startTime) {
+    return new Request(signature, goal.it(), _this__u8e3s4, startTime);
+  }
+  function appendPrimitivesAndChoicePoints(_this__u8e3s4, primitiveExecutions) {
+    var tmp;
+    if (primitiveExecutions.to()) {
+      tmp = appendPrimitives(_this__u8e3s4.u2u_1, primitiveExecutions.ro(), _this__u8e3s4);
+    } else {
+      tmp = appendPrimitives(_this__u8e3s4.u2u_1, Companion_instance_7.empty(), _this__u8e3s4);
+    }
+    var newChoicePointContext = tmp;
+    return _this__u8e3s4.u2v(VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, primitiveExecutions, VOID, VOID, newChoicePointContext);
+  }
+  function replaceWithChildAppendingRulesAndChoicePoints(_this__u8e3s4, rules, inferProcedureFromGoals) {
+    inferProcedureFromGoals = inferProcedureFromGoals === VOID ? true : inferProcedureFromGoals;
+    var tempExecutionContext = replaceWithChild(_this__u8e3s4, inferProcedureFromGoals);
+    return appendRulesAndChoicePoints(tempExecutionContext, rules);
+  }
+  function createChildAppendingRulesAndChoicePoints(_this__u8e3s4, rules, inferProcedureFromGoals) {
+    inferProcedureFromGoals = inferProcedureFromGoals === VOID ? true : inferProcedureFromGoals;
+    var tempExecutionContext = createChild(_this__u8e3s4, inferProcedureFromGoals);
+    return appendRulesAndChoicePoints(tempExecutionContext, rules);
+  }
+  function ensureRules(_this__u8e3s4) {
+    return map(_this__u8e3s4, ensureRules$lambda);
+  }
+  function replaceWithChild(_this__u8e3s4, inferProcedureFromGoals) {
+    inferProcedureFromGoals = inferProcedureFromGoals === VOID ? true : inferProcedureFromGoals;
+    var currentGoal = ensureNotNull(_this__u8e3s4.p2x()).castToStruct();
+    var tmp0_goals = toGoals(currentGoal);
+    var tmp1_procedure = inferProcedureFromGoals ? currentGoal : _this__u8e3s4.d2u_1;
+    var tmp2_depth = _this__u8e3s4.w2u_1 + 1 | 0;
+    // Inline function 'kotlin.Long.plus' call
+    var this_0 = _this__u8e3s4.x2u_1;
+    var tmp3_step = add(this_0, fromInt(1));
+    return _this__u8e3s4.u2v(tmp1_procedure, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, VOID, tmp0_goals, VOID, VOID, VOID, VOID, VOID, VOID, tmp2_depth, tmp3_step);
+  }
+  function toGoals$lambda(it) {
+    return it.du() ? Companion_getInstance_1().of('call', [it]) : it;
+  }
+  function unfoldGoals$lambda(it) {
+    return unfoldGoals(it);
+  }
+  function ensureRules$lambda(it) {
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.require' call
+    if (!it.pt()) {
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return it.castToRule();
+  }
+  function AbstractSolutionIterator(state) {
+    this.e31_1 = state;
+    this.f31_1 = new Long(0, 0);
+  }
+  protoOf(AbstractSolutionIterator).p = function () {
+    // Inline function 'kotlin.let' call
+    var it = this.e31_1;
+    return !it.e2z() || it.castToEndState().b2w();
+  };
+  protoOf(AbstractSolutionIterator).q = function () {
+    do {
+      var previousState = this.e31_1;
+      var tmp = this;
+      var tmp_0 = this.e31_1;
+      this.f31_1 = add(this.f31_1, get_ONE());
+      tmp.e31_1 = this.g31(tmp_0, this.f31_1);
+      this.onStateTransition(previousState, this.e31_1, this.f31_1);
+    }
+     while (!this.e31_1.e2z());
+    return this.e31_1.castToEndState().j2e().cleanUp();
+  };
+  function SimpleSolutionIterator(state, onStateTransitionCallback) {
+    AbstractSolutionIterator.call(this, state);
+    this.j31_1 = onStateTransitionCallback;
+  }
+  protoOf(SimpleSolutionIterator).g31 = function (state, step) {
+    return state.next();
+  };
+  protoOf(SimpleSolutionIterator).k31 = function (source, destination, index) {
+    return this.j31_1(source, destination, index);
+  };
+  protoOf(SimpleSolutionIterator).onStateTransition = function (source, destination, index) {
+    return this.k31(source, destination, index);
+  };
+  function DefaultBuiltins() {
+    DefaultBuiltins_instance = this;
+    ExtensionLibrary.call(this, CommonBuiltins_getInstance());
+  }
+  protoOf(DefaultBuiltins).v2a = function () {
+    return listOf(Throw_getInstance());
+  };
+  protoOf(DefaultBuiltins).u2a = function () {
+    return listOf_0([Catch_getInstance(), Call_getInstance(), Comma_getInstance(), Cut_getInstance(), Fail_getInstance(), Success_getInstance()]);
+  };
+  var DefaultBuiltins_instance;
+  function DefaultBuiltins_getInstance() {
+    if (DefaultBuiltins_instance == null)
+      new DefaultBuiltins();
+    return DefaultBuiltins_instance;
+  }
+  function handleError($this, context, error) {
+    var tmp;
+    var tmp_0;
+    var tmp_1;
+    if (isInterface(error, Struct)) {
+      tmp_1 = error.ht() === 'error';
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      var containsArg = error.bt();
+      tmp_0 = 1 <= containsArg ? containsArg <= 2 : false;
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      var tmp_2 = Companion_instance_14;
+      var tmp_3 = error.get(0);
+      tmp = tmp_2.of(VOID, VOID, context, isInterface(tmp_3, Struct) ? tmp_3 : THROW_CCE(), error.bt() > 1 ? error.get(1) : null);
+    } else {
+      tmp = Companion_instance_13.x22(error, context);
+    }
+    return tmp;
+  }
+  function Throw() {
+    Throw_instance = this;
+    UnaryPredicate.call(this, 'throw');
+  }
+  protoOf(Throw).a2l = function (_this__u8e3s4, first) {
+    return sequenceOf_0(Companion_getInstance_4().v2b(_this__u8e3s4).replyException(handleError(this, _this__u8e3s4.context, _this__u8e3s4.arguments.t(0)), VOID, []));
+  };
+  protoOf(Throw).a2f = function (_this__u8e3s4, first) {
+    return this.a2l(_this__u8e3s4, first);
+  };
+  var Throw_instance;
+  function Throw_getInstance() {
+    if (Throw_instance == null)
+      new Throw();
+    return Throw_instance;
+  }
+  function Call() {
+    Call_instance = this;
+    RuleWrapper_init_$Init$('call', 1, VOID, this);
+  }
+  protoOf(Call).e2f = function (_this__u8e3s4) {
+    return listOf(_this__u8e3s4.varOf('G'));
+  };
+  protoOf(Call).f2f = function (_this__u8e3s4) {
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp$ret$0 = EnsureExecutable_getInstance().signature.name;
+    return _this__u8e3s4.tupleOf([_this__u8e3s4.structOf(tmp$ret$0, [_this__u8e3s4.varOf('G')]), _this__u8e3s4.varOf('G')]);
+  };
+  var Call_instance;
+  function Call_getInstance() {
+    if (Call_instance == null)
+      new Call();
+    return Call_instance;
+  }
+  function Catch() {
+    Catch_instance = this;
+    RuleWrapper_init_$Init$('catch', 3, VOID, this);
+  }
+  protoOf(Catch).e2f = function (_this__u8e3s4) {
+    return listOf_0([_this__u8e3s4.varOf('G'), _this__u8e3s4.varOf('E'), _this__u8e3s4.varOf('C')]);
+  };
+  protoOf(Catch).f2f = function (_this__u8e3s4) {
+    return _this__u8e3s4.varOf('G');
+  };
+  var Catch_instance;
+  function Catch_getInstance() {
+    if (Catch_instance == null)
+      new Catch();
+    return Catch_instance;
+  }
+  function Comma() {
+    Comma_instance = this;
+    RuleWrapper_init_$Init$(',', 2, VOID, this);
+  }
+  protoOf(Comma).e2f = function (_this__u8e3s4) {
+    return listOf_0([_this__u8e3s4.varOf('A'), _this__u8e3s4.varOf('B')]);
+  };
+  protoOf(Comma).f2f = function (_this__u8e3s4) {
+    return _this__u8e3s4.tupleOf([_this__u8e3s4.varOf('A'), _this__u8e3s4.varOf('B')]);
+  };
+  var Comma_instance;
+  function Comma_getInstance() {
+    if (Comma_instance == null)
+      new Comma();
+    return Comma_instance;
+  }
+  function Cut() {
+    Cut_instance = this;
+    RuleWrapper_init_$Init$('!', 0, VOID, this);
+  }
+  var Cut_instance;
+  function Cut_getInstance() {
+    if (Cut_instance == null)
+      new Cut();
+    return Cut_instance;
+  }
+  function Fail() {
+    Fail_instance = this;
+    NegationAsFailure.call(this);
+  }
+  protoOf(Fail).f2f = function (_this__u8e3s4) {
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp$ret$0 = EnsureExecutable_getInstance().signature.name;
+    var tmp = _this__u8e3s4.structOf(tmp$ret$0, [_this__u8e3s4.varOf('X')]);
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp$ret$1 = Call_getInstance().signature.name;
+    return _this__u8e3s4.tupleOf([tmp, _this__u8e3s4.structOf(tmp$ret$1, [_this__u8e3s4.varOf('X')]), MagicCut_getInstance(), _this__u8e3s4.truthOf(false)]);
+  };
+  var Fail_instance;
+  function Fail_getInstance() {
+    if (Fail_instance == null)
+      new Fail();
+    return Fail_instance;
+  }
+  function Success() {
+    Success_instance = this;
+    NegationAsFailure.call(this);
+  }
+  protoOf(Success).f2f = function (_this__u8e3s4) {
+    return _this__u8e3s4.truthOf(true);
+  };
+  var Success_instance;
+  function Success_getInstance() {
+    if (Success_instance == null)
+      new Success();
+    return Success_instance;
+  }
+  function Companion_1() {
+    this.k32_1 = '\\+';
+    this.l32_1 = 1;
+  }
+  var Companion_instance_17;
+  function Companion_getInstance_7() {
+    return Companion_instance_17;
+  }
+  function NegationAsFailure() {
+    RuleWrapper_init_$Init$('\\+', 1, VOID, this);
+  }
+  protoOf(NegationAsFailure).e2f = function (_this__u8e3s4) {
+    return listOf(_this__u8e3s4.varOf('X'));
+  };
+  //region block: post-declaration
+  protoOf(ClassicExecutionContext).createSolver = createSolver;
+  protoOf(ClassicExecutionContext).createMutableSolver = createMutableSolver;
+  protoOf(ClassicExecutionContext).update = update;
+  protoOf(ClassicExecutionContext).e1s = get_standardInput;
+  protoOf(ClassicExecutionContext).f1s = get_standardOutput;
+  protoOf(ClassicExecutionContext).g1s = get_standardError;
+  protoOf(ClassicExecutionContext).h1s = get_warnings;
+  protoOf(ClassicExecutionContext).l1r = get_endTime;
+  protoOf(ClassicExecutionContext).n1r = get_remainingTime;
+  protoOf(ClassicExecutionContext).o1r = get_elapsedTime;
+  protoOf(ClassicSolverFactory).rawSolverOf = rawSolverOf;
+  protoOf(ClassicSolverFactory).solverOf = solverOf;
+  protoOf(ClassicSolverFactory).mutableSolverOf = mutableSolverOf;
+  protoOf(ClassicSolverFactory).rawMutableSolverOf = rawMutableSolverOf;
+  protoOf(ClassicSolverFactory).newBuilder = newBuilder;
+  protoOf(ClassicSolverFactory).f1u = get_defaultRuntime;
+  protoOf(ClassicSolverFactory).h1u = get_defaultUnificator;
+  protoOf(ClassicSolverFactory).i1u = get_defaultFlags;
+  protoOf(ClassicSolverFactory).l1u = get_defaultStaticKb;
+  protoOf(ClassicSolverFactory).m1u = get_defaultDynamicKb;
+  protoOf(ClassicSolverFactory).n1u = get_defaultInputChannel;
+  protoOf(ClassicSolverFactory).o1u = get_defaultOutputChannel;
+  protoOf(ClassicSolverFactory).p1u = get_defaultErrorChannel;
+  protoOf(ClassicSolverFactory).q1u = get_defaultWarningsChannel;
+  protoOf(ClassicSolverFactory).y1u = solverWithDefaultBuiltins;
+  protoOf(ClassicSolverFactory).solverWithDefaultBuiltinsAnd = solverWithDefaultBuiltinsAnd;
+  protoOf(ClassicSolverFactory).a1v = mutableSolverWithDefaultBuiltins;
+  protoOf(ClassicSolverFactory).mutableSolverWithDefaultBuiltinsAnd = mutableSolverWithDefaultBuiltinsAnd;
+  protoOf(MutableClassicSolver).loadStaticClauses = loadStaticClauses;
+  protoOf(MutableClassicSolver).loadStaticClausesIterable = loadStaticClausesIterable;
+  protoOf(MutableClassicSolver).loadStaticClausesSequence = loadStaticClausesSequence;
+  protoOf(MutableClassicSolver).loadDynamicClauses = loadDynamicClauses;
+  protoOf(MutableClassicSolver).loadDynamicClausesIterable = loadDynamicClausesIterable;
+  protoOf(MutableClassicSolver).loadDynamicClausesSequence = loadDynamicClausesSequence;
+  protoOf(AbstractState).e2z = get_isEndState;
+  protoOf(AbstractState).asEndState = asEndState;
+  protoOf(AbstractState).castToEndState = castToEndState;
+  protoOf(AbstractState).clone = clone;
+  protoOf(AbstractEndState).e2z = get_isEndState_0;
+  protoOf(AbstractEndState).f2z = asEndState_0;
+  protoOf(AbstractEndState).b2w = get_hasOpenAlternatives;
+  //endregion
+  //region block: init
+  ClassicSolverFactory_instance = new ClassicSolverFactory();
+  Companion_instance_15 = new Companion();
+  Companion_instance_17 = new Companion_1();
+  //endregion
+  //region block: exports
+  function $jsExportAll$(_) {
+    var it = _.it || (_.it = {});
+    var unibo = it.unibo || (it.unibo = {});
+    var tuprolog = unibo.tuprolog || (unibo.tuprolog = {});
+    var solve = tuprolog.solve || (tuprolog.solve = {});
+    var classic = solve.classic || (solve.classic = {});
+    defineProp(classic, 'ClassicSolverFactory', ClassicSolverFactory_getInstance, VOID, true);
+  }
+  $jsExportAll$(_);
+  _.$jsExportAll$ = $jsExportAll$;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-solve-classic.js.map