@tuprolog/2p-full 0.30.5 → 0.31.1-dev02

package/2p-solve-problog.js

@@ -0,0 +1,4547 @@
+(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_solve_plp, kotlin_it_unibo_tuprolog_solve_classic, kotlin_it_unibo_tuprolog_bdd, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_utils, kotlin_it_unibo_tuprolog_unify) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var first = kotlin_kotlin.$_$.y3;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var copy$default = kotlin_it_unibo_tuprolog_solve.$_$.u;
+  var loadStaticClauses = kotlin_it_unibo_tuprolog_solve.$_$.n4;
+  var loadStaticClausesIterable = kotlin_it_unibo_tuprolog_solve.$_$.o4;
+  var loadStaticClausesSequence = kotlin_it_unibo_tuprolog_solve.$_$.p4;
+  var loadDynamicClauses = kotlin_it_unibo_tuprolog_solve.$_$.m4;
+  var loadDynamicClausesIterable = kotlin_it_unibo_tuprolog_solve.$_$.k4;
+  var loadDynamicClausesSequence = kotlin_it_unibo_tuprolog_solve.$_$.l4;
+  var MutableSolver = kotlin_it_unibo_tuprolog_solve.$_$.q4;
+  var classMeta = kotlin_kotlin.$_$.m6;
+  var setMetadataFor = kotlin_kotlin.$_$.j7;
+  var Specifier_XFY_getInstance = kotlin_it_unibo_tuprolog_core.$_$.c;
+  var Operator = kotlin_it_unibo_tuprolog_core.$_$.n1;
+  var OperatorSet_init_$Create$ = kotlin_it_unibo_tuprolog_core.$_$.n;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.q;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_core.$_$.i1;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.h1;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.d1;
+  var Unit_getInstance = kotlin_kotlin.$_$.r2;
+  var map = kotlin_kotlin.$_$.c9;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_solve.$_$.m2;
+  var Halt = kotlin_it_unibo_tuprolog_solve.$_$.r4;
+  var isInterface = kotlin_kotlin.$_$.y6;
+  var Yes = kotlin_it_unibo_tuprolog_solve.$_$.t4;
+  var DoubleCompanionObject_getInstance = kotlin_kotlin.$_$.j2;
+  var setProbability = kotlin_it_unibo_tuprolog_solve_plp.$_$.d;
+  var Numeric = kotlin_it_unibo_tuprolog_core.$_$.w1;
+  var setBinaryDecisionDiagram = kotlin_it_unibo_tuprolog_solve_plp.$_$.b;
+  var get_isProbabilistic = kotlin_it_unibo_tuprolog_solve_plp.$_$.a;
+  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_solve.$_$.o2;
+  var toList = kotlin_kotlin.$_$.p9;
+  var first_0 = kotlin_kotlin.$_$.t8;
+  var Solver = kotlin_it_unibo_tuprolog_solve.$_$.q5;
+  var TrackVariables_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.c2;
+  var invoke = kotlin_it_unibo_tuprolog_solve.$_$.w2;
+  var THROW_CCE = kotlin_kotlin.$_$.sb;
+  var Map = kotlin_kotlin.$_$.w2;
+  var get_defaultFlags = kotlin_it_unibo_tuprolog_solve.$_$.f5;
+  var ClassicSolverFactory_getInstance = kotlin_it_unibo_tuprolog_solve_classic.$_$.c;
+  var solverOf$default = kotlin_it_unibo_tuprolog_solve.$_$.z;
+  var solverOf$default_0 = kotlin_it_unibo_tuprolog_solve.$_$.y;
+  var mutableSolverOf$default = kotlin_it_unibo_tuprolog_solve.$_$.v;
+  var mutableSolverOf$default_0 = kotlin_it_unibo_tuprolog_solve.$_$.w;
+  var newBuilder = kotlin_it_unibo_tuprolog_solve.$_$.n5;
+  var get_defaultRuntime = kotlin_it_unibo_tuprolog_solve.$_$.i5;
+  var get_defaultUnificator = kotlin_it_unibo_tuprolog_solve.$_$.k5;
+  var get_defaultStaticKb = kotlin_it_unibo_tuprolog_solve.$_$.j5;
+  var get_defaultDynamicKb = kotlin_it_unibo_tuprolog_solve.$_$.d5;
+  var get_defaultInputChannel = kotlin_it_unibo_tuprolog_solve.$_$.g5;
+  var get_defaultOutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.h5;
+  var get_defaultErrorChannel = kotlin_it_unibo_tuprolog_solve.$_$.e5;
+  var get_defaultWarningsChannel = kotlin_it_unibo_tuprolog_solve.$_$.l5;
+  var solverWithDefaultBuiltins = kotlin_it_unibo_tuprolog_solve.$_$.o5;
+  var solverWithDefaultBuiltins$default = kotlin_it_unibo_tuprolog_solve.$_$.a1;
+  var mutableSolverWithDefaultBuiltins = kotlin_it_unibo_tuprolog_solve.$_$.m5;
+  var mutableSolverWithDefaultBuiltins$default = kotlin_it_unibo_tuprolog_solve.$_$.x;
+  var SolverFactory = kotlin_it_unibo_tuprolog_solve.$_$.p5;
+  var objectMeta = kotlin_kotlin.$_$.i7;
+  var ExtensionLibrary = kotlin_it_unibo_tuprolog_solve.$_$.z2;
+  var DefaultBuiltins_getInstance = kotlin_it_unibo_tuprolog_solve_classic.$_$.b;
+  var containsSignature = kotlin_it_unibo_tuprolog_solve.$_$.b3;
+  var containsOperator = kotlin_it_unibo_tuprolog_solve.$_$.a3;
+  var hasPrimitive = kotlin_it_unibo_tuprolog_solve.$_$.d3;
+  var hasFunction = kotlin_it_unibo_tuprolog_solve.$_$.c3;
+  var get_ruleSignatures = kotlin_it_unibo_tuprolog_solve.$_$.f3;
+  var hasProtected = kotlin_it_unibo_tuprolog_solve.$_$.e3;
+  var EnsureExecutable_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.i2;
+  var listOf = kotlin_kotlin.$_$.h4;
+  var Call_getInstance = kotlin_it_unibo_tuprolog_solve_classic.$_$.a;
+  var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_solve.$_$.e2;
+  var listOf_0 = kotlin_kotlin.$_$.i4;
+  var captureStack = kotlin_kotlin.$_$.h6;
+  var TuPrologException = kotlin_it_unibo_tuprolog_core.$_$.l1;
+  var TuPrologException_init_$Init$ = kotlin_it_unibo_tuprolog_core.$_$.j;
+  var emptyList = kotlin_kotlin.$_$.s3;
+  var asIterable = kotlin_kotlin.$_$.b3;
+  var asIterable_0 = kotlin_kotlin.$_$.h8;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var Companion_getInstance_7 = kotlin_it_unibo_tuprolog_core.$_$.c1;
+  var bddTerminalOf = kotlin_it_unibo_tuprolog_bdd.$_$.d;
+  var bddOf = kotlin_it_unibo_tuprolog_bdd.$_$.c;
+  var interfaceMeta = kotlin_kotlin.$_$.u6;
+  var Companion_getInstance_8 = kotlin_it_unibo_tuprolog_core.$_$.s;
+  var Term = kotlin_it_unibo_tuprolog_core.$_$.y2;
+  var Companion_getInstance_9 = kotlin_it_unibo_tuprolog_core.$_$.e1;
+  var Atom = kotlin_it_unibo_tuprolog_core.$_$.o1;
+  var Collection = kotlin_kotlin.$_$.t2;
+  var getNumberHashCode = kotlin_kotlin.$_$.q6;
+  var hashCode = kotlin_kotlin.$_$.t6;
+  var Companion_getInstance_10 = kotlin_it_unibo_tuprolog_core.$_$.z;
+  var lazy = kotlin_kotlin.$_$.xb;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j3;
+  var toSet = kotlin_kotlin.$_$.w5;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.c1;
+  var compareTo = kotlin_it_unibo_tuprolog_core.$_$.b2;
+  var equals = kotlin_kotlin.$_$.o6;
+  var compareTo_0 = kotlin_kotlin.$_$.n6;
+  var round = kotlin_kotlin.$_$.s7;
+  var KProperty1 = kotlin_kotlin.$_$.d8;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.r6;
+  var MutableTheory = kotlin_it_unibo_tuprolog_theory.$_$.c;
+  var Theory = kotlin_it_unibo_tuprolog_theory.$_$.f;
+  var Struct = kotlin_it_unibo_tuprolog_core.$_$.z1;
+  var Companion_getInstance_11 = kotlin_it_unibo_tuprolog_solve.$_$.k2;
+  var TuPrologException_init_$Create$ = kotlin_it_unibo_tuprolog_core.$_$.l;
+  var Rule = kotlin_it_unibo_tuprolog_core.$_$.y1;
+  var Companion_getInstance_12 = kotlin_it_unibo_tuprolog_core.$_$.b1;
+  var toList_0 = kotlin_kotlin.$_$.n5;
+  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.c2;
+  var notThenExpansion = kotlin_it_unibo_tuprolog_bdd.$_$.g;
+  var expansion = kotlin_it_unibo_tuprolog_bdd.$_$.e;
+  var anyWhere = kotlin_it_unibo_tuprolog_bdd.$_$.b;
+  var andThenExpansion = kotlin_it_unibo_tuprolog_bdd.$_$.a;
+  var orThenExpansion = kotlin_it_unibo_tuprolog_bdd.$_$.h;
+  var map_0 = kotlin_it_unibo_tuprolog_bdd.$_$.f;
+  var Long = kotlin_kotlin.$_$.mb;
+  var NoSuchElementException_init_$Create$ = kotlin_kotlin.$_$.w1;
+  var Companion_getInstance_13 = kotlin_it_unibo_tuprolog_core.$_$.w;
+  var plus = kotlin_kotlin.$_$.b5;
+  var setTag = kotlin_it_unibo_tuprolog_utils.$_$.j1;
+  var Regex_init_$Create$ = kotlin_kotlin.$_$.h1;
+  var toDoubleOrNull = kotlin_kotlin.$_$.sa;
+  var toSet_0 = kotlin_kotlin.$_$.r9;
+  var plus_0 = kotlin_kotlin.$_$.y4;
+  var checkIndexOverflow = kotlin_kotlin.$_$.i3;
+  var Pair = kotlin_kotlin.$_$.qb;
+  var Fact = kotlin_it_unibo_tuprolog_core.$_$.s1;
+  var emptySet = kotlin_kotlin.$_$.u3;
+  var subtract = kotlin_kotlin.$_$.j5;
+  var setOf = kotlin_kotlin.$_$.e5;
+  var Directive = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var Indicator = kotlin_it_unibo_tuprolog_core.$_$.t1;
+  var Companion_getInstance_14 = kotlin_it_unibo_tuprolog_core.$_$.u;
+  var Truth = kotlin_it_unibo_tuprolog_core.$_$.z2;
+  var Companion_getInstance_15 = kotlin_it_unibo_tuprolog_core.$_$.g1;
+  var Companion_getInstance_16 = kotlin_it_unibo_tuprolog_unify.$_$.a;
+  var Companion_getInstance_17 = kotlin_it_unibo_tuprolog_theory.$_$.a;
+  var addAll = kotlin_kotlin.$_$.y2;
+  var Companion_getInstance_18 = kotlin_it_unibo_tuprolog_theory.$_$.b;
+  var Failure = kotlin_it_unibo_tuprolog_theory.$_$.d;
+  var Success = kotlin_it_unibo_tuprolog_theory.$_$.e;
+  var NonBacktrackable = kotlin_it_unibo_tuprolog_solve.$_$.p3;
+  var Companion_getInstance_19 = kotlin_it_unibo_tuprolog_solve.$_$.g2;
+  var Var = kotlin_it_unibo_tuprolog_core.$_$.b3;
+  var ResolutionException_init_$Create$ = kotlin_it_unibo_tuprolog_solve.$_$.c1;
+  var CoroutineImpl = kotlin_kotlin.$_$.c6;
+  var SequenceScope = kotlin_kotlin.$_$.e8;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.b6;
+  var extractSignature = kotlin_it_unibo_tuprolog_solve.$_$.s5;
+  var ensureNotNull = kotlin_kotlin.$_$.vb;
+  var Clause = kotlin_it_unibo_tuprolog_core.$_$.p1;
+  var copyToArray = kotlin_kotlin.$_$.p3;
+  var WithoutSideEffects = kotlin_it_unibo_tuprolog_solve.$_$.r3;
+  var sequence = kotlin_kotlin.$_$.j9;
+  var NonBacktrackable_0 = kotlin_it_unibo_tuprolog_solve.$_$.h3;
+  var setProbabilistic = kotlin_it_unibo_tuprolog_solve_plp.$_$.c;
+  var firstOrNull = kotlin_kotlin.$_$.s8;
+  var WithoutSideEffects_0 = kotlin_it_unibo_tuprolog_solve.$_$.n3;
+  var NonBacktrackable_1 = kotlin_it_unibo_tuprolog_solve.$_$.u3;
+  var SetFlags_init_$Create$ = kotlin_it_unibo_tuprolog_solve.$_$.j1;
+  var WithoutSideEffects_1 = kotlin_it_unibo_tuprolog_solve.$_$.i3;
+  var asSequence = kotlin_kotlin.$_$.g3;
+  var filter = kotlin_kotlin.$_$.r8;
+  var Sequence = kotlin_kotlin.$_$.f8;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.f1;
+  var sequenceOf = kotlin_kotlin.$_$.i9;
+  var RuleWrapper = kotlin_it_unibo_tuprolog_solve.$_$.x3;
+  var RuleWrapper_init_$Init$ = kotlin_it_unibo_tuprolog_solve.$_$.g1;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(ProblogSolver, 'ProblogSolver', classMeta, undefined, [Solver], undefined, undefined, []);
+  setMetadataFor(MutableProblogSolver, 'MutableProblogSolver', classMeta, ProblogSolver, [ProblogSolver, MutableSolver], undefined, undefined, []);
+  setMetadataFor(ProblogSolverFactory, 'ProblogSolverFactory', objectMeta, undefined, [SolverFactory], undefined, undefined, []);
+  setMetadataFor(DefaultBuiltins, 'DefaultBuiltins', objectMeta, ExtensionLibrary, undefined, undefined, undefined, []);
+  setMetadataFor(MinimalBuiltins, 'MinimalBuiltins', objectMeta, ExtensionLibrary, undefined, undefined, undefined, []);
+  setMetadataFor(ProblogLib, 'ProblogLib', objectMeta, ExtensionLibrary, undefined, undefined, undefined, []);
+  setMetadataFor(ClauseMappingException, 'ClauseMappingException', classMeta, TuPrologException, undefined, undefined, undefined, []);
+  setMetadataFor(Companion, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_0, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function get_probabilityOrNull() {
+    var tmp;
+    try {
+      tmp = this.x3d();
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        tmp_0 = null;
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  setMetadataFor(ProbExplanation, 'ProbExplanation', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(ProbExplanationTerm, 'ProbExplanationTerm', classMeta, undefined, [Atom], undefined, undefined, []);
+  setMetadataFor(ProbTerm, 'ProbTerm', classMeta, undefined, [Term], undefined, undefined, []);
+  setMetadataFor(Companion_1, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(ProblogTheory, 'ProblogTheory', interfaceMeta, undefined, [Theory], undefined, undefined, []);
+  setMetadataFor(AnnotatedDisjunctionClauseMapper, 'AnnotatedDisjunctionClauseMapper', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(ComputedValue, 'ComputedValue', classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_2, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(BinaryDecisionDiagramExplanation, 'BinaryDecisionDiagramExplanation', classMeta, undefined, [ProbExplanation], undefined, undefined, []);
+  setMetadataFor(ClauseMappingUtils, 'ClauseMappingUtils', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(DirectiveClauseMapper, 'DirectiveClauseMapper', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(EvidenceClauseMapper, 'EvidenceClauseMapper', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(MappedMutableProblogTheory, 'MappedMutableProblogTheory', classMeta, undefined, [MutableTheory, ProblogTheory], undefined, undefined, []);
+  setMetadataFor(MappedProblogTheory, 'MappedProblogTheory', classMeta, undefined, [Theory, ProblogTheory], undefined, undefined, []);
+  setMetadataFor(NothingClauseMapper, 'NothingClauseMapper', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(ProbabilisticClauseMapper, 'ProbabilisticClauseMapper', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(PrologClauseMapper, 'PrologClauseMapper', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(ProbExplAnd, 'ProbExplAnd', objectMeta, NonBacktrackable, undefined, undefined, undefined, []);
+  setMetadataFor(ProbHelper$computeAllSubstitutions$slambda, 'ProbHelper$computeAllSubstitutions$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(ProbHelper, 'ProbHelper', objectMeta, WithoutSideEffects, undefined, undefined, undefined, []);
+  setMetadataFor(ProbNegationAsFailure, 'ProbNegationAsFailure', objectMeta, NonBacktrackable_0, undefined, undefined, undefined, []);
+  setMetadataFor(ProbQuery$computeAllSubstitutions$slambda, 'ProbQuery$computeAllSubstitutions$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(ProbQuery, 'ProbQuery', objectMeta, WithoutSideEffects_0, undefined, undefined, undefined, []);
+  setMetadataFor(ProbSetConfig, 'ProbSetConfig', objectMeta, NonBacktrackable_1, undefined, undefined, undefined, []);
+  setMetadataFor(ProbSolve$computeAllSubstitutions$slambda, 'ProbSolve$computeAllSubstitutions$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(ProbSolve, 'ProbSolve', objectMeta, WithoutSideEffects_1, undefined, undefined, undefined, []);
+  setMetadataFor(ProbSolveEvidence, 'ProbSolveEvidence', objectMeta, NonBacktrackable_1, undefined, undefined, undefined, []);
+  setMetadataFor(ProbSolveWithEvidence$computeAllSubstitutions$slambda, 'ProbSolveWithEvidence$computeAllSubstitutions$slambda', classMeta, CoroutineImpl, undefined, undefined, undefined, [1]);
+  setMetadataFor(ProbSolveWithEvidence, 'ProbSolveWithEvidence', objectMeta, WithoutSideEffects, undefined, undefined, undefined, []);
+  setMetadataFor(Prob, 'Prob', objectMeta, RuleWrapper, undefined, undefined, undefined, []);
+  //endregion
+  function MutableProblogSolver(solver) {
+    ProblogSolver.call(this, solver);
+    this.s3b_1 = solver;
+  }
+  MutableProblogSolver.prototype.f37 = function (library) {
+    this.s3b_1.loadLibrary(library);
+  };
+  MutableProblogSolver.prototype.loadLibrary = function (library) {
+    return this.f37(library);
+  };
+  MutableProblogSolver.prototype.g37 = function (library) {
+    this.s3b_1.unloadLibrary(library);
+  };
+  MutableProblogSolver.prototype.unloadLibrary = function (library) {
+    return this.g37(library);
+  };
+  MutableProblogSolver.prototype.h37 = function (libraries) {
+    this.s3b_1.setLibraries(libraries);
+  };
+  MutableProblogSolver.prototype.setLibraries = function (libraries) {
+    return this.h37(libraries);
+  };
+  MutableProblogSolver.prototype.i37 = function (theory) {
+    this.s3b_1.loadStaticKb(Companion_getInstance_22().ofIterable(this.s3b_1.k1l(), theory));
+  };
+  MutableProblogSolver.prototype.loadStaticKb = function (theory) {
+    return this.i37(theory);
+  };
+  MutableProblogSolver.prototype.j37 = function (theory) {
+    this.s3b_1.appendStaticKb(Companion_getInstance_22().ofIterable(this.s3b_1.k1l(), theory));
+  };
+  MutableProblogSolver.prototype.appendStaticKb = function (theory) {
+    return this.j37(theory);
+  };
+  MutableProblogSolver.prototype.k37 = function () {
+    this.s3b_1.resetStaticKb();
+  };
+  MutableProblogSolver.prototype.resetStaticKb = function () {
+    return this.k37();
+  };
+  MutableProblogSolver.prototype.l37 = function (theory) {
+    this.s3b_1.loadDynamicKb(Companion_getInstance_22().ofIterable(this.s3b_1.k1l(), theory));
+  };
+  MutableProblogSolver.prototype.loadDynamicKb = function (theory) {
+    return this.l37(theory);
+  };
+  MutableProblogSolver.prototype.m37 = function (theory) {
+    this.s3b_1.appendDynamicKb(Companion_getInstance_22().ofIterable(this.s3b_1.k1l(), theory));
+  };
+  MutableProblogSolver.prototype.appendDynamicKb = function (theory) {
+    return this.m37(theory);
+  };
+  MutableProblogSolver.prototype.n37 = function () {
+    this.s3b_1.resetDynamicKb();
+  };
+  MutableProblogSolver.prototype.resetDynamicKb = function () {
+    return this.n37();
+  };
+  MutableProblogSolver.prototype.w1m = function (clause) {
+    this.s3b_1.assertA(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [clause]).t1l()));
+  };
+  MutableProblogSolver.prototype.assertA = function (clause) {
+    return this.w1m(clause);
+  };
+  MutableProblogSolver.prototype.o37 = function (fact) {
+    this.s3b_1.assertA(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [Companion_getInstance().of(fact)]).t1l()));
+  };
+  MutableProblogSolver.prototype.assertAFact = function (fact) {
+    return this.o37(fact);
+  };
+  MutableProblogSolver.prototype.w1l = function (clause) {
+    this.s3b_1.assertZ(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [clause]).t1l()));
+  };
+  MutableProblogSolver.prototype.assertZ = function (clause) {
+    return this.w1l(clause);
+  };
+  MutableProblogSolver.prototype.p37 = function (fact) {
+    this.s3b_1.assertA(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [Companion_getInstance().of(fact)]).t1l()));
+  };
+  MutableProblogSolver.prototype.assertZFact = function (fact) {
+    return this.p37(fact);
+  };
+  MutableProblogSolver.prototype.e1t = function (clause) {
+    return this.s3b_1.retract(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [clause]).t1l()));
+  };
+  MutableProblogSolver.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  MutableProblogSolver.prototype.f1t = function (fact) {
+    return this.s3b_1.retract(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [Companion_getInstance().of(fact)]).t1l()));
+  };
+  MutableProblogSolver.prototype.retractByHead = function (fact) {
+    return this.f1t(fact);
+  };
+  MutableProblogSolver.prototype.c1m = function (clause) {
+    return this.s3b_1.retractAll(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [clause]).t1l()));
+  };
+  MutableProblogSolver.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  MutableProblogSolver.prototype.q37 = function (fact) {
+    return this.s3b_1.retractAll(first(Companion_getInstance_22().of(this.s3b_1.k1l(), [Companion_getInstance().of(fact)]).t1l()));
+  };
+  MutableProblogSolver.prototype.retractAllBeHead = function (fact) {
+    return this.q37(fact);
+  };
+  MutableProblogSolver.prototype.r37 = function (name, value) {
+    this.s3b_1.setFlag(name, value);
+  };
+  MutableProblogSolver.prototype.setFlag = function (name, value) {
+    return this.r37(name, value);
+  };
+  MutableProblogSolver.prototype.s37 = function (flag) {
+    this.s3b_1.setFlagPair(flag);
+  };
+  MutableProblogSolver.prototype.setFlagPair = function (flag) {
+    return this.s37(flag);
+  };
+  MutableProblogSolver.prototype.t37 = function (flag) {
+    this.s3b_1.setFlagNotable(flag);
+  };
+  MutableProblogSolver.prototype.setFlagNotable = function (flag) {
+    return this.t37(flag);
+  };
+  MutableProblogSolver.prototype.u37 = function (stdIn) {
+    this.s3b_1.setStandardInput(stdIn);
+  };
+  MutableProblogSolver.prototype.setStandardInput = function (stdIn) {
+    return this.u37(stdIn);
+  };
+  MutableProblogSolver.prototype.v37 = function (stdErr) {
+    this.s3b_1.setStandardError(stdErr);
+  };
+  MutableProblogSolver.prototype.setStandardError = function (stdErr) {
+    return this.v37(stdErr);
+  };
+  MutableProblogSolver.prototype.w37 = function (stdOut) {
+    this.s3b_1.setStandardOutput(stdOut);
+  };
+  MutableProblogSolver.prototype.setStandardOutput = function (stdOut) {
+    return this.w37(stdOut);
+  };
+  MutableProblogSolver.prototype.x37 = function (warnings) {
+    this.s3b_1.setWarnings(warnings);
+  };
+  MutableProblogSolver.prototype.setWarnings = function (warnings) {
+    return this.x37(warnings);
+  };
+  MutableProblogSolver.prototype.p1v = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return new MutableProblogSolver(this.s3b_1.p1v(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings));
+  };
+  MutableProblogSolver.prototype.z1s = function () {
+    return new MutableProblogSolver(this.s3b_1.z1s());
+  };
+  MutableProblogSolver.prototype.clone = function () {
+    return this.z1s();
+  };
+  function get_ANNOTATION_OPERATOR() {
+    init_properties_Operators_kt_f59079();
+    return ANNOTATION_OPERATOR;
+  }
+  var ANNOTATION_OPERATOR;
+  function get_PROBLOG_SPECIFIC_OPERATORS() {
+    init_properties_Operators_kt_f59079();
+    return PROBLOG_SPECIFIC_OPERATORS;
+  }
+  var PROBLOG_SPECIFIC_OPERATORS;
+  var PROBLOG_OPERATORS;
+  function get_ANNOTATION_FUNCTOR() {
+    return ANNOTATION_FUNCTOR;
+  }
+  var ANNOTATION_FUNCTOR;
+  var properties_initialized_Operators_kt_vybuzl;
+  function init_properties_Operators_kt_f59079() {
+    if (properties_initialized_Operators_kt_vybuzl) {
+    } else {
+      properties_initialized_Operators_kt_vybuzl = true;
+      ANNOTATION_OPERATOR = new Operator('::', Specifier_XFY_getInstance(), 900);
+      PROBLOG_SPECIFIC_OPERATORS = OperatorSet_init_$Create$([get_ANNOTATION_OPERATOR()]);
+      PROBLOG_OPERATORS = Companion_getInstance_0().DEFAULT.plusOperatorSet(get_PROBLOG_SPECIFIC_OPERATORS());
+    }
+  }
+  function solveNonProbabilistically($this, goal, options) {
+    var anonVar = Companion_getInstance_1().anonymous();
+    var tmp = Companion_getInstance_2();
+    var tmp_0 = Companion_getInstance_3();
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp0__get_functor__thl4dk = ProbSetConfig_getInstance();
+    tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+    var tmp_1 = tmp_0.of(tmp$ret$0, [ProbSetConfig_getInstance().g3c(options)]);
+    var tmp_2 = Companion_getInstance_3();
+    var tmp$ret$1;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp1__get_functor__4k11yf = Prob_getInstance();
+    tmp$ret$1 = tmp1__get_functor__4k11yf.signature.name;
+    var tmp_3 = $this.t3b_1.solveWithOptions(tmp.of(tmp_1, tmp_2.of(tmp$ret$1, [anonVar, goal])), options);
+    return map(tmp_3, ProblogSolver$solveNonProbabilistically$lambda(goal, anonVar));
+  }
+  function solveProbabilistically($this, goal, options) {
+    var probabilityVar = Companion_getInstance_1().of('Prob');
+    var bddVar = Companion_getInstance_1().of('BDD');
+    var tmp = Companion_getInstance_3();
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp0__get_functor__thl4dk = ProbQuery_getInstance();
+    tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+    var tmp_0 = $this.t3b_1.solveWithOptions(tmp.of(tmp$ret$0, [probabilityVar, goal, ProbSetConfig_getInstance().g3c(options), bddVar]), options);
+    return map(tmp_0, ProblogSolver$solveProbabilistically$lambda(probabilityVar, bddVar, goal, options));
+  }
+  function ProblogSolver$solveNonProbabilistically$lambda$lambda($anonVar) {
+    return function (key, _anonymous_parameter_1__qggqgd) {
+      return !key.equals($anonVar);
+    };
+  }
+  function ProblogSolver$solveNonProbabilistically$lambda($goal, $anonVar) {
+    return function (it) {
+      var tmp0_subject = it;
+      var tmp;
+      if (isInterface(tmp0_subject, Yes)) {
+        var tmp_0 = Companion_getInstance_4();
+        var tmp_1 = it.r1u();
+        tmp = tmp_0.m1w($goal, tmp_1.l12(ProblogSolver$solveNonProbabilistically$lambda$lambda($anonVar)));
+      } else {
+        if (isInterface(tmp0_subject, Halt)) {
+          tmp = Companion_getInstance_4().halt($goal, it.c1w());
+        } else {
+          tmp = Companion_getInstance_4().no($goal);
+        }
+      }
+      return tmp;
+    };
+  }
+  function ProblogSolver$solveProbabilistically$lambda$lambda($probabilityVar, $bddVar) {
+    return function (key, _anonymous_parameter_1__qggqgd) {
+      return !key.equals($probabilityVar) ? !key.equals($bddVar) : false;
+    };
+  }
+  function ProblogSolver$solveProbabilistically$lambda($probabilityVar, $bddVar, $goal, $options) {
+    return function (it) {
+      var probabilityTerm = it.r1u().a3($probabilityVar);
+      var bddTerm = it.r1u().a3($bddVar);
+      var tmp0_subject = it;
+      var tmp;
+      if (isInterface(tmp0_subject, Yes)) {
+        var tmp_0 = Companion_getInstance_4();
+        var tmp_1 = it.r1u();
+        tmp = tmp_0.m1w($goal, tmp_1.l12(ProblogSolver$solveProbabilistically$lambda$lambda($probabilityVar, $bddVar)));
+      } else {
+        if (isInterface(tmp0_subject, Halt)) {
+          tmp = Companion_getInstance_4().halt($goal, it.c1w());
+        } else {
+          tmp = Companion_getInstance_4().no($goal);
+        }
+      }
+      var newSolution = tmp;
+      var tmp_2;
+      if (!get_isProbabilistic($options)) {
+        tmp_2 = newSolution;
+      } else {
+        var tmp1_subject = probabilityTerm;
+        var tmp_3;
+        if (!(tmp1_subject == null) ? isInterface(tmp1_subject, Numeric) : false) {
+          tmp_3 = setProbability(newSolution, probabilityTerm.x10().toDouble());
+        } else {
+          var tmp_4 = newSolution;
+          DoubleCompanionObject_getInstance();
+          tmp_3 = setProbability(tmp_4, NaN);
+        }
+        newSolution = tmp_3;
+        var tmp_5;
+        if (!(bddTerm == null)) {
+          tmp_5 = bddTerm instanceof ProbExplanationTerm;
+        } else {
+          tmp_5 = false;
+        }
+        if (tmp_5) {
+          var explanation = bddTerm.h3c_1;
+          if (explanation instanceof BinaryDecisionDiagramExplanation) {
+            newSolution = setBinaryDecisionDiagram(newSolution, explanation.j3c_1);
+          }
+        }
+        tmp_2 = newSolution;
+      }
+      return tmp_2;
+    };
+  }
+  function ProblogSolver(solver) {
+    this.t3b_1 = solver;
+  }
+  ProblogSolver.prototype.z1u = function () {
+    return this.t3b_1.z1u();
+  };
+  ProblogSolver.prototype.x1u = function () {
+    return this.t3b_1.x1u();
+  };
+  ProblogSolver.prototype.a1v = function () {
+    return this.t3b_1.a1v();
+  };
+  ProblogSolver.prototype.w1u = function () {
+    return this.t3b_1.w1u();
+  };
+  ProblogSolver.prototype.h1v = function () {
+    return this.t3b_1.h1v();
+  };
+  ProblogSolver.prototype.b1v = function () {
+    return this.t3b_1.b1v();
+  };
+  ProblogSolver.prototype.m1v = function () {
+    return this.t3b_1.m1v();
+  };
+  ProblogSolver.prototype.i1v = function () {
+    return this.t3b_1.i1v();
+  };
+  ProblogSolver.prototype.k1v = function () {
+    return this.t3b_1.k1v();
+  };
+  ProblogSolver.prototype.y1u = function () {
+    return this.t3b_1.y1u();
+  };
+  ProblogSolver.prototype.k1l = function () {
+    return this.t3b_1.k1l();
+  };
+  ProblogSolver.prototype.o1v = function () {
+    return this.t3b_1.o1v();
+  };
+  ProblogSolver.prototype.u2b = function (goal, options) {
+    var tmp;
+    if (!get_isProbabilistic(options)) {
+      tmp = solveNonProbabilistically(this, goal, options);
+    } else {
+      tmp = solveProbabilistically(this, goal, options);
+    }
+    return tmp;
+  };
+  ProblogSolver.prototype.solveWithOptions = function (goal, options) {
+    return this.u2b(goal, options);
+  };
+  ProblogSolver.prototype.u3b = function (goal, timeout) {
+    return this.u2b(goal, Companion_getInstance_5().allLazilyWithTimeout(timeout));
+  };
+  ProblogSolver.prototype.solveWithTimeout = function (goal, timeout) {
+    return this.u3b(goal, timeout);
+  };
+  ProblogSolver.prototype.v3b = function (goal) {
+    return this.u2b(goal, Companion_getInstance_5().DEFAULT);
+  };
+  ProblogSolver.prototype.solve = function (goal) {
+    return this.v3b(goal);
+  };
+  ProblogSolver.prototype.w3b = function (goal, timeout) {
+    return toList(this.u3b(goal, timeout));
+  };
+  ProblogSolver.prototype.solveListWithTimeout = function (goal, timeout) {
+    return this.w3b(goal, timeout);
+  };
+  ProblogSolver.prototype.x3b = function (goal) {
+    return toList(this.v3b(goal));
+  };
+  ProblogSolver.prototype.solveList = function (goal) {
+    return this.x3b(goal);
+  };
+  ProblogSolver.prototype.y3b = function (goal, options) {
+    return toList(this.u2b(goal, options));
+  };
+  ProblogSolver.prototype.solveListWithOptions = function (goal, options) {
+    return this.y3b(goal, options);
+  };
+  ProblogSolver.prototype.z3b = function (goal, timeout) {
+    return first_0(this.u2b(goal, Companion_getInstance_5().someLazilyWithTimeout(1, timeout)));
+  };
+  ProblogSolver.prototype.solveOnceWithTimeout = function (goal, timeout) {
+    return this.z3b(goal, timeout);
+  };
+  ProblogSolver.prototype.a3c = function (goal) {
+    return first_0(this.u2b(goal, Companion_getInstance_5().someLazily(1)));
+  };
+  ProblogSolver.prototype.solveOnce = function (goal) {
+    return this.a3c(goal);
+  };
+  ProblogSolver.prototype.b3c = function (goal, options) {
+    return first_0(this.u2b(goal, options.setLimit(1)));
+  };
+  ProblogSolver.prototype.solveOnceWithOptions = function (goal, options) {
+    return this.b3c(goal, options);
+  };
+  ProblogSolver.prototype.p1v = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return new ProblogSolver(this.t3b_1.p1v(unificator, libraries, flags, Companion_getInstance_22().ofIterable(unificator, staticKb), Companion_getInstance_22().ofIterable(unificator, dynamicKb), stdIn, stdOut, stdErr, warnings));
+  };
+  ProblogSolver.prototype.z1s = function () {
+    return new ProblogSolver(this.t3b_1.clone());
+  };
+  ProblogSolver.prototype.clone = function () {
+    return this.z1s();
+  };
+  function ensureVariablesTracking($this, flags) {
+    var tmp = TrackVariables_getInstance();
+    return flags.plusPair(invoke(tmp, ProblogSolverFactory$ensureVariablesTracking$lambda));
+  }
+  function fixLibraries($this, libraries) {
+    var tmp;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.contains' call
+    var tmp0_contains = ProblogLib_getInstance().i2e();
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.containsKey' call
+    tmp$ret$0 = (isInterface(libraries, Map) ? libraries : THROW_CCE()).u2(tmp0_contains);
+    tmp$ret$1 = tmp$ret$0;
+    if (!tmp$ret$1) {
+      tmp = libraries.plusLibrary(MinimalBuiltins_getInstance());
+    } else {
+      tmp = libraries;
+    }
+    return tmp;
+  }
+  function ProblogSolverFactory$ensureVariablesTracking$lambda($this$invoke) {
+    return $this$invoke.m29_1;
+  }
+  function ProblogSolverFactory() {
+    ProblogSolverFactory_instance = this;
+  }
+  ProblogSolverFactory.prototype.d1y = function () {
+    return DefaultBuiltins_getInstance_0();
+  };
+  ProblogSolverFactory.prototype.f1y = function () {
+    return ensureVariablesTracking(this, get_defaultFlags.call(this));
+  };
+  ProblogSolverFactory.prototype.t1y = function (unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs) {
+    return new ProblogSolver(ClassicSolverFactory_getInstance().t1y(unificator, fixLibraries(this, libraries), ensureVariablesTracking(this, flags), Companion_getInstance_22().ofIterable(unificator, staticKb), Companion_getInstance_22().ofIterable(unificator, dynamicKb), inputs, outputs));
+  };
+  ProblogSolverFactory.prototype.v1y = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return new ProblogSolver(ClassicSolverFactory_getInstance().v1y(unificator, fixLibraries(this, libraries), ensureVariablesTracking(this, flags), Companion_getInstance_22().ofIterable(unificator, staticKb), Companion_getInstance_22().ofIterable(unificator, dynamicKb), stdIn, stdOut, stdErr, warnings));
+  };
+  ProblogSolverFactory.prototype.z1y = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
+    return new MutableProblogSolver(ClassicSolverFactory_getInstance().z1y(unificator, fixLibraries(this, libraries), ensureVariablesTracking(this, flags), Companion_getInstance_22().ofIterable(unificator, staticKb), Companion_getInstance_22().ofIterable(unificator, dynamicKb), stdIn, stdOut, stdErr, warnings));
+  };
+  ProblogSolverFactory.prototype.d1z = function (unificator, libraries, flags, staticKb, dynamicKb, inputs, outputs) {
+    return new MutableProblogSolver(ClassicSolverFactory_getInstance().d1z(unificator, fixLibraries(this, libraries), ensureVariablesTracking(this, flags), Companion_getInstance_22().ofIterable(unificator, staticKb), Companion_getInstance_22().ofIterable(unificator, dynamicKb), inputs, outputs));
+  };
+  var ProblogSolverFactory_instance;
+  function ProblogSolverFactory_getInstance() {
+    if (ProblogSolverFactory_instance == null)
+      new ProblogSolverFactory();
+    return ProblogSolverFactory_instance;
+  }
+  function DefaultBuiltins() {
+    DefaultBuiltins_instance = this;
+    ExtensionLibrary.call(this, DefaultBuiltins_getInstance());
+  }
+  DefaultBuiltins.prototype.i2e = function () {
+    return ProblogLib_getInstance().i2e();
+  };
+  DefaultBuiltins.prototype.t2e = function () {
+    return ProblogLib_getInstance().t2e();
+  };
+  DefaultBuiltins.prototype.y2e = function () {
+    return ProblogLib_getInstance().y2e();
+  };
+  DefaultBuiltins.prototype.x2e = function () {
+    return ProblogLib_getInstance().x2e();
+  };
+  var DefaultBuiltins_instance;
+  function DefaultBuiltins_getInstance_0() {
+    if (DefaultBuiltins_instance == null)
+      new DefaultBuiltins();
+    return DefaultBuiltins_instance;
+  }
+  function MinimalBuiltins() {
+    MinimalBuiltins_instance = this;
+    ExtensionLibrary.call(this, ProblogLib_getInstance());
+  }
+  MinimalBuiltins.prototype.y2e = function () {
+    return listOf(EnsureExecutable_getInstance());
+  };
+  MinimalBuiltins.prototype.x2e = function () {
+    return listOf(Call_getInstance());
+  };
+  var MinimalBuiltins_instance;
+  function MinimalBuiltins_getInstance() {
+    if (MinimalBuiltins_instance == null)
+      new MinimalBuiltins();
+    return MinimalBuiltins_instance;
+  }
+  function ProblogLib() {
+    ProblogLib_instance = this;
+    var tmp = Companion_getInstance_6();
+    ExtensionLibrary.call(this, tmp.e2e('problog.lang', null, null, null, null, 30, null));
+    this.a3d_1 = 'EXPL';
+    this.b3d_1 = 'evidence';
+    this.c3d_1 = 'prob';
+  }
+  ProblogLib.prototype.t2e = function () {
+    return get_PROBLOG_SPECIFIC_OPERATORS();
+  };
+  ProblogLib.prototype.x2e = function () {
+    return listOf(Prob_getInstance());
+  };
+  ProblogLib.prototype.y2e = function () {
+    return listOf_0([ProbHelper_getInstance(), ProbSolve_getInstance(), ProbExplAnd_getInstance(), ProbQuery_getInstance(), ProbSolveEvidence_getInstance(), ProbSolveWithEvidence_getInstance(), ProbNegationAsFailure_getInstance(), ProbSetConfig_getInstance()]);
+  };
+  var ProblogLib_instance;
+  function ProblogLib_getInstance() {
+    if (ProblogLib_instance == null)
+      new ProblogLib();
+    return ProblogLib_instance;
+  }
+  function ClauseMappingException_init_$Init$(message, cause, $mask0, $marker, $this) {
+    if (!(($mask0 & 2) === 0))
+      cause = null;
+    ClauseMappingException.call($this, message, cause);
+    return $this;
+  }
+  function ClauseMappingException_init_$Create$(message, cause, $mask0, $marker) {
+    var tmp = ClauseMappingException_init_$Init$(message, cause, $mask0, $marker, Object.create(ClauseMappingException.prototype));
+    captureStack(tmp, ClauseMappingException_init_$Create$);
+    return tmp;
+  }
+  function ClauseMappingException(message, cause) {
+    TuPrologException_init_$Init$(cause, this);
+    this.j3d_1 = message;
+    captureStack(this, ClauseMappingException);
+  }
+  ClauseMappingException.prototype.k1 = function () {
+    return this.j3d_1;
+  };
+  Object.defineProperty(ClauseMappingException.prototype, 'message', {
+    configurable: true,
+    get: function () {
+      return this.k1();
+    }
+  });
+  function Companion() {
+    Companion_instance = this;
+  }
+  Companion.prototype.empty = function (unificator) {
+    return this.ofIterable(unificator, emptyList());
+  };
+  Companion.prototype.of = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable(clauses));
+  };
+  Companion.prototype.ofSequence = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable_0(clauses));
+  };
+  Companion.prototype.ofScopes = function (unificator, clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(clauses.length);
+    var indexedObject = clauses;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.Companion.of.<anonymous>' call
+      tmp$ret$0 = item(Companion_getInstance_7().empty());
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.ofIterable(unificator, tmp$ret$2);
+  };
+  Companion.prototype.ofIterable = function (unificator, clauses) {
+    return MappedMutableProblogTheory_init_$Create$(clauses, unificator, null, 4, null);
+  };
+  var Companion_instance;
+  function Companion_getInstance_20() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+    this.k3d_1 = new BinaryDecisionDiagramExplanation(bddTerminalOf(false), Companion_getInstance_23().n3d_1);
+    this.l3d_1 = new BinaryDecisionDiagramExplanation(bddTerminalOf(true), Companion_getInstance_23().o3d_1);
+  }
+  Companion_0.prototype.p3d = function (term) {
+    return new BinaryDecisionDiagramExplanation(bddOf(term), new ComputedValue(term.r3d_1));
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_21() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function ProbExplanation() {
+  }
+  function ProbExplanationTerm$freshCopy$lambda(it) {
+    return it.iw();
+  }
+  function ProbExplanationTerm$freshCopy$lambda_0($scope) {
+    return function (it) {
+      return it.jw($scope);
+    };
+  }
+  function ProbExplanationTerm$apply$lambda($substitution) {
+    return function (it) {
+      return it.s16($substitution);
+    };
+  }
+  function ProbExplanationTerm(explanation) {
+    this.h3c_1 = explanation;
+    this.i3c_1 = Companion_getInstance_8().of('<expl:' + explanation + '>');
+  }
+  ProbExplanationTerm.prototype.gw = function () {
+    return this.i3c_1.gw();
+  };
+  ProbExplanationTerm.prototype.yw = function () {
+    return this.i3c_1.yw();
+  };
+  ProbExplanationTerm.prototype.zv = function () {
+    return this.i3c_1.zv();
+  };
+  ProbExplanationTerm.prototype.fw = function () {
+    return this.i3c_1.fw();
+  };
+  ProbExplanationTerm.prototype.xw = function () {
+    return this.i3c_1.xw();
+  };
+  ProbExplanationTerm.prototype.aw = function () {
+    return this.i3c_1.aw();
+  };
+  ProbExplanationTerm.prototype.tw = function () {
+    return this.i3c_1.tw();
+  };
+  ProbExplanationTerm.prototype.mw = function () {
+    return this.i3c_1.mw();
+  };
+  ProbExplanationTerm.prototype.sw = function () {
+    return this.i3c_1.sw();
+  };
+  ProbExplanationTerm.prototype.ow = function () {
+    return this.i3c_1.ow();
+  };
+  ProbExplanationTerm.prototype.bw = function () {
+    return this.i3c_1.bw();
+  };
+  ProbExplanationTerm.prototype.cw = function () {
+    return this.i3c_1.cw();
+  };
+  ProbExplanationTerm.prototype.pw = function () {
+    return this.i3c_1.pw();
+  };
+  ProbExplanationTerm.prototype.ew = function () {
+    return this.i3c_1.ew();
+  };
+  ProbExplanationTerm.prototype.ww = function () {
+    return this.i3c_1.ww();
+  };
+  ProbExplanationTerm.prototype.uw = function () {
+    return this.i3c_1.uw();
+  };
+  ProbExplanationTerm.prototype.gx = function () {
+    return this.i3c_1.gx();
+  };
+  ProbExplanationTerm.prototype.rw = function () {
+    return this.i3c_1.rw();
+  };
+  ProbExplanationTerm.prototype.fx = function () {
+    return this.i3c_1.fx();
+  };
+  ProbExplanationTerm.prototype.hx = function () {
+    return this.i3c_1.hx();
+  };
+  ProbExplanationTerm.prototype.dx = function () {
+    return this.i3c_1.dx();
+  };
+  ProbExplanationTerm.prototype.nw = function () {
+    return this.i3c_1.nw();
+  };
+  ProbExplanationTerm.prototype.lw = function () {
+    return this.i3c_1.lw();
+  };
+  ProbExplanationTerm.prototype.dw = function () {
+    return this.i3c_1.dw();
+  };
+  ProbExplanationTerm.prototype.cx = function () {
+    return this.i3c_1.cx();
+  };
+  ProbExplanationTerm.prototype.qw = function () {
+    return this.i3c_1.qw();
+  };
+  ProbExplanationTerm.prototype.bx = function () {
+    return this.i3c_1.bx();
+  };
+  ProbExplanationTerm.prototype.kt = function () {
+    return this.i3c_1.kt();
+  };
+  ProbExplanationTerm.prototype.b1 = function () {
+    return this.i3c_1.b1();
+  };
+  ProbExplanationTerm.prototype.hw = function () {
+    return this.i3c_1.hw();
+  };
+  ProbExplanationTerm.prototype.accept = function (visitor) {
+    return this.i3c_1.accept(visitor);
+  };
+  ProbExplanationTerm.prototype.addFirst = function (argument) {
+    return this.i3c_1.addFirst(argument);
+  };
+  ProbExplanationTerm.prototype.addLast = function (argument) {
+    return this.i3c_1.addLast(argument);
+  };
+  ProbExplanationTerm.prototype.append = function (argument) {
+    return this.i3c_1.append(argument);
+  };
+  ProbExplanationTerm.prototype.kw = function () {
+    return this.i3c_1.kw();
+  };
+  ProbExplanationTerm.prototype.asAtom = function () {
+    return this.kw();
+  };
+  ProbExplanationTerm.prototype.asBlock = function () {
+    return this.i3c_1.asBlock();
+  };
+  ProbExplanationTerm.prototype.asClause = function () {
+    return this.i3c_1.asClause();
+  };
+  ProbExplanationTerm.prototype.asCons = function () {
+    return this.i3c_1.asCons();
+  };
+  ProbExplanationTerm.prototype.asDirective = function () {
+    return this.i3c_1.asDirective();
+  };
+  ProbExplanationTerm.prototype.asEmptyBlock = function () {
+    return this.i3c_1.asEmptyBlock();
+  };
+  ProbExplanationTerm.prototype.asEmptyList = function () {
+    return this.i3c_1.asEmptyList();
+  };
+  ProbExplanationTerm.prototype.asFact = function () {
+    return this.i3c_1.asFact();
+  };
+  ProbExplanationTerm.prototype.asIndicator = function () {
+    return this.i3c_1.asIndicator();
+  };
+  ProbExplanationTerm.prototype.asInteger = function () {
+    return this.i3c_1.asInteger();
+  };
+  ProbExplanationTerm.prototype.asList = function () {
+    return this.i3c_1.asList();
+  };
+  ProbExplanationTerm.prototype.asNumeric = function () {
+    return this.i3c_1.asNumeric();
+  };
+  ProbExplanationTerm.prototype.asReal = function () {
+    return this.i3c_1.asReal();
+  };
+  ProbExplanationTerm.prototype.asRecursive = function () {
+    return this.i3c_1.asRecursive();
+  };
+  ProbExplanationTerm.prototype.asRule = function () {
+    return this.i3c_1.asRule();
+  };
+  ProbExplanationTerm.prototype.vw = function () {
+    return this.i3c_1.vw();
+  };
+  ProbExplanationTerm.prototype.asStruct = function () {
+    return this.vw();
+  };
+  ProbExplanationTerm.prototype.asTerm = function () {
+    return this.i3c_1.asTerm();
+  };
+  ProbExplanationTerm.prototype.asTruth = function () {
+    return this.i3c_1.asTruth();
+  };
+  ProbExplanationTerm.prototype.asTuple = function () {
+    return this.i3c_1.asTuple();
+  };
+  ProbExplanationTerm.prototype.asVar = function () {
+    return this.i3c_1.asVar();
+  };
+  ProbExplanationTerm.prototype.zw = function () {
+    return this.i3c_1.zw();
+  };
+  ProbExplanationTerm.prototype.qq = function () {
+    return this.zw();
+  };
+  ProbExplanationTerm.prototype.castToAtom = function () {
+    return this.i3c_1.castToAtom();
+  };
+  ProbExplanationTerm.prototype.castToBlock = function () {
+    return this.i3c_1.castToBlock();
+  };
+  ProbExplanationTerm.prototype.castToClause = function () {
+    return this.i3c_1.castToClause();
+  };
+  ProbExplanationTerm.prototype.castToCons = function () {
+    return this.i3c_1.castToCons();
+  };
+  ProbExplanationTerm.prototype.castToConstant = function () {
+    return this.i3c_1.castToConstant();
+  };
+  ProbExplanationTerm.prototype.castToDirective = function () {
+    return this.i3c_1.castToDirective();
+  };
+  ProbExplanationTerm.prototype.castToEmptyBlock = function () {
+    return this.i3c_1.castToEmptyBlock();
+  };
+  ProbExplanationTerm.prototype.castToEmptyList = function () {
+    return this.i3c_1.castToEmptyList();
+  };
+  ProbExplanationTerm.prototype.castToFact = function () {
+    return this.i3c_1.castToFact();
+  };
+  ProbExplanationTerm.prototype.castToIndicator = function () {
+    return this.i3c_1.castToIndicator();
+  };
+  ProbExplanationTerm.prototype.castToInteger = function () {
+    return this.i3c_1.castToInteger();
+  };
+  ProbExplanationTerm.prototype.castToList = function () {
+    return this.i3c_1.castToList();
+  };
+  ProbExplanationTerm.prototype.castToNumeric = function () {
+    return this.i3c_1.castToNumeric();
+  };
+  ProbExplanationTerm.prototype.castToReal = function () {
+    return this.i3c_1.castToReal();
+  };
+  ProbExplanationTerm.prototype.castToRecursive = function () {
+    return this.i3c_1.castToRecursive();
+  };
+  ProbExplanationTerm.prototype.castToRule = function () {
+    return this.i3c_1.castToRule();
+  };
+  ProbExplanationTerm.prototype.castToStruct = function () {
+    return this.i3c_1.castToStruct();
+  };
+  ProbExplanationTerm.prototype.castToTerm = function () {
+    return this.i3c_1.castToTerm();
+  };
+  ProbExplanationTerm.prototype.castToTruth = function () {
+    return this.i3c_1.castToTruth();
+  };
+  ProbExplanationTerm.prototype.castToTuple = function () {
+    return this.i3c_1.castToTuple();
+  };
+  ProbExplanationTerm.prototype.castToVar = function () {
+    return this.i3c_1.castToVar();
+  };
+  ProbExplanationTerm.prototype.ax = function (other) {
+    return this.i3c_1.ax(other);
+  };
+  ProbExplanationTerm.prototype.aa = function (other) {
+    return this.ax((!(other == null) ? isInterface(other, Term) : false) ? other : THROW_CCE());
+  };
+  ProbExplanationTerm.prototype.containsTag = function (name) {
+    return this.i3c_1.containsTag(name);
+  };
+  ProbExplanationTerm.prototype.equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.i3c_1.equalsUsingVarCompleteNames(other, useVarCompleteName);
+  };
+  ProbExplanationTerm.prototype.equals = function (other) {
+    return this.i3c_1.equals(other);
+  };
+  ProbExplanationTerm.prototype.get = function (index) {
+    return this.i3c_1.get(index);
+  };
+  ProbExplanationTerm.prototype.getArgAt = function (index) {
+    return this.i3c_1.getArgAt(index);
+  };
+  ProbExplanationTerm.prototype.getTag = function (name) {
+    return this.i3c_1.getTag(name);
+  };
+  ProbExplanationTerm.prototype.hashCode = function () {
+    return this.i3c_1.hashCode();
+  };
+  ProbExplanationTerm.prototype.insertAt = function (index, argument) {
+    return this.i3c_1.insertAt(index, argument);
+  };
+  ProbExplanationTerm.prototype.resetTags = function (tags) {
+    return this.i3c_1.resetTags(tags);
+  };
+  ProbExplanationTerm.prototype.setArgs = function (args) {
+    return this.i3c_1.setArgs(args);
+  };
+  ProbExplanationTerm.prototype.setArgsIterable = function (args) {
+    return this.i3c_1.setArgsIterable(args);
+  };
+  ProbExplanationTerm.prototype.setArgsSequence = function (args) {
+    return this.i3c_1.setArgsSequence(args);
+  };
+  ProbExplanationTerm.prototype.setFunctor = function (functor) {
+    return this.i3c_1.setFunctor(functor);
+  };
+  ProbExplanationTerm.prototype.structurallyEquals = function (other) {
+    return this.i3c_1.structurallyEquals(other);
+  };
+  ProbExplanationTerm.prototype.toString = function () {
+    return this.i3c_1.toString();
+  };
+  ProbExplanationTerm.prototype.ex = function () {
+    return false;
+  };
+  ProbExplanationTerm.prototype.ix = function () {
+    return this;
+  };
+  ProbExplanationTerm.prototype.asConstant = function () {
+    return this.ix();
+  };
+  ProbExplanationTerm.prototype.iw = function () {
+    return new ProbExplanationTerm(this.h3c_1.applyTransformation(ProbExplanationTerm$freshCopy$lambda));
+  };
+  ProbExplanationTerm.prototype.freshCopy = function () {
+    return this.iw();
+  };
+  ProbExplanationTerm.prototype.jw = function (scope) {
+    return new ProbExplanationTerm(this.h3c_1.applyTransformation(ProbExplanationTerm$freshCopy$lambda_0(scope)));
+  };
+  ProbExplanationTerm.prototype.freshCopyFromScope = function (scope) {
+    return this.jw(scope);
+  };
+  ProbExplanationTerm.prototype.b2p = function (substitution, substitutions) {
+    return this.c2p(substitution, substitutions.slice());
+  };
+  ProbExplanationTerm.prototype.getSubstituted = function (substitution, substitutions) {
+    return this.b2p(substitution, substitutions);
+  };
+  ProbExplanationTerm.prototype.c2p = function (substitution, substitutions) {
+    return this.s16(Companion_getInstance_9().ofSubstitution(substitution, substitutions.slice()));
+  };
+  ProbExplanationTerm.prototype.apply = function (substitution, substitutions) {
+    return this.c2p(substitution, substitutions);
+  };
+  ProbExplanationTerm.prototype.s16 = function (substitution) {
+    var tmp;
+    if (substitution.d() ? true : this.jx()) {
+      tmp = this;
+    } else {
+      tmp = new ProbExplanationTerm(this.h3c_1.applyTransformation(ProbExplanationTerm$apply$lambda(substitution)));
+    }
+    return tmp;
+  };
+  ProbExplanationTerm.prototype.applySubstitution = function (substitution) {
+    return this.s16(substitution);
+  };
+  ProbExplanationTerm.prototype.jx = function () {
+    return !this.h3c_1.z3d();
+  };
+  function _get_cachedHashCode__d7x0zy($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = cachedHashCode$factory();
+    tmp$ret$0 = $this.w3d_1.b1();
+    return tmp$ret$0;
+  }
+  function ProbTerm$isGround$delegate$lambda(this$0) {
+    return function () {
+      var tmp;
+      if (this$0.s3d_1.jx()) {
+        var tmp$ret$0;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.any' call
+          var tmp0_any = this$0.t3d_1;
+          var tmp_0;
+          if (isInterface(tmp0_any, Collection)) {
+            tmp_0 = tmp0_any.d();
+          } else {
+            tmp_0 = false;
+          }
+          if (tmp_0) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+          var tmp0_iterator = tmp0_any.j();
+          while (tmp0_iterator.m()) {
+            var element = tmp0_iterator.p();
+            var tmp$ret$1;
+            // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.ProbTerm.isGround$delegate.<anonymous>.<anonymous>' call
+            tmp$ret$1 = element.bx();
+            if (tmp$ret$1) {
+              tmp$ret$0 = true;
+              break $l$block_0;
+            }
+          }
+          tmp$ret$0 = false;
+        }
+        tmp = !tmp$ret$0;
+      } else {
+        tmp = false;
+      }
+      return tmp;
+    };
+  }
+  function ProbTerm$cachedHashCode$delegate$lambda(this$0) {
+    return function () {
+      var result = this$0.q3d_1.hashCode();
+      result = imul(31, result) + getNumberHashCode(this$0.r3d_1) | 0;
+      result = imul(31, result) + this$0.s3d_1.hashCode() | 0;
+      result = imul(31, result) + hashCode(this$0.t3d_1) | 0;
+      return result;
+    };
+  }
+  function ProbTerm(id, probability, term, extraVariables) {
+    this.q3d_1 = id;
+    this.r3d_1 = probability;
+    this.s3d_1 = term;
+    this.t3d_1 = extraVariables;
+    this.u3d_1 = Companion_getInstance_3().of(get_ANNOTATION_FUNCTOR(), [Companion_getInstance_10().ofDouble(probability), term]);
+    var tmp = this;
+    tmp.v3d_1 = lazy(ProbTerm$isGround$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.w3d_1 = lazy(ProbTerm$cachedHashCode$delegate$lambda(this));
+  }
+  ProbTerm.prototype.aw = function () {
+    return this.u3d_1.aw();
+  };
+  ProbTerm.prototype.mw = function () {
+    return this.u3d_1.mw();
+  };
+  ProbTerm.prototype.sw = function () {
+    return this.u3d_1.sw();
+  };
+  ProbTerm.prototype.ex = function () {
+    return this.u3d_1.ex();
+  };
+  ProbTerm.prototype.bw = function () {
+    return this.u3d_1.bw();
+  };
+  ProbTerm.prototype.cw = function () {
+    return this.u3d_1.cw();
+  };
+  ProbTerm.prototype.uw = function () {
+    return this.u3d_1.uw();
+  };
+  ProbTerm.prototype.gx = function () {
+    return this.u3d_1.gx();
+  };
+  ProbTerm.prototype.rw = function () {
+    return this.u3d_1.rw();
+  };
+  ProbTerm.prototype.fx = function () {
+    return this.u3d_1.fx();
+  };
+  ProbTerm.prototype.hx = function () {
+    return this.u3d_1.hx();
+  };
+  ProbTerm.prototype.lw = function () {
+    return this.u3d_1.lw();
+  };
+  ProbTerm.prototype.dw = function () {
+    return this.u3d_1.dw();
+  };
+  ProbTerm.prototype.qw = function () {
+    return this.u3d_1.qw();
+  };
+  ProbTerm.prototype.bx = function () {
+    return this.u3d_1.bx();
+  };
+  ProbTerm.prototype.kt = function () {
+    return this.u3d_1.kt();
+  };
+  ProbTerm.prototype.hw = function () {
+    return this.u3d_1.hw();
+  };
+  ProbTerm.prototype.accept = function (visitor) {
+    return this.u3d_1.accept(visitor);
+  };
+  ProbTerm.prototype.asAtom = function () {
+    return this.u3d_1.asAtom();
+  };
+  ProbTerm.prototype.asBlock = function () {
+    return this.u3d_1.asBlock();
+  };
+  ProbTerm.prototype.asClause = function () {
+    return this.u3d_1.asClause();
+  };
+  ProbTerm.prototype.asCons = function () {
+    return this.u3d_1.asCons();
+  };
+  ProbTerm.prototype.asConstant = function () {
+    return this.u3d_1.asConstant();
+  };
+  ProbTerm.prototype.asDirective = function () {
+    return this.u3d_1.asDirective();
+  };
+  ProbTerm.prototype.asEmptyBlock = function () {
+    return this.u3d_1.asEmptyBlock();
+  };
+  ProbTerm.prototype.asEmptyList = function () {
+    return this.u3d_1.asEmptyList();
+  };
+  ProbTerm.prototype.asFact = function () {
+    return this.u3d_1.asFact();
+  };
+  ProbTerm.prototype.asIndicator = function () {
+    return this.u3d_1.asIndicator();
+  };
+  ProbTerm.prototype.asInteger = function () {
+    return this.u3d_1.asInteger();
+  };
+  ProbTerm.prototype.asList = function () {
+    return this.u3d_1.asList();
+  };
+  ProbTerm.prototype.asNumeric = function () {
+    return this.u3d_1.asNumeric();
+  };
+  ProbTerm.prototype.asReal = function () {
+    return this.u3d_1.asReal();
+  };
+  ProbTerm.prototype.asRecursive = function () {
+    return this.u3d_1.asRecursive();
+  };
+  ProbTerm.prototype.asRule = function () {
+    return this.u3d_1.asRule();
+  };
+  ProbTerm.prototype.asStruct = function () {
+    return this.u3d_1.vw();
+  };
+  ProbTerm.prototype.asTerm = function () {
+    return this.u3d_1.asTerm();
+  };
+  ProbTerm.prototype.asTruth = function () {
+    return this.u3d_1.asTruth();
+  };
+  ProbTerm.prototype.asTuple = function () {
+    return this.u3d_1.asTuple();
+  };
+  ProbTerm.prototype.asVar = function () {
+    return this.u3d_1.asVar();
+  };
+  ProbTerm.prototype.zw = function () {
+    return this.u3d_1.zw();
+  };
+  ProbTerm.prototype.qq = function () {
+    return this.zw();
+  };
+  ProbTerm.prototype.castToAtom = function () {
+    return this.u3d_1.castToAtom();
+  };
+  ProbTerm.prototype.castToBlock = function () {
+    return this.u3d_1.castToBlock();
+  };
+  ProbTerm.prototype.castToClause = function () {
+    return this.u3d_1.castToClause();
+  };
+  ProbTerm.prototype.castToCons = function () {
+    return this.u3d_1.castToCons();
+  };
+  ProbTerm.prototype.castToConstant = function () {
+    return this.u3d_1.castToConstant();
+  };
+  ProbTerm.prototype.castToDirective = function () {
+    return this.u3d_1.castToDirective();
+  };
+  ProbTerm.prototype.castToEmptyBlock = function () {
+    return this.u3d_1.castToEmptyBlock();
+  };
+  ProbTerm.prototype.castToEmptyList = function () {
+    return this.u3d_1.castToEmptyList();
+  };
+  ProbTerm.prototype.castToFact = function () {
+    return this.u3d_1.castToFact();
+  };
+  ProbTerm.prototype.castToIndicator = function () {
+    return this.u3d_1.castToIndicator();
+  };
+  ProbTerm.prototype.castToInteger = function () {
+    return this.u3d_1.castToInteger();
+  };
+  ProbTerm.prototype.castToList = function () {
+    return this.u3d_1.castToList();
+  };
+  ProbTerm.prototype.castToNumeric = function () {
+    return this.u3d_1.castToNumeric();
+  };
+  ProbTerm.prototype.castToReal = function () {
+    return this.u3d_1.castToReal();
+  };
+  ProbTerm.prototype.castToRecursive = function () {
+    return this.u3d_1.castToRecursive();
+  };
+  ProbTerm.prototype.castToRule = function () {
+    return this.u3d_1.castToRule();
+  };
+  ProbTerm.prototype.castToStruct = function () {
+    return this.u3d_1.castToStruct();
+  };
+  ProbTerm.prototype.castToTerm = function () {
+    return this.u3d_1.castToTerm();
+  };
+  ProbTerm.prototype.castToTruth = function () {
+    return this.u3d_1.castToTruth();
+  };
+  ProbTerm.prototype.castToTuple = function () {
+    return this.u3d_1.castToTuple();
+  };
+  ProbTerm.prototype.castToVar = function () {
+    return this.u3d_1.castToVar();
+  };
+  ProbTerm.prototype.containsTag = function (name) {
+    return this.u3d_1.containsTag(name);
+  };
+  ProbTerm.prototype.equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.u3d_1.equalsUsingVarCompleteNames(other, useVarCompleteName);
+  };
+  ProbTerm.prototype.getTag = function (name) {
+    return this.u3d_1.getTag(name);
+  };
+  ProbTerm.prototype.resetTags = function (tags) {
+    return this.u3d_1.resetTags(tags);
+  };
+  ProbTerm.prototype.structurallyEquals = function (other) {
+    return this.u3d_1.structurallyEquals(other);
+  };
+  ProbTerm.prototype.iw = function () {
+    var termCopy = this.s3d_1.freshCopy();
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = this.t3d_1;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+    var tmp0_iterator = tmp0_map.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.ProbTerm.freshCopy.<anonymous>' call
+      tmp$ret$0 = item.freshCopy();
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return new ProbTerm(this.q3d_1, this.r3d_1, termCopy, toSet(tmp$ret$2));
+  };
+  ProbTerm.prototype.freshCopy = function () {
+    return this.iw();
+  };
+  ProbTerm.prototype.jw = function (scope) {
+    var termCopy = this.s3d_1.freshCopyFromScope(scope);
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = this.t3d_1;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+    var tmp0_iterator = tmp0_map.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.ProbTerm.freshCopy.<anonymous>' call
+      tmp$ret$0 = item.freshCopyFromScope(scope);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return new ProbTerm(this.q3d_1, this.r3d_1, termCopy, toSet(tmp$ret$2));
+  };
+  ProbTerm.prototype.freshCopyFromScope = function (scope) {
+    return this.jw(scope);
+  };
+  ProbTerm.prototype.b2p = function (substitution, substitutions) {
+    return this.c2p(substitution, substitutions.slice());
+  };
+  ProbTerm.prototype.getSubstituted = function (substitution, substitutions) {
+    return this.b2p(substitution, substitutions);
+  };
+  ProbTerm.prototype.c2p = function (substitution, substitutions) {
+    return this.s16(Companion_getInstance_9().ofSubstitution(substitution, substitutions.slice()));
+  };
+  ProbTerm.prototype.apply = function (substitution, substitutions) {
+    return this.c2p(substitution, substitutions);
+  };
+  ProbTerm.prototype.s16 = function (substitution) {
+    var tmp;
+    if (substitution.d() ? true : this.jx()) {
+      tmp = this;
+    } else {
+      var tmp_0;
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.any' call
+        var tmp0_any = this.t3d_1;
+        var tmp_1;
+        if (isInterface(tmp0_any, Collection)) {
+          tmp_1 = tmp0_any.d();
+        } else {
+          tmp_1 = false;
+        }
+        if (tmp_1) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+        var tmp0_iterator = tmp0_any.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$1;
+          // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.ProbTerm.apply.<anonymous>' call
+          tmp$ret$1 = element.bx();
+          if (tmp$ret$1) {
+            tmp$ret$0 = true;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = false;
+      }
+      if (!tmp$ret$0) {
+        tmp_0 = this.t3d_1;
+      } else {
+        var tmp$ret$5;
+        // Inline function 'kotlin.collections.mapNotNull' call
+        var tmp1_mapNotNull = this.t3d_1;
+        var tmp$ret$4;
+        // Inline function 'kotlin.collections.mapNotNullTo' call
+        var tmp0_mapNotNullTo = ArrayList_init_$Create$_0();
+        // Inline function 'kotlin.collections.forEach' call
+        var tmp0_iterator_0 = tmp1_mapNotNull.j();
+        while (tmp0_iterator_0.m()) {
+          var element_0 = tmp0_iterator_0.p();
+          // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+          var tmp$ret$2;
+          // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.ProbTerm.apply.<anonymous>' call
+          tmp$ret$2 = substitution.applyTo(element_0);
+          var tmp0_safe_receiver = tmp$ret$2;
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            var tmp$ret$3;
+            // Inline function 'kotlin.let' call
+            // Inline function 'kotlin.contracts.contract' call
+            tmp0_mapNotNullTo.g(tmp0_safe_receiver);
+            tmp$ret$3 = Unit_getInstance();
+          }
+        }
+        tmp$ret$4 = tmp0_mapNotNullTo;
+        tmp$ret$5 = tmp$ret$4;
+        tmp_0 = toSet(tmp$ret$5);
+      }
+      var newExtraVars = tmp_0;
+      tmp = new ProbTerm(this.q3d_1, this.r3d_1, this.s3d_1.applySubstitution(substitution), newExtraVars);
+    }
+    return tmp;
+  };
+  ProbTerm.prototype.applySubstitution = function (substitution) {
+    return this.s16(substitution);
+  };
+  ProbTerm.prototype.jx = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = isGround$factory();
+    tmp$ret$0 = this.v3d_1.b1();
+    return tmp$ret$0;
+  };
+  ProbTerm.prototype.ax = function (other) {
+    if (!(other instanceof ProbTerm)) {
+      return compareTo.call(this, other);
+    }
+    var res = this.q3d_1.jd(other.q3d_1);
+    if (!(res === 0))
+      return res;
+    res = this.s3d_1.ax(other.s3d_1);
+    if (!(res === 0))
+      return res;
+    res = equals(this.t3d_1, other.t3d_1) ? 0 : -1;
+    if (!(res === 0))
+      return res;
+    res = compareTo_0(this.r3d_1, other.r3d_1);
+    return res;
+  };
+  ProbTerm.prototype.aa = function (other) {
+    return this.ax((!(other == null) ? isInterface(other, Term) : false) ? other : THROW_CCE());
+  };
+  ProbTerm.prototype.equals = function (other) {
+    var tmp;
+    if (other instanceof ProbTerm) {
+      tmp = this.ax(other) === 0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  ProbTerm.prototype.hashCode = function () {
+    return _get_cachedHashCode__d7x0zy(this);
+  };
+  ProbTerm.prototype.toString = function () {
+    return '' + round(this.r3d_1 * 100) / 100.0 + '::' + this.s3d_1;
+  };
+  function isGround$factory() {
+    return getPropertyCallableRef('isGround', 1, KProperty1, function (receiver) {
+      return receiver.jx();
+    }, null);
+  }
+  function cachedHashCode$factory() {
+    return getPropertyCallableRef('cachedHashCode', 1, KProperty1, function (receiver) {
+      return _get_cachedHashCode__d7x0zy(receiver);
+    }, null);
+  }
+  function Companion_1() {
+    Companion_instance_1 = this;
+  }
+  Companion_1.prototype.empty = function (unificator) {
+    return this.ofIterable(unificator, emptyList());
+  };
+  Companion_1.prototype.of = function (unificator, clause) {
+    return this.ofIterable(unificator, asIterable(clause));
+  };
+  Companion_1.prototype.ofSequence = function (unificator, clauses) {
+    return this.ofIterable(unificator, asIterable_0(clauses));
+  };
+  Companion_1.prototype.ofScopes = function (unificator, clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(clauses.length);
+    var indexedObject = clauses;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.Companion.of.<anonymous>' call
+      tmp$ret$0 = item(Companion_getInstance_7().empty());
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return this.ofIterable(unificator, tmp$ret$2);
+  };
+  Companion_1.prototype.ofIterable = function (unificator, clauses) {
+    var tmp;
+    if (isInterface(clauses, MutableTheory)) {
+      tmp = Companion_getInstance_20().ofIterable(unificator, clauses);
+    } else {
+      tmp = MappedProblogTheory_init_$Create$(clauses, unificator, null, 4, null);
+    }
+    return tmp;
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_22() {
+    if (Companion_instance_1 == null)
+      new Companion_1();
+    return Companion_instance_1;
+  }
+  function ProblogTheory() {
+  }
+  function collectAllHeads($this, head, accumulator) {
+    var tmp;
+    if (isInterface(head, Struct)) {
+      tmp = head.zv() === 2;
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      var tmp_0;
+      var tmp_1 = head.fw();
+      Companion_getInstance_11();
+      if (!(tmp_1 === ';')) {
+        tmp_0 = !(head.fw() === get_ANNOTATION_FUNCTOR());
+      } else {
+        tmp_0 = false;
+      }
+      if (tmp_0) {
+        throw TuPrologException_init_$Create$('Badly formatted disjoint annotation: ' + head);
+      }
+      var tmp_2 = head.fw();
+      Companion_getInstance_11();
+      if (tmp_2 === ';') {
+        collectAllHeads($this, head.get(1), accumulator);
+      }
+    }
+    var curHeadProb = 1.0;
+    var curHead = head;
+    if (isInterface(head, Struct)) {
+      var tmp_3;
+      var tmp_4 = head.fw();
+      Companion_getInstance_11();
+      if (tmp_4 === ';') {
+        tmp_3 = head.get(0);
+      } else {
+        tmp_3 = head;
+      }
+      curHead = tmp_3;
+      var tmp_5;
+      if (isInterface(curHead, Struct)) {
+        tmp_5 = curHead.fw() === get_ANNOTATION_FUNCTOR();
+      } else {
+        tmp_5 = false;
+      }
+      if (tmp_5) {
+        var curHeadProbTerm = curHead.get(0);
+        var tmp0_subject = curHeadProbTerm;
+        var tmp_6;
+        if (isInterface(tmp0_subject, Numeric)) {
+          tmp_6 = curHeadProbTerm.x10().toDouble();
+        } else {
+          tmp_6 = solveArithmeticExpression(curHeadProbTerm);
+        }
+        curHeadProb = tmp_6;
+        curHead = curHead.get(1);
+      }
+    }
+    accumulator.g(Companion_getInstance_3().of(get_ANNOTATION_FUNCTOR(), [Companion_getInstance_10().ofDouble(curHeadProb), curHead]));
+  }
+  function AnnotatedDisjunctionClauseMapper() {
+    AnnotatedDisjunctionClauseMapper_instance = this;
+  }
+  AnnotatedDisjunctionClauseMapper.prototype.a3e = function (clause) {
+    var tmp;
+    if (isInterface(clause, Rule)) {
+      var tmp_0 = clause.ly().fw();
+      Companion_getInstance_11();
+      tmp = tmp_0 === ';';
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  AnnotatedDisjunctionClauseMapper.prototype.b3e = function (clause) {
+    if (!isInterface(clause, Rule)) {
+      var tmp = 'Clause is not an instance of Rule: ' + clause;
+      throw ClauseMappingException_init_$Create$(tmp, null, 2, null);
+    }
+    var body = clause.my();
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    tmp$ret$0 = ArrayList_init_$Create$_0();
+    var disjointHeads = tmp$ret$0;
+    collectAllHeads(this, clause.ly(), disjointHeads);
+    var probSum = 0.0;
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(disjointHeads, 10));
+    var tmp0_iterator = disjointHeads.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$1;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.AnnotatedDisjunctionClauseMapper.apply.<anonymous>' call
+      var tmp_0 = item.get(0);
+      var curProb = (isInterface(tmp_0, Numeric) ? tmp_0 : THROW_CCE()).x10().toDouble();
+      var tmp_1;
+      var tmp_2 = item.get(1);
+      if (isInterface(tmp_2, Struct)) {
+        var tmp_3 = item.get(1);
+        tmp_1 = isInterface(tmp_3, Struct) ? tmp_3 : THROW_CCE();
+      } else {
+        tmp_1 = Companion_getInstance_3().of(item.get(1).toString(), []);
+      }
+      var curRuleHead = tmp_1;
+      probSum = probSum + curProb;
+      tmp$ret$1 = ProbabilisticClauseMapper_getInstance().c3e(Companion_getInstance_12().of(Companion_getInstance_3().of(get_ANNOTATION_FUNCTOR(), [Companion_getInstance_10().ofDouble(curProb / (1.0 - (probSum - curProb))), curRuleHead]), [body]));
+      tmp0_mapTo.g(tmp$ret$1);
+    }
+    tmp$ret$2 = tmp0_mapTo;
+    tmp$ret$3 = tmp$ret$2;
+    var mappedRules = toList_0(tmp$ret$3);
+    var explanation = Companion_getInstance_21().l3d_1;
+    var tmp$ret$6;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$5;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(mappedRules, 10));
+    var tmp0_iterator_0 = mappedRules.j();
+    while (tmp0_iterator_0.m()) {
+      var item_0 = tmp0_iterator_0.p();
+      var tmp$ret$4;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.AnnotatedDisjunctionClauseMapper.apply.<anonymous>' call
+      var thisExplanation = Companion_getInstance_21().p3d(item_0.h4_1);
+      var resultExplanation = thisExplanation.and(explanation);
+      explanation = explanation.and(thisExplanation.not());
+      tmp$ret$4 = ProbabilisticClauseMapper_getInstance().d3e(item_0.g4_1, resultExplanation);
+      tmp0_mapTo_0.g(tmp$ret$4);
+    }
+    tmp$ret$5 = tmp0_mapTo_0;
+    tmp$ret$6 = tmp$ret$5;
+    return tmp$ret$6;
+  };
+  var AnnotatedDisjunctionClauseMapper_instance;
+  function AnnotatedDisjunctionClauseMapper_getInstance() {
+    if (AnnotatedDisjunctionClauseMapper_instance == null)
+      new AnnotatedDisjunctionClauseMapper();
+    return AnnotatedDisjunctionClauseMapper_instance;
+  }
+  function BinaryDecisionDiagramExplanation_init_$Init$(diagram, computedValue, $mask0, $marker, $this) {
+    if (!(($mask0 & 2) === 0))
+      computedValue = Companion_getInstance_23().m3d_1;
+    BinaryDecisionDiagramExplanation.call($this, diagram, computedValue);
+    return $this;
+  }
+  function BinaryDecisionDiagramExplanation_init_$Create$(diagram, computedValue, $mask0, $marker) {
+    return BinaryDecisionDiagramExplanation_init_$Init$(diagram, computedValue, $mask0, $marker, Object.create(BinaryDecisionDiagramExplanation.prototype));
+  }
+  function ComputedValue(probability) {
+    this.e3e_1 = probability;
+  }
+  ComputedValue.prototype.toString = function () {
+    return 'ComputedValue(probability=' + this.e3e_1 + ')';
+  };
+  ComputedValue.prototype.hashCode = function () {
+    return this.e3e_1 == null ? 0 : getNumberHashCode(this.e3e_1);
+  };
+  ComputedValue.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof ComputedValue))
+      return false;
+    var tmp0_other_with_cast = other instanceof ComputedValue ? other : THROW_CCE();
+    if (!equals(this.e3e_1, tmp0_other_with_cast.e3e_1))
+      return false;
+    return true;
+  };
+  function Companion_2() {
+    Companion_instance_2 = this;
+    this.m3d_1 = new ComputedValue(null);
+    this.n3d_1 = new ComputedValue(0.0);
+    this.o3d_1 = new ComputedValue(1.0);
+  }
+  var Companion_instance_2;
+  function Companion_getInstance_23() {
+    if (Companion_instance_2 == null)
+      new Companion_2();
+    return Companion_instance_2;
+  }
+  function getAsInternal($this, that) {
+    if (!(that instanceof BinaryDecisionDiagramExplanation)) {
+      throw UnsupportedOperationException_init_$Create$('that does not support Binary Decision Diagrams');
+    }
+    return that;
+  }
+  function computeExpansion($this, value, low, high) {
+    var tmp;
+    if (!(low.e3e_1 == null) ? !(high.e3e_1 == null) : false) {
+      tmp = value.r3d_1 * high.e3e_1 + (1.0 - value.r3d_1) * low.e3e_1;
+    } else {
+      tmp = null;
+    }
+    return new ComputedValue(tmp);
+  }
+  function _get_cachedNot__l38068($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = cachedNot$factory();
+    tmp$ret$0 = $this.l3c_1.b1();
+    return tmp$ret$0;
+  }
+  function BinaryDecisionDiagramExplanation$cachedNot$delegate$lambda$lambda(this$0) {
+    return function (node, low, high) {
+      return computeExpansion(this$0, node, low, high);
+    };
+  }
+  function BinaryDecisionDiagramExplanation$cachedNot$delegate$lambda(this$0) {
+    return function () {
+      var tmp = Companion_getInstance_23().n3d_1;
+      var tmp_0 = Companion_getInstance_23().o3d_1;
+      var result = notThenExpansion(this$0.j3c_1, tmp, tmp_0, BinaryDecisionDiagramExplanation$cachedNot$delegate$lambda$lambda(this$0));
+      return new BinaryDecisionDiagramExplanation(result.g4_1, result.h4_1);
+    };
+  }
+  function BinaryDecisionDiagramExplanation$and$lambda(this$0) {
+    return function (node, low, high) {
+      return computeExpansion(this$0, node, low, high);
+    };
+  }
+  function BinaryDecisionDiagramExplanation$or$lambda(this$0) {
+    return function (node, low, high) {
+      return computeExpansion(this$0, node, low, high);
+    };
+  }
+  function BinaryDecisionDiagramExplanation$probability$delegate$lambda$lambda(node, low, high) {
+    return node.r3d_1 * high + (1.0 - node.r3d_1) * low;
+  }
+  function BinaryDecisionDiagramExplanation$probability$delegate$lambda(this$0) {
+    return function () {
+      var tmp0_elvis_lhs = this$0.k3c_1.e3e_1;
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        tmp = expansion(this$0.j3c_1, 0.0, 1.0, BinaryDecisionDiagramExplanation$probability$delegate$lambda$lambda);
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      return tmp;
+    };
+  }
+  function BinaryDecisionDiagramExplanation$containsAnyNotGroundTerm$delegate$lambda$lambda(it) {
+    return !it.jx();
+  }
+  function BinaryDecisionDiagramExplanation$containsAnyNotGroundTerm$delegate$lambda(this$0) {
+    return function () {
+      return anyWhere(this$0.j3c_1, BinaryDecisionDiagramExplanation$containsAnyNotGroundTerm$delegate$lambda$lambda);
+    };
+  }
+  function BinaryDecisionDiagramExplanation$apply$lambda($transformation) {
+    return function (it) {
+      return $transformation(it);
+    };
+  }
+  function BinaryDecisionDiagramExplanation(diagram, computedValue) {
+    Companion_getInstance_23();
+    this.j3c_1 = diagram;
+    this.k3c_1 = computedValue;
+    var tmp = this;
+    tmp.l3c_1 = lazy(BinaryDecisionDiagramExplanation$cachedNot$delegate$lambda(this));
+    var tmp_0 = this;
+    tmp_0.m3c_1 = lazy(BinaryDecisionDiagramExplanation$probability$delegate$lambda(this));
+    var tmp_1 = this;
+    tmp_1.n3c_1 = lazy(BinaryDecisionDiagramExplanation$containsAnyNotGroundTerm$delegate$lambda(this));
+  }
+  BinaryDecisionDiagramExplanation.prototype.f3e = function () {
+    return _get_cachedNot__l38068(this);
+  };
+  BinaryDecisionDiagramExplanation.prototype.not = function () {
+    return this.f3e();
+  };
+  BinaryDecisionDiagramExplanation.prototype.g3e = function (that) {
+    var tmp = getAsInternal(this, that).j3c_1;
+    var tmp_0 = Companion_getInstance_23().n3d_1;
+    var tmp_1 = Companion_getInstance_23().o3d_1;
+    var result = andThenExpansion(this.j3c_1, tmp, tmp_0, tmp_1, BinaryDecisionDiagramExplanation$and$lambda(this));
+    return new BinaryDecisionDiagramExplanation(result.g4_1, result.h4_1);
+  };
+  BinaryDecisionDiagramExplanation.prototype.and = function (that) {
+    return this.g3e(that);
+  };
+  BinaryDecisionDiagramExplanation.prototype.h3e = function (that) {
+    var tmp = getAsInternal(this, that).j3c_1;
+    var tmp_0 = Companion_getInstance_23().n3d_1;
+    var tmp_1 = Companion_getInstance_23().o3d_1;
+    var result = orThenExpansion(this.j3c_1, tmp, tmp_0, tmp_1, BinaryDecisionDiagramExplanation$or$lambda(this));
+    return new BinaryDecisionDiagramExplanation(result.g4_1, result.h4_1);
+  };
+  BinaryDecisionDiagramExplanation.prototype.or = function (that) {
+    return this.h3e(that);
+  };
+  BinaryDecisionDiagramExplanation.prototype.x3d = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = probability$factory();
+    tmp$ret$0 = this.m3c_1.b1();
+    return tmp$ret$0;
+  };
+  BinaryDecisionDiagramExplanation.prototype.z3d = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = containsAnyNotGroundTerm$factory();
+    tmp$ret$0 = this.n3c_1.b1();
+    return tmp$ret$0;
+  };
+  BinaryDecisionDiagramExplanation.prototype.toString = function () {
+    return 'bdd:' + hashCode(this.j3c_1);
+  };
+  BinaryDecisionDiagramExplanation.prototype.i3e = function (transformation) {
+    var tmp = map_0(this.j3c_1, BinaryDecisionDiagramExplanation$apply$lambda(transformation));
+    return BinaryDecisionDiagramExplanation_init_$Create$(tmp, null, 2, null);
+  };
+  BinaryDecisionDiagramExplanation.prototype.applyTransformation = function (transformation) {
+    return this.i3e(transformation);
+  };
+  function cachedNot$factory() {
+    return getPropertyCallableRef('cachedNot', 1, KProperty1, function (receiver) {
+      return _get_cachedNot__l38068(receiver);
+    }, null);
+  }
+  function probability$factory() {
+    return getPropertyCallableRef('probability', 1, KProperty1, function (receiver) {
+      return receiver.x3d();
+    }, null);
+  }
+  function containsAnyNotGroundTerm$factory() {
+    return getPropertyCallableRef('containsAnyNotGroundTerm', 1, KProperty1, function (receiver) {
+      return receiver.z3d();
+    }, null);
+  }
+  function get_nonWrappableFunctors() {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    return nonWrappableFunctors;
+  }
+  var nonWrappableFunctors;
+  function ClauseMappingUtils() {
+    ClauseMappingUtils_instance = this;
+    this.j3e_1 = new Long(1, 0);
+    this.k3e_1 = listOf_0([DirectiveClauseMapper_getInstance(), AnnotatedDisjunctionClauseMapper_getInstance(), ProbabilisticClauseMapper_getInstance(), EvidenceClauseMapper_getInstance(), PrologClauseMapper_getInstance(), NothingClauseMapper_getInstance()]);
+  }
+  ClauseMappingUtils.prototype.l3e = function () {
+    var tmp0_this = this;
+    var tmp1 = tmp0_this.j3e_1;
+    tmp0_this.j3e_1 = tmp1.gh();
+    return tmp1;
+  };
+  ClauseMappingUtils.prototype.m3e = function (clause) {
+    var tmp;
+    if (get_isMappedAsProblog(clause)) {
+      tmp = listOf(clause);
+    } else {
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.map' call
+      var tmp$ret$1;
+      $l$block: {
+        // Inline function 'kotlin.collections.first' call
+        var tmp0_first = this.k3e_1;
+        var tmp0_iterator = tmp0_first.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$0;
+          // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.ClauseMappingUtils.map.<anonymous>' call
+          tmp$ret$0 = element.a3e(clause);
+          if (tmp$ret$0) {
+            tmp$ret$1 = element;
+            break $l$block;
+          }
+        }
+        throw NoSuchElementException_init_$Create$('Collection contains no element matching the predicate.');
+      }
+      var tmp1_map = tmp$ret$1.b3e(clause);
+      var tmp$ret$3;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+      var tmp0_iterator_0 = tmp1_map.j();
+      while (tmp0_iterator_0.m()) {
+        var item = tmp0_iterator_0.p();
+        var tmp$ret$2;
+        // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.ClauseMappingUtils.map.<anonymous>' call
+        tmp$ret$2 = setMappedAsProblog(item, true);
+        tmp0_mapTo.g(tmp$ret$2);
+      }
+      tmp$ret$3 = tmp0_mapTo;
+      tmp$ret$4 = tmp$ret$3;
+      tmp = tmp$ret$4;
+    }
+    return tmp;
+  };
+  ClauseMappingUtils.prototype.n3e = function (indicator) {
+    var arityTerm = indicator.o10();
+    var tmp = Companion_getInstance_13();
+    var tmp_0 = indicator.n10();
+    var tmp0_subject = arityTerm;
+    var tmp_1;
+    if (isInterface(tmp0_subject, Numeric)) {
+      tmp_1 = Companion_getInstance_10().ofInteger(arityTerm.p10().toInt() + 1 | 0);
+    } else {
+      tmp_1 = arityTerm;
+    }
+    return tmp.of(tmp_0, tmp_1);
+  };
+  var ClauseMappingUtils_instance;
+  function ClauseMappingUtils_getInstance() {
+    if (ClauseMappingUtils_instance == null)
+      new ClauseMappingUtils();
+    return ClauseMappingUtils_instance;
+  }
+  function toTerm(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    return new ProbExplanationTerm(_this__u8e3s4);
+  }
+  function safeToStruct(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp;
+    if (isInterface(_this__u8e3s4, Struct)) {
+      tmp = _this__u8e3s4;
+    } else {
+      tmp = Companion_getInstance_3().of(_this__u8e3s4.toString(), []);
+    }
+    return tmp;
+  }
+  function withBodyExplanation(_this__u8e3s4, explanation) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp0__get_functor__thl4dk = Prob_getInstance();
+    tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+    var tmp = tmp$ret$0;
+    return wrapInPredicateRecursive$default(_this__u8e3s4, tmp, explanation, 0, 4, null);
+  }
+  function withExplanation(_this__u8e3s4, explanation) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp;
+    if (!get_isWrappableWithExplanation(_this__u8e3s4)) {
+      tmp = withExplanationNonWrappable(_this__u8e3s4, explanation);
+    } else {
+      var tmp0_subject = _this__u8e3s4;
+      var tmp_0;
+      if (isInterface(tmp0_subject, Struct)) {
+        tmp_0 = Companion_getInstance_3().ofList(_this__u8e3s4.fw(), plus(_this__u8e3s4.gw(), explanation));
+      } else {
+        tmp_0 = Companion_getInstance_3().of(_this__u8e3s4.toString(), [explanation]);
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  function get_isMappedAsProblog(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp0_elvis_lhs = _this__u8e3s4.getTag('it.unibo.tuprolog.problog.mapped');
+    return tmp0_elvis_lhs == null ? false : tmp0_elvis_lhs;
+  }
+  function setMappedAsProblog(_this__u8e3s4, value) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    return setTag(_this__u8e3s4, 'it.unibo.tuprolog.problog.mapped', value);
+  }
+  function wrapInPredicateRecursive(_this__u8e3s4, functor, explanation, depth) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp0_subject = _this__u8e3s4;
+    var tmp;
+    if (isInterface(tmp0_subject, Struct)) {
+      var tmp1_subject = _this__u8e3s4.fw();
+      var tmp_0;
+      switch (tmp1_subject) {
+        case ',':
+          var tmp_1 = Companion_getInstance_1();
+          ProblogLib_getInstance();
+          var leftVar = tmp_1.of('EXPL' + '_A_' + depth);
+          var tmp_2 = Companion_getInstance_1();
+          ProblogLib_getInstance();
+          var rightVar = tmp_2.of('EXPL' + '_B_' + depth);
+          var tmp_3 = Companion_getInstance_2();
+          var tmp_4 = wrapInPredicateRecursive(_this__u8e3s4.get(0), functor, leftVar, depth + 1 | 0);
+          var tmp_5 = wrapInPredicateRecursive(_this__u8e3s4.get(1), functor, rightVar, depth + 1 | 0);
+          var tmp_6 = Companion_getInstance_3();
+          var tmp$ret$0;
+          // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+          var tmp0__get_functor__thl4dk = ProbExplAnd_getInstance();
+          tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+
+          tmp_0 = tmp_3.ofMany(tmp_4, tmp_5, [tmp_6.of(tmp$ret$0, [explanation, leftVar, rightVar])]);
+          break;
+        case ';':
+          tmp_0 = Companion_getInstance_3().of(';', [wrapInPredicateRecursive(_this__u8e3s4.get(0), functor, explanation, depth + 1 | 0), wrapInPredicateRecursive(_this__u8e3s4.get(1), functor, explanation, depth + 1 | 0)]);
+          break;
+        case '->':
+          tmp_0 = Companion_getInstance_3().of('->', [wrapInPredicateRecursive(_this__u8e3s4.get(0), functor, Companion_getInstance_1().anonymous(), depth + 1 | 0), wrapInPredicateRecursive(_this__u8e3s4.get(1), functor, explanation, depth + 1 | 0)]);
+          break;
+        default:
+          tmp_0 = wrapInPredicate(_this__u8e3s4, functor, explanation);
+          break;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = wrapInPredicate(_this__u8e3s4, functor, explanation);
+    }
+    return tmp;
+  }
+  function wrapInPredicateRecursive$default(_this__u8e3s4, functor, explanation, depth, $mask0, $handler) {
+    if (!(($mask0 & 4) === 0))
+      depth = 1;
+    return wrapInPredicateRecursive(_this__u8e3s4, functor, explanation, depth);
+  }
+  function get_isWrappableWithExplanation(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    return !get_nonWrappableFunctors().v(safeToStruct(_this__u8e3s4).fw());
+  }
+  function withExplanationNonWrappable(_this__u8e3s4, explanation) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    return Companion_getInstance_2().of(_this__u8e3s4, Companion_getInstance_3().of('=', [explanation, toTerm(Companion_getInstance_21().l3d_1)]));
+  }
+  function wrapInPredicate(_this__u8e3s4, functor, explanation) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp;
+    if (!get_isWrappableWithExplanation(_this__u8e3s4)) {
+      tmp = withExplanationNonWrappable(_this__u8e3s4, explanation);
+    } else {
+      tmp = Companion_getInstance_3().of(functor, [explanation, _this__u8e3s4]);
+    }
+    return tmp;
+  }
+  function solveArithmeticExpression(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp$ret$1;
+    // Inline function 'kotlin.text.replace' call
+    var tmp0_replace = _this__u8e3s4.toString();
+    var tmp$ret$0;
+    // Inline function 'kotlin.text.toRegex' call
+    tmp$ret$0 = Regex_init_$Create$('\\s');
+    var tmp1_replace = tmp$ret$0;
+    tmp$ret$1 = tmp1_replace.kf(tmp0_replace, '');
+    var termStr = tmp$ret$1;
+    var tmp = Regex_init_$Create$('([0-9.]+)(/)([0-9.]+).*');
+    var tmp0_elvis_lhs = tmp.gf(termStr, 0, 2, null);
+    var tmp_0;
+    if (tmp0_elvis_lhs == null) {
+      throw TuPrologException_init_$Create$('Unsupported probability notation in annotated disjunction: ' + termStr);
+    } else {
+      tmp_0 = tmp0_elvis_lhs;
+    }
+    var regexMatch = tmp_0;
+    var tmp1_container = regexMatch.n9();
+    var tmp$ret$2;
+    // Inline function 'kotlin.text.Destructured.component1' call
+    tmp$ret$2 = tmp1_container.j9_1.m9().n(1);
+    var dividendStr = tmp$ret$2;
+    var tmp$ret$3;
+    // Inline function 'kotlin.text.Destructured.component3' call
+    tmp$ret$3 = tmp1_container.j9_1.m9().n(3);
+    var divisorStr = tmp$ret$3;
+    var dividend = toDoubleOrNull(dividendStr);
+    var divisor = toDoubleOrNull(divisorStr);
+    if (dividend == null ? true : divisor == null) {
+      throw TuPrologException_init_$Create$('Unable to parse arithmetic division expression: ' + termStr);
+    }
+    return dividend / divisor;
+  }
+  function withoutAnonymousVars(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp = Companion_getInstance_9();
+    var tmp$ret$5;
+    // Inline function 'kotlin.collections.mapIndexed' call
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_filter = plus_0(toSet_0(_this__u8e3s4.ly().hw()), toSet_0(_this__u8e3s4.my().hw()));
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = tmp0_filter.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.withoutAnonymousVars.<anonymous>' call
+      tmp$ret$0 = element.x14();
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    var tmp1_mapIndexed = tmp$ret$2;
+    var tmp$ret$4;
+    // Inline function 'kotlin.collections.mapIndexedTo' call
+    var tmp0_mapIndexedTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_mapIndexed, 10));
+    var index = 0;
+    var tmp0_iterator_0 = tmp1_mapIndexed.j();
+    while (tmp0_iterator_0.m()) {
+      var item = tmp0_iterator_0.p();
+      var tmp$ret$3;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.withoutAnonymousVars.<anonymous>' call
+      var tmp1 = index;
+      index = tmp1 + 1 | 0;
+      var tmp2__anonymous__z9zvc9 = checkIndexOverflow(tmp1);
+      tmp$ret$3 = new Pair(item, Companion_getInstance_1().of('ANON_' + tmp2__anonymous__z9zvc9));
+      tmp0_mapIndexedTo.g(tmp$ret$3);
+    }
+    tmp$ret$4 = tmp0_mapIndexedTo;
+    tmp$ret$5 = tmp$ret$4;
+    var anonVarSubstitution = tmp.ofIterable(tmp$ret$5);
+    var tmp0_subject = _this__u8e3s4;
+    var tmp_0;
+    if (isInterface(tmp0_subject, Fact)) {
+      tmp_0 = Companion_getInstance().of(safeToStruct(_this__u8e3s4.ly().applySubstitution(anonVarSubstitution)));
+    } else {
+      tmp_0 = Companion_getInstance_12().of(safeToStruct(_this__u8e3s4.ly().applySubstitution(anonVarSubstitution)), [safeToStruct(_this__u8e3s4.my().applySubstitution(anonVarSubstitution))]);
+    }
+    return tmp_0;
+  }
+  function get_extraVariables(_this__u8e3s4) {
+    init_properties_ClauseMappingUtils_kt_i29ma0();
+    var tmp;
+    if (!_this__u8e3s4.jx()) {
+      var headVars = toSet_0(_this__u8e3s4.ly().hw());
+      var bodyVars = toSet_0(_this__u8e3s4.my().hw());
+      tmp = subtract(bodyVars, headVars);
+    } else {
+      tmp = emptySet();
+    }
+    return tmp;
+  }
+  var properties_initialized_ClauseMappingUtils_kt_tzf6ek;
+  function init_properties_ClauseMappingUtils_kt_i29ma0() {
+    if (properties_initialized_ClauseMappingUtils_kt_tzf6ek) {
+    } else {
+      properties_initialized_ClauseMappingUtils_kt_tzf6ek = true;
+      nonWrappableFunctors = setOf(['!', 'true', 'false']);
+    }
+  }
+  function DirectiveClauseMapper() {
+    DirectiveClauseMapper_instance = this;
+  }
+  DirectiveClauseMapper.prototype.a3e = function (clause) {
+    return clause.ow();
+  };
+  DirectiveClauseMapper.prototype.b3e = function (clause) {
+    var body = clause.my();
+    if (!isInterface(clause, Directive)) {
+      var tmp = 'Clause is not an instance of Directive: ' + clause;
+      throw ClauseMappingException_init_$Create$(tmp, null, 2, null);
+    }
+    var tmp_0;
+    if (isInterface(body, Struct)) {
+      tmp_0 = body.fw() === 'static' ? true : body.fw() === 'dynamic';
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      var indicatorTerm = body.get(0);
+      if (!isInterface(indicatorTerm, Indicator)) {
+        var tmp_1 = 'Malformed directive: ' + clause;
+        throw ClauseMappingException_init_$Create$(tmp_1, null, 2, null);
+      }
+      var name = indicatorTerm.n10();
+      var arity = indicatorTerm.o10();
+      if (!isInterface(arity, Numeric)) {
+        var tmp_2 = 'Malformed directive: ' + clause;
+        throw ClauseMappingException_init_$Create$(tmp_2, null, 2, null);
+      }
+      return listOf(Companion_getInstance_14().of(Companion_getInstance_3().of(body.fw(), [Companion_getInstance_13().of(name, Companion_getInstance_10().ofInteger(arity.x10().toInt() + 1 | 0))]), []));
+    }
+    var tmp_3;
+    if (isInterface(body, Struct)) {
+      tmp_3 = body.fw() === 'initialization' ? true : body.fw() === 'solve';
+    } else {
+      tmp_3 = false;
+    }
+    if (tmp_3) {
+      return listOf(Companion_getInstance_14().of(Companion_getInstance_3().of(body.fw(), [withBodyExplanation(body.get(0), Companion_getInstance_1().anonymous())]), []));
+    }
+    return listOf(clause);
+  };
+  var DirectiveClauseMapper_instance;
+  function DirectiveClauseMapper_getInstance() {
+    if (DirectiveClauseMapper_instance == null)
+      new DirectiveClauseMapper();
+    return DirectiveClauseMapper_instance;
+  }
+  function EvidenceClauseMapper() {
+    EvidenceClauseMapper_instance = this;
+  }
+  EvidenceClauseMapper.prototype.a3e = function (clause) {
+    var tmp;
+    if (isInterface(clause, Rule)) {
+      var tmp_0 = clause.ly().fw();
+      ProblogLib_getInstance();
+      tmp = tmp_0 === 'evidence';
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  EvidenceClauseMapper.prototype.b3e = function (clause) {
+    if (!isInterface(clause, Rule)) {
+      var tmp = 'Clause is not an instance of Rule: ' + clause;
+      throw ClauseMappingException_init_$Create$(tmp, null, 2, null);
+    }
+    if (clause.ly().zv() > 2) {
+      throw TuPrologException_init_$Create$('Invalid evidence predicate: ' + clause.ly());
+    } else {
+      var tmp_0;
+      if (clause.ly().zv() === 2) {
+        var tmp_1 = clause.ly().get(1);
+        tmp_0 = !isInterface(tmp_1, Truth);
+      } else {
+        tmp_0 = false;
+      }
+      if (tmp_0) {
+        throw TuPrologException_init_$Create$('Invalid evidence predicate: ' + clause.ly());
+      }
+    }
+    var headTerm = clause.ly();
+    if (headTerm.zv() === 1) {
+      headTerm = Companion_getInstance_3().of(headTerm.fw(), [headTerm.get(0), Companion_getInstance_15().wv_1]);
+    }
+    var tmp_2;
+    if (isInterface(clause, Fact)) {
+      tmp_2 = Companion_getInstance().of(headTerm);
+    } else {
+      tmp_2 = Companion_getInstance_12().of(headTerm, [withBodyExplanation(clause.my(), Companion_getInstance_1().anonymous())]);
+    }
+    return listOf(tmp_2);
+  };
+  var EvidenceClauseMapper_instance;
+  function EvidenceClauseMapper_getInstance() {
+    if (EvidenceClauseMapper_instance == null)
+      new EvidenceClauseMapper();
+    return EvidenceClauseMapper_instance;
+  }
+  function MappedMutableProblogTheory_init_$Init$(clauses, unificator, theory, $mask0, $marker, $this) {
+    if (!(($mask0 & 2) === 0))
+      unificator = Companion_getInstance_16().h1l();
+    if (!(($mask0 & 4) === 0)) {
+      var tmp = Companion_getInstance_17();
+      var tmp0_safe_receiver = clauses;
+      var tmp_0;
+      if (tmp0_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        var tmp$ret$2;
+        var tmp$ret$2_0;
+        // Inline function 'kotlin.collections.flatMap' call
+        var tmp$ret$1;
+        var tmp$ret$1_0;
+        // Inline function 'kotlin.collections.flatMapTo' call
+        var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+        var tmp0_iterator = tmp0_safe_receiver.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$0;
+          var tmp$ret$0_0;
+          // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedMutableProblogTheory.<init>.<anonymous>' call
+          tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+          tmp$ret$0_0 = Unit_getInstance();
+          var list = tmp$ret$0;
+          addAll(tmp0_flatMapTo, list);
+        }
+        tmp$ret$1 = tmp0_flatMapTo;
+        tmp$ret$1_0 = Unit_getInstance();
+        tmp$ret$2 = tmp$ret$1;
+        tmp$ret$2_0 = Unit_getInstance();
+        tmp_0 = tmp$ret$2;
+      }
+      var tmp1_elvis_lhs = tmp_0;
+      theory = tmp.indexedOfIterable(unificator, tmp1_elvis_lhs == null ? emptyList() : tmp1_elvis_lhs);
+    }
+    MappedMutableProblogTheory.call($this, clauses, unificator, theory);
+    return $this;
+  }
+  function MappedMutableProblogTheory_init_$Create$(clauses, unificator, theory, $mask0, $marker) {
+    return MappedMutableProblogTheory_init_$Init$(clauses, unificator, theory, $mask0, $marker, Object.create(MappedMutableProblogTheory.prototype));
+  }
+  function MappedMutableProblogTheory(clauses, unificator, theory) {
+    this.o3e_1 = theory;
+  }
+  MappedMutableProblogTheory.prototype.t1l = function () {
+    return this.o3e_1.t1l();
+  };
+  MappedMutableProblogTheory.prototype.m1l = function () {
+    return this.o3e_1.m1l();
+  };
+  MappedMutableProblogTheory.prototype.o1l = function () {
+    return this.o3e_1.o1l();
+  };
+  MappedMutableProblogTheory.prototype.k1s = function () {
+    return this.o3e_1.k1s();
+  };
+  MappedMutableProblogTheory.prototype.o = function () {
+    return this.o3e_1.o();
+  };
+  MappedMutableProblogTheory.prototype.kt = function () {
+    return this.o3e_1.kt();
+  };
+  MappedMutableProblogTheory.prototype.k1l = function () {
+    return this.o3e_1.k1l();
+  };
+  MappedMutableProblogTheory.prototype.z1s = function () {
+    return this.o3e_1.z1s();
+  };
+  MappedMutableProblogTheory.prototype.clone = function () {
+    return this.z1s();
+  };
+  MappedMutableProblogTheory.prototype.contains = function (clause) {
+    return this.o3e_1.contains(clause);
+  };
+  MappedMutableProblogTheory.prototype.containsIndicator = function (indicator) {
+    return this.o3e_1.containsIndicator(indicator);
+  };
+  MappedMutableProblogTheory.prototype.containsHead = function (head) {
+    return this.o3e_1.containsHead(head);
+  };
+  MappedMutableProblogTheory.prototype.containsTag = function (name) {
+    return this.o3e_1.containsTag(name);
+  };
+  MappedMutableProblogTheory.prototype.equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.o3e_1.equalsUsingVarCompleteNames(other, useVarCompleteName);
+  };
+  MappedMutableProblogTheory.prototype.get = function (clause) {
+    return this.o3e_1.get(clause);
+  };
+  MappedMutableProblogTheory.prototype.getByIndicator = function (indicator) {
+    return this.o3e_1.getByIndicator(indicator);
+  };
+  MappedMutableProblogTheory.prototype.getByHead = function (head) {
+    return this.o3e_1.getByHead(head);
+  };
+  MappedMutableProblogTheory.prototype.getTag = function (name) {
+    return this.o3e_1.getTag(name);
+  };
+  MappedMutableProblogTheory.prototype.j = function () {
+    return this.o3e_1.j();
+  };
+  MappedMutableProblogTheory.prototype.o12 = function (tags) {
+    return this.o3e_1.o12(tags);
+  };
+  MappedMutableProblogTheory.prototype.resetTags = function (tags) {
+    return this.o12(tags);
+  };
+  MappedMutableProblogTheory.prototype.l1s = function (unificator) {
+    return this.o3e_1.l1s(unificator);
+  };
+  MappedMutableProblogTheory.prototype.setUnificator = function (unificator) {
+    return this.l1s(unificator);
+  };
+  MappedMutableProblogTheory.prototype.toStringAsProlog = function (asPrologText) {
+    return this.o3e_1.toStringAsProlog(asPrologText);
+  };
+  MappedMutableProblogTheory.prototype.a1t = function () {
+    return false;
+  };
+  MappedMutableProblogTheory.prototype.b1t = function () {
+    return Companion_getInstance_20().ofIterable(this.k1l(), this);
+  };
+  MappedMutableProblogTheory.prototype.toMutableTheory = function () {
+    return this.b1t();
+  };
+  MappedMutableProblogTheory.prototype.a1s = function () {
+    return this;
+  };
+  MappedMutableProblogTheory.prototype.toImmutableTheory = function () {
+    return this.a1s();
+  };
+  MappedMutableProblogTheory.prototype.p3e = function (theory) {
+    return new MappedMutableProblogTheory(null, this.k1l(), this.o3e_1.n1s(theory));
+  };
+  MappedMutableProblogTheory.prototype.n1s = function (theory) {
+    var tmp0_subject = theory;
+    var tmp;
+    if (isInterface(tmp0_subject, ProblogTheory)) {
+      tmp = this.p3e(theory);
+    } else {
+      var tmp_0 = this.k1l();
+      tmp = this.p3e(MappedMutableProblogTheory_init_$Create$(theory, tmp_0, null, 4, null));
+    }
+    return tmp;
+  };
+  MappedMutableProblogTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  MappedMutableProblogTheory.prototype.b1s = function (clause) {
+    var mapped = ClauseMappingUtils_getInstance().m3e(clause);
+    return new MappedMutableProblogTheory(null, this.k1l(), this.o3e_1.n1s(Companion_getInstance_18().indexedOfIterable(this.k1l(), mapped)));
+  };
+  MappedMutableProblogTheory.prototype.plus = function (clause) {
+    return this.b1s(clause);
+  };
+  MappedMutableProblogTheory.prototype.r1s = function (clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.flatMap' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedMutableProblogTheory.assertA.<anonymous>' call
+      tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+      var list = tmp$ret$0;
+      addAll(tmp0_flatMapTo, list);
+    }
+    tmp$ret$1 = tmp0_flatMapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var mapped = tmp$ret$2;
+    return new MappedMutableProblogTheory(null, this.k1l(), this.o3e_1.r1s(mapped));
+  };
+  MappedMutableProblogTheory.prototype.assertAIterable = function (clauses) {
+    return this.r1s(clauses);
+  };
+  MappedMutableProblogTheory.prototype.u1s = function (clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.flatMap' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedMutableProblogTheory.assertZ.<anonymous>' call
+      tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+      var list = tmp$ret$0;
+      addAll(tmp0_flatMapTo, list);
+    }
+    tmp$ret$1 = tmp0_flatMapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var mapped = tmp$ret$2;
+    return new MappedMutableProblogTheory(null, this.k1l(), this.o3e_1.u1s(mapped));
+  };
+  MappedMutableProblogTheory.prototype.assertZIterable = function (clauses) {
+    return this.u1s(clauses);
+  };
+  MappedMutableProblogTheory.prototype.y1s = function (clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.flatMap' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedMutableProblogTheory.retract.<anonymous>' call
+      tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+      var list = tmp$ret$0;
+      addAll(tmp0_flatMapTo, list);
+    }
+    tmp$ret$1 = tmp0_flatMapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var mapped = tmp$ret$2;
+    var result = this.o3e_1.y1s(mapped);
+    var tmp;
+    if (result instanceof Success) {
+      tmp = new Success(new MappedMutableProblogTheory(null, this.k1l(), result.h1s()), result.i1t_1);
+    } else {
+      tmp = new Failure(new MappedMutableProblogTheory(null, this.k1l(), result.h1s()));
+    }
+    return tmp;
+  };
+  MappedMutableProblogTheory.prototype.retractIterable = function (clauses) {
+    return this.y1s(clauses);
+  };
+  MappedMutableProblogTheory.prototype.c1m = function (clause) {
+    var mappedClauses = ClauseMappingUtils_getInstance().m3e(clause);
+    var result = null;
+    var tmp0_iterator = mappedClauses.j();
+    while (tmp0_iterator.m()) {
+      var c = tmp0_iterator.p();
+      var tmp;
+      if (result == null) {
+        tmp = true;
+      } else {
+        tmp = !(result instanceof Failure);
+      }
+      if (tmp) {
+        result = this.o3e_1.c1m(c);
+      }
+    }
+    var tmp1_subject = result;
+    var tmp_0;
+    if (tmp1_subject instanceof Success) {
+      tmp_0 = new Success(new MappedMutableProblogTheory(null, this.k1l(), result.h1s()), result.i1t_1);
+    } else {
+      if (tmp1_subject instanceof Failure) {
+        tmp_0 = new Failure(new MappedMutableProblogTheory(null, this.k1l(), result.h1s()));
+      } else {
+        tmp_0 = new Failure(this);
+      }
+    }
+    return tmp_0;
+  };
+  MappedMutableProblogTheory.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  MappedMutableProblogTheory.prototype.g1s = function (indicator) {
+    return new MappedMutableProblogTheory(null, this.k1l(), this.o3e_1.g1s(ClauseMappingUtils_getInstance().n3e(indicator)));
+  };
+  MappedMutableProblogTheory.prototype.abolish = function (indicator) {
+    return this.g1s(indicator);
+  };
+  MappedMutableProblogTheory.prototype.c1t = function (struct) {
+    return this.p1s(Companion_getInstance().of(struct));
+  };
+  MappedMutableProblogTheory.prototype.assertAFact = function (struct) {
+    return this.c1t(struct);
+  };
+  MappedMutableProblogTheory.prototype.d1t = function (struct) {
+    return this.t1s(Companion_getInstance().of(struct));
+  };
+  MappedMutableProblogTheory.prototype.assertZFact = function (struct) {
+    return this.d1t(struct);
+  };
+  MappedMutableProblogTheory.prototype.p1s = function (clause) {
+    return this.r1s(listOf(clause));
+  };
+  MappedMutableProblogTheory.prototype.assertA = function (clause) {
+    return this.p1s(clause);
+  };
+  MappedMutableProblogTheory.prototype.s1s = function (clauses) {
+    return this.r1s(asIterable_0(clauses));
+  };
+  MappedMutableProblogTheory.prototype.assertASequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  MappedMutableProblogTheory.prototype.t1s = function (clause) {
+    return this.u1s(listOf(clause));
+  };
+  MappedMutableProblogTheory.prototype.assertZ = function (clause) {
+    return this.t1s(clause);
+  };
+  MappedMutableProblogTheory.prototype.v1s = function (clauses) {
+    return this.u1s(asIterable_0(clauses));
+  };
+  MappedMutableProblogTheory.prototype.assertZSequence = function (clauses) {
+    return this.v1s(clauses);
+  };
+  MappedMutableProblogTheory.prototype.f1t = function (head) {
+    return this.e1t(Companion_getInstance_12().of(head, [Companion_getInstance_1().anonymous()]));
+  };
+  MappedMutableProblogTheory.prototype.retractByHead = function (head) {
+    return this.f1t(head);
+  };
+  MappedMutableProblogTheory.prototype.e1t = function (clause) {
+    return this.y1s(listOf(clause));
+  };
+  MappedMutableProblogTheory.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  MappedMutableProblogTheory.prototype.x1s = function (clauses) {
+    return this.y1s(asIterable_0(clauses));
+  };
+  MappedMutableProblogTheory.prototype.retractSequence = function (clauses) {
+    return this.x1s(clauses);
+  };
+  MappedMutableProblogTheory.prototype.g1t = function (head) {
+    return this.c1m(Companion_getInstance_12().of(head, [Companion_getInstance_1().anonymous()]));
+  };
+  MappedMutableProblogTheory.prototype.retractAllByHead = function (head) {
+    return this.g1t(head);
+  };
+  function MappedProblogTheory_init_$Init$(clauses, unificator, theory, $mask0, $marker, $this) {
+    if (!(($mask0 & 2) === 0))
+      unificator = Companion_getInstance_16().h1l();
+    if (!(($mask0 & 4) === 0)) {
+      var tmp = Companion_getInstance_18();
+      var tmp0_safe_receiver = clauses;
+      var tmp_0;
+      if (tmp0_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        var tmp$ret$2;
+        var tmp$ret$2_0;
+        // Inline function 'kotlin.collections.flatMap' call
+        var tmp$ret$1;
+        var tmp$ret$1_0;
+        // Inline function 'kotlin.collections.flatMapTo' call
+        var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+        var tmp0_iterator = tmp0_safe_receiver.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$0;
+          var tmp$ret$0_0;
+          // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedProblogTheory.<init>.<anonymous>' call
+          tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+          tmp$ret$0_0 = Unit_getInstance();
+          var list = tmp$ret$0;
+          addAll(tmp0_flatMapTo, list);
+        }
+        tmp$ret$1 = tmp0_flatMapTo;
+        tmp$ret$1_0 = Unit_getInstance();
+        tmp$ret$2 = tmp$ret$1;
+        tmp$ret$2_0 = Unit_getInstance();
+        tmp_0 = tmp$ret$2;
+      }
+      var tmp1_elvis_lhs = tmp_0;
+      theory = tmp.indexedOfIterable(unificator, tmp1_elvis_lhs == null ? emptyList() : tmp1_elvis_lhs);
+    }
+    MappedProblogTheory.call($this, clauses, unificator, theory);
+    return $this;
+  }
+  function MappedProblogTheory_init_$Create$(clauses, unificator, theory, $mask0, $marker) {
+    return MappedProblogTheory_init_$Init$(clauses, unificator, theory, $mask0, $marker, Object.create(MappedProblogTheory.prototype));
+  }
+  function MappedProblogTheory(clauses, unificator, theory) {
+    this.q3e_1 = theory;
+  }
+  MappedProblogTheory.prototype.t1l = function () {
+    return this.q3e_1.t1l();
+  };
+  MappedProblogTheory.prototype.m1l = function () {
+    return this.q3e_1.m1l();
+  };
+  MappedProblogTheory.prototype.o1l = function () {
+    return this.q3e_1.o1l();
+  };
+  MappedProblogTheory.prototype.k1s = function () {
+    return this.q3e_1.k1s();
+  };
+  MappedProblogTheory.prototype.o = function () {
+    return this.q3e_1.o();
+  };
+  MappedProblogTheory.prototype.kt = function () {
+    return this.q3e_1.kt();
+  };
+  MappedProblogTheory.prototype.k1l = function () {
+    return this.q3e_1.k1l();
+  };
+  MappedProblogTheory.prototype.clone = function () {
+    return this.q3e_1.clone();
+  };
+  MappedProblogTheory.prototype.contains = function (clause) {
+    return this.q3e_1.contains(clause);
+  };
+  MappedProblogTheory.prototype.containsIndicator = function (indicator) {
+    return this.q3e_1.containsIndicator(indicator);
+  };
+  MappedProblogTheory.prototype.containsHead = function (head) {
+    return this.q3e_1.containsHead(head);
+  };
+  MappedProblogTheory.prototype.containsTag = function (name) {
+    return this.q3e_1.containsTag(name);
+  };
+  MappedProblogTheory.prototype.equalsUsingVarCompleteNames = function (other, useVarCompleteName) {
+    return this.q3e_1.equalsUsingVarCompleteNames(other, useVarCompleteName);
+  };
+  MappedProblogTheory.prototype.get = function (clause) {
+    return this.q3e_1.get(clause);
+  };
+  MappedProblogTheory.prototype.getByIndicator = function (indicator) {
+    return this.q3e_1.getByIndicator(indicator);
+  };
+  MappedProblogTheory.prototype.getByHead = function (head) {
+    return this.q3e_1.getByHead(head);
+  };
+  MappedProblogTheory.prototype.getTag = function (name) {
+    return this.q3e_1.getTag(name);
+  };
+  MappedProblogTheory.prototype.j = function () {
+    return this.q3e_1.j();
+  };
+  MappedProblogTheory.prototype.resetTags = function (tags) {
+    return this.q3e_1.resetTags(tags);
+  };
+  MappedProblogTheory.prototype.setUnificator = function (unificator) {
+    return this.q3e_1.setUnificator(unificator);
+  };
+  MappedProblogTheory.prototype.toStringAsProlog = function (asPrologText) {
+    return this.q3e_1.toStringAsProlog(asPrologText);
+  };
+  MappedProblogTheory.prototype.a1t = function () {
+    return false;
+  };
+  MappedProblogTheory.prototype.b1t = function () {
+    return Companion_getInstance_20().ofIterable(this.k1l(), this);
+  };
+  MappedProblogTheory.prototype.toMutableTheory = function () {
+    return this.b1t();
+  };
+  MappedProblogTheory.prototype.a1s = function () {
+    return this;
+  };
+  MappedProblogTheory.prototype.toImmutableTheory = function () {
+    return this.a1s();
+  };
+  MappedProblogTheory.prototype.p3e = function (theory) {
+    return new MappedProblogTheory(null, this.k1l(), this.q3e_1.plusTheory(theory));
+  };
+  MappedProblogTheory.prototype.n1s = function (theory) {
+    var tmp0_subject = theory;
+    var tmp;
+    if (isInterface(tmp0_subject, ProblogTheory)) {
+      tmp = this.p3e(theory);
+    } else {
+      var tmp_0 = this.k1l();
+      tmp = this.p3e(MappedProblogTheory_init_$Create$(theory, tmp_0, null, 4, null));
+    }
+    return tmp;
+  };
+  MappedProblogTheory.prototype.plusTheory = function (theory) {
+    return this.n1s(theory);
+  };
+  MappedProblogTheory.prototype.b1s = function (clause) {
+    var mapped = ClauseMappingUtils_getInstance().m3e(clause);
+    return new MappedProblogTheory(null, this.k1l(), this.q3e_1.plusTheory(Companion_getInstance_18().indexedOfIterable(this.k1l(), mapped)));
+  };
+  MappedProblogTheory.prototype.plus = function (clause) {
+    return this.b1s(clause);
+  };
+  MappedProblogTheory.prototype.r1s = function (clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.flatMap' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedProblogTheory.assertA.<anonymous>' call
+      tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+      var list = tmp$ret$0;
+      addAll(tmp0_flatMapTo, list);
+    }
+    tmp$ret$1 = tmp0_flatMapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var mapped = tmp$ret$2;
+    return new MappedProblogTheory(null, this.k1l(), this.q3e_1.assertAIterable(mapped));
+  };
+  MappedProblogTheory.prototype.assertAIterable = function (clauses) {
+    return this.r1s(clauses);
+  };
+  MappedProblogTheory.prototype.u1s = function (clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.flatMap' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedProblogTheory.assertZ.<anonymous>' call
+      tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+      var list = tmp$ret$0;
+      addAll(tmp0_flatMapTo, list);
+    }
+    tmp$ret$1 = tmp0_flatMapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var mapped = tmp$ret$2;
+    return new MappedProblogTheory(null, this.k1l(), this.q3e_1.assertZIterable(mapped));
+  };
+  MappedProblogTheory.prototype.assertZIterable = function (clauses) {
+    return this.u1s(clauses);
+  };
+  MappedProblogTheory.prototype.y1s = function (clauses) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.flatMap' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var tmp0_flatMapTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator = clauses.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.knowledge.impl.MappedProblogTheory.retract.<anonymous>' call
+      tmp$ret$0 = ClauseMappingUtils_getInstance().m3e(element);
+      var list = tmp$ret$0;
+      addAll(tmp0_flatMapTo, list);
+    }
+    tmp$ret$1 = tmp0_flatMapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var mapped = tmp$ret$2;
+    var result = this.q3e_1.retractIterable(mapped);
+    var tmp;
+    if (result instanceof Success) {
+      tmp = new Success(new MappedProblogTheory(null, this.k1l(), result.h1s()), result.i1t_1);
+    } else {
+      tmp = new Failure(new MappedProblogTheory(null, this.k1l(), result.h1s()));
+    }
+    return tmp;
+  };
+  MappedProblogTheory.prototype.retractIterable = function (clauses) {
+    return this.y1s(clauses);
+  };
+  MappedProblogTheory.prototype.c1m = function (clause) {
+    var mappedClauses = ClauseMappingUtils_getInstance().m3e(clause);
+    var result = null;
+    var tmp0_iterator = mappedClauses.j();
+    while (tmp0_iterator.m()) {
+      var c = tmp0_iterator.p();
+      var tmp;
+      if (result == null) {
+        tmp = true;
+      } else {
+        tmp = !(result instanceof Failure);
+      }
+      if (tmp) {
+        result = this.q3e_1.retractAll(c);
+      }
+    }
+    var tmp1_subject = result;
+    var tmp_0;
+    if (tmp1_subject instanceof Success) {
+      tmp_0 = new Success(new MappedProblogTheory(null, this.k1l(), result.h1s()), result.i1t_1);
+    } else {
+      tmp_0 = new Failure(this);
+    }
+    return tmp_0;
+  };
+  MappedProblogTheory.prototype.retractAll = function (clause) {
+    return this.c1m(clause);
+  };
+  MappedProblogTheory.prototype.g1s = function (indicator) {
+    return new MappedProblogTheory(null, this.k1l(), this.q3e_1.abolish(ClauseMappingUtils_getInstance().n3e(indicator)));
+  };
+  MappedProblogTheory.prototype.abolish = function (indicator) {
+    return this.g1s(indicator);
+  };
+  MappedProblogTheory.prototype.c1t = function (struct) {
+    return this.p1s(Companion_getInstance().of(struct));
+  };
+  MappedProblogTheory.prototype.assertAFact = function (struct) {
+    return this.c1t(struct);
+  };
+  MappedProblogTheory.prototype.d1t = function (struct) {
+    return this.t1s(Companion_getInstance().of(struct));
+  };
+  MappedProblogTheory.prototype.assertZFact = function (struct) {
+    return this.d1t(struct);
+  };
+  MappedProblogTheory.prototype.p1s = function (clause) {
+    return this.r1s(listOf(clause));
+  };
+  MappedProblogTheory.prototype.assertA = function (clause) {
+    return this.p1s(clause);
+  };
+  MappedProblogTheory.prototype.s1s = function (clauses) {
+    return this.r1s(asIterable_0(clauses));
+  };
+  MappedProblogTheory.prototype.assertASequence = function (clauses) {
+    return this.s1s(clauses);
+  };
+  MappedProblogTheory.prototype.t1s = function (clause) {
+    return this.u1s(listOf(clause));
+  };
+  MappedProblogTheory.prototype.assertZ = function (clause) {
+    return this.t1s(clause);
+  };
+  MappedProblogTheory.prototype.v1s = function (clauses) {
+    return this.u1s(asIterable_0(clauses));
+  };
+  MappedProblogTheory.prototype.assertZSequence = function (clauses) {
+    return this.v1s(clauses);
+  };
+  MappedProblogTheory.prototype.f1t = function (head) {
+    return this.e1t(Companion_getInstance_12().of(head, [Companion_getInstance_1().anonymous()]));
+  };
+  MappedProblogTheory.prototype.retractByHead = function (head) {
+    return this.f1t(head);
+  };
+  MappedProblogTheory.prototype.e1t = function (clause) {
+    return this.y1s(listOf(clause));
+  };
+  MappedProblogTheory.prototype.retract = function (clause) {
+    return this.e1t(clause);
+  };
+  MappedProblogTheory.prototype.x1s = function (clauses) {
+    return this.y1s(asIterable_0(clauses));
+  };
+  MappedProblogTheory.prototype.retractSequence = function (clauses) {
+    return this.x1s(clauses);
+  };
+  MappedProblogTheory.prototype.g1t = function (head) {
+    return this.c1m(Companion_getInstance_12().of(head, [Companion_getInstance_1().anonymous()]));
+  };
+  MappedProblogTheory.prototype.retractAllByHead = function (head) {
+    return this.g1t(head);
+  };
+  function NothingClauseMapper() {
+    NothingClauseMapper_instance = this;
+  }
+  NothingClauseMapper.prototype.a3e = function (clause) {
+    return true;
+  };
+  NothingClauseMapper.prototype.b3e = function (clause) {
+    return listOf(clause);
+  };
+  var NothingClauseMapper_instance;
+  function NothingClauseMapper_getInstance() {
+    if (NothingClauseMapper_instance == null)
+      new NothingClauseMapper();
+    return NothingClauseMapper_instance;
+  }
+  function ProbabilisticClauseMapper() {
+    ProbabilisticClauseMapper_instance = this;
+  }
+  ProbabilisticClauseMapper.prototype.a3e = function (clause) {
+    var tmp;
+    if (isInterface(clause, Rule)) {
+      tmp = clause.ly().fw() === get_ANNOTATION_FUNCTOR();
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  ProbabilisticClauseMapper.prototype.b3e = function (clause) {
+    if (!isInterface(clause, Rule)) {
+      var tmp = 'Clause is not an instance of Rule: ' + clause;
+      throw ClauseMappingException_init_$Create$(tmp, null, 2, null);
+    }
+    var mapped = this.c3e(clause);
+    return listOf(this.d3e(mapped.g4_1, Companion_getInstance_21().p3d(mapped.h4_1)));
+  };
+  ProbabilisticClauseMapper.prototype.c3e = function (rule) {
+    if (!(rule.ly().zv() === 2)) {
+      throw TuPrologException_init_$Create$('Invalid probabilistic rule: ' + rule.ly());
+    }
+    var probTerm = rule.ly().get(0);
+    var tmp;
+    if (isInterface(probTerm, Numeric)) {
+      tmp = probTerm.x10().toDouble();
+    } else {
+      tmp = solveArithmeticExpression(probTerm);
+    }
+    var probability = tmp;
+    var headTerm = safeToStruct(rule.ly().get(1));
+    var tmp_0 = headTerm.fw();
+    ProblogLib_getInstance();
+    if (tmp_0 === 'evidence') {
+      throw TuPrologException_init_$Create$("Probability notation can't be expressed on evidence: " + rule.ly());
+    }
+    var bodyTerm = rule.my();
+    var tmp_1 = rule.my();
+    if (isInterface(tmp_1, Truth)) {
+      if (!rule.my().dw() ? probability < 1.0 : false) {
+        probability = 1.0 - probability;
+        bodyTerm = Companion_getInstance_15().of(true);
+      }
+    }
+    var anonVariablesFix = withoutAnonymousVars(Companion_getInstance_12().of(headTerm, [bodyTerm]));
+    headTerm = anonVariablesFix.ly();
+    bodyTerm = anonVariablesFix.my();
+    var extraVariables = get_extraVariables(Companion_getInstance_12().of(headTerm, [bodyTerm]));
+    var probTerm_0 = new ProbTerm(ClauseMappingUtils_getInstance().l3e(), probability, headTerm, extraVariables);
+    return new Pair(Companion_getInstance_12().of(headTerm, [bodyTerm]), probTerm_0);
+  };
+  ProbabilisticClauseMapper.prototype.d3e = function (rule, explanation) {
+    var tmp = rule.my();
+    if (isInterface(tmp, Truth)) {
+      return Companion_getInstance_12().of(withExplanation(rule.ly(), toTerm(explanation)), [rule.my()]);
+    }
+    var tmp_0 = Companion_getInstance_1();
+    ProblogLib_getInstance();
+    var explanationVar = tmp_0.of('EXPL' + '_Res');
+    var tmp_1 = Companion_getInstance_1();
+    ProblogLib_getInstance();
+    var explanationBodyVar = tmp_1.of('EXPL' + '_Body');
+    var newBody = withBodyExplanation(rule.my(), explanationBodyVar);
+    var tmp_2 = Companion_getInstance_12();
+    var tmp_3 = withExplanation(rule.ly(), explanationVar);
+    var tmp_4 = Companion_getInstance_3();
+    var tmp_5 = Companion_getInstance_3();
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp0__get_functor__thl4dk = ProbExplAnd_getInstance();
+    tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+    return tmp_2.of(tmp_3, [tmp_4.of(',', [newBody, tmp_5.of(tmp$ret$0, [explanationVar, explanationBodyVar, toTerm(explanation)])])]);
+  };
+  var ProbabilisticClauseMapper_instance;
+  function ProbabilisticClauseMapper_getInstance() {
+    if (ProbabilisticClauseMapper_instance == null)
+      new ProbabilisticClauseMapper();
+    return ProbabilisticClauseMapper_instance;
+  }
+  function PrologClauseMapper() {
+    PrologClauseMapper_instance = this;
+  }
+  PrologClauseMapper.prototype.a3e = function (clause) {
+    return isInterface(clause, Rule);
+  };
+  PrologClauseMapper.prototype.b3e = function (clause) {
+    if (!isInterface(clause, Rule)) {
+      var tmp = 'Clause is not an instance of Rule: ' + clause;
+      throw ClauseMappingException_init_$Create$(tmp, null, 2, null);
+    }
+    var tmp_0 = clause.my();
+    if (isInterface(tmp_0, Truth)) {
+      return listOf(Companion_getInstance_12().of(withExplanation(clause.ly(), toTerm(Companion_getInstance_21().l3d_1)), [clause.my()]));
+    }
+    var tmp_1 = Companion_getInstance_1();
+    ProblogLib_getInstance();
+    var explanationVar = tmp_1.of('EXPL' + '_Res');
+    return listOf(Companion_getInstance_12().of(withExplanation(clause.ly(), explanationVar), [withBodyExplanation(clause.my(), explanationVar)]));
+  };
+  var PrologClauseMapper_instance;
+  function PrologClauseMapper_getInstance() {
+    if (PrologClauseMapper_instance == null)
+      new PrologClauseMapper();
+    return PrologClauseMapper_instance;
+  }
+  function ProbExplAnd() {
+    ProbExplAnd_instance = this;
+    ProblogLib_getInstance();
+    NonBacktrackable.call(this, 'prob' + '_expl_and');
+  }
+  ProbExplAnd.prototype.z2r = function (_this__u8e3s4, first, second, third) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().n2h(_this__u8e3s4, 1);
+    if (ProbSetConfig_getInstance().s3e(_this__u8e3s4.context)) {
+      var tmp = Companion_getInstance_19().b2h(_this__u8e3s4, first, toTerm(Companion_getInstance_21().l3d_1));
+      return _this__u8e3s4.g2g(tmp, null, [], 6, null);
+    }
+    var tmp_0;
+    var tmp_1;
+    var tmp_2;
+    if (isInterface(first, Var)) {
+      tmp_2 = second instanceof ProbExplanationTerm;
+    } else {
+      tmp_2 = false;
+    }
+    if (tmp_2) {
+      tmp_1 = third instanceof ProbExplanationTerm;
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      var explanation = (second.h3c_1.x3d() === 0.0 ? true : third.h3c_1.x3d() === 0.0) ? Companion_getInstance_21().k3d_1 : (second.h3c_1.x3d() === 1.0 ? third.h3c_1.x3d() === 1.0 : false) ? Companion_getInstance_21().l3d_1 : second.h3c_1.x3d() === 1.0 ? third.h3c_1 : third.h3c_1.x3d() === 1.0 ? second.h3c_1 : second.h3c_1.and(third.h3c_1);
+      var tmp_3;
+      if (explanation.x3d() === 0.0) {
+        tmp_3 = _this__u8e3s4.y2i(false, null, [], 6, null);
+      } else {
+        var tmp_4 = Companion_getInstance_19().b2h(_this__u8e3s4, first, new ProbExplanationTerm(explanation));
+        tmp_3 = _this__u8e3s4.g2g(tmp_4, null, [], 6, null);
+      }
+      tmp_0 = tmp_3;
+    } else {
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+      tmp$ret$0 = this.signature.name;
+      var tmp_5 = "Can't compute " + tmp$ret$0;
+      var tmp_6 = ResolutionException_init_$Create$(tmp_5, null, _this__u8e3s4.context, [], 10, null);
+      tmp_0 = _this__u8e3s4.c2j(tmp_6, null, [], 6, null);
+    }
+    return tmp_0;
+  };
+  ProbExplAnd.prototype.r2j = function (_this__u8e3s4, first, second, third) {
+    return this.z2r(_this__u8e3s4, first, second, third);
+  };
+  var ProbExplAnd_instance;
+  function ProbExplAnd_getInstance() {
+    if (ProbExplAnd_instance == null)
+      new ProbExplAnd();
+    return ProbExplAnd_instance;
+  }
+  function ProbHelper$computeAllSubstitutions$slambda($goal, $this_computeAllSubstitutions, $third, $first, $second, $goalSignature, resultContinuation) {
+    this.b3f_1 = $goal;
+    this.c3f_1 = $this_computeAllSubstitutions;
+    this.d3f_1 = $third;
+    this.e3f_1 = $first;
+    this.f3f_1 = $second;
+    this.g3f_1 = $goalSignature;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  ProbHelper$computeAllSubstitutions$slambda.prototype.t2t = function ($this$sequence, $cont) {
+    var tmp = this.u2t($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  ProbHelper$computeAllSubstitutions$slambda.prototype.wi = function (p1, $cont) {
+    return this.t2t(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  ProbHelper$computeAllSubstitutions$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 18;
+            this.i3f_1 = this.b3f_1.fw();
+            if (this.i3f_1 === '\\+' ? true : this.i3f_1 === 'not') {
+              this.ci_1 = 16;
+              var tmp_0;
+              if (ProbSetConfig_getInstance().s3e(this.c3f_1.context)) {
+                var tmp_1 = Companion_getInstance_19();
+                var tmp_2 = Companion_getInstance_3();
+                var tmp_3 = this.b3f_1.fw();
+                var tmp_4 = Companion_getInstance_3();
+                var tmp0__get_functor__thl4dk = Prob_getInstance();
+                tmp_0 = tmp_1.b2h(this.c3f_1, this.d3f_1, tmp_2.of(tmp_3, [tmp_4.of(tmp0__get_functor__thl4dk.signature.name, [Companion_getInstance_1().anonymous(), this.b3f_1.get(0)])])).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1)));
+              } else {
+                var tmp_5 = Companion_getInstance_19();
+                var tmp_6 = Companion_getInstance_3();
+                var tmp1__get_functor__4k11yf = ProbNegationAsFailure_getInstance();
+                tmp_0 = tmp_5.b2h(this.c3f_1, this.d3f_1, tmp_6.of(tmp1__get_functor__4k11yf.signature.name, [this.e3f_1, this.b3f_1.get(0)]));
+              }
+              suspendResult = this.h3f_1.z4(tmp_0, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              if ((this.i3f_1 === ',' ? true : this.i3f_1 === ';') ? true : this.i3f_1 === '->') {
+                this.ci_1 = 15;
+                var tmp_7;
+                if (ProbSetConfig_getInstance().s3e(this.c3f_1.context)) {
+                  tmp_7 = Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, withBodyExplanation(this.b3f_1, Companion_getInstance_1().anonymous())).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1)));
+                } else {
+                  tmp_7 = Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, withBodyExplanation(this.b3f_1, this.e3f_1));
+                }
+                suspendResult = this.h3f_1.z4(tmp_7, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+                continue $sm;
+              } else {
+                if (this.i3f_1 === 'call') {
+                  this.j3f_1 = this.b3f_1.get(0);
+                  this.ci_1 = 14;
+                  suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, Companion_getInstance_2().of(Companion_getInstance_3().of('ensure_executable', [this.j3f_1]), Companion_getInstance_3().of(this.b3f_1.fw(), [withBodyExplanation(this.j3f_1, this.e3f_1)]))), this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  if (this.i3f_1 === 'catch') {
+                    this.ci_1 = 13;
+                    suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, Companion_getInstance_3().of(this.b3f_1.fw(), [withBodyExplanation(this.b3f_1.get(0), this.e3f_1), this.b3f_1.get(1), withBodyExplanation(this.b3f_1.get(2), this.e3f_1)])), this);
+                    if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                      return suspendResult;
+                    }
+                    continue $sm;
+                  } else {
+                    if (this.i3f_1 === 'findall') {
+                      var tmp_8 = this;
+                      var tmp2_toTypedArray = this.b3f_1.gw();
+                      tmp_8.k3f_1 = copyToArray(tmp2_toTypedArray);
+                      this.k3f_1[1] = withBodyExplanation(this.k3f_1[1], Companion_getInstance_1().anonymous());
+                      this.ci_1 = 12;
+                      suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, Companion_getInstance_3().of(this.b3f_1.fw(), this.k3f_1.slice())).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1))), this);
+                      if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                        return suspendResult;
+                      }
+                      continue $sm;
+                    } else {
+                      if ((this.i3f_1 === 'assert' ? true : this.i3f_1 === 'asserta') ? true : this.i3f_1 === 'assertz') {
+                        this.l3f_1 = this.b3f_1.get(0);
+                        var tmp_9 = this;
+                        var tmp1_subject = this.l3f_1;
+                        var tmp_10;
+                        if (isInterface(tmp1_subject, Clause)) {
+                          tmp_10 = extractSignature(ensureNotNull(this.l3f_1.ly()));
+                        } else {
+                          tmp_10 = extractSignature(safeToStruct(this.l3f_1));
+                        }
+                        tmp_9.m3f_1 = tmp_10;
+                        var tmp_11;
+                        if (this.c3f_1.context.w1u().containsSignature(this.m3f_1)) {
+                          tmp_11 = true;
+                        } else {
+                          var tmp_12;
+                          var tmp_13 = this.l3f_1;
+                          if (isInterface(tmp_13, Clause)) {
+                            tmp_12 = !this.l3f_1.vy();
+                          } else {
+                            tmp_12 = false;
+                          }
+                          tmp_11 = tmp_12;
+                        }
+                        if (tmp_11) {
+                          this.ci_1 = 10;
+                          suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, this.b3f_1).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1))), this);
+                          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                            return suspendResult;
+                          }
+                          continue $sm;
+                        } else {
+                          var tmp_14 = this;
+                          var tmp2_subject = this.l3f_1;
+                          var tmp_15;
+                          if (isInterface(tmp2_subject, Clause)) {
+                            tmp_15 = ClauseMappingUtils_getInstance().m3e(this.l3f_1);
+                          } else {
+                            if (isInterface(tmp2_subject, Struct)) {
+                              var tmp3_map = ClauseMappingUtils_getInstance().m3e(Companion_getInstance().of(this.l3f_1));
+                              var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp3_map, 10));
+                              var tmp0_iterator = tmp3_map.j();
+                              while (tmp0_iterator.m()) {
+                                var item = tmp0_iterator.p();
+                                tmp0_mapTo.g(ensureNotNull(item.ly()));
+                              }
+                              tmp_15 = tmp0_mapTo;
+                            } else {
+                              tmp_15 = listOf(this.l3f_1);
+                            }
+                          }
+                          tmp_14.n3f_1 = tmp_15;
+                          this.ci_1 = 9;
+                          var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this.n3f_1, 10));
+                          var tmp0_iterator_0 = this.n3f_1.j();
+                          while (tmp0_iterator_0.m()) {
+                            var item_0 = tmp0_iterator_0.p();
+                            tmp0_mapTo_0.g(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, Companion_getInstance_3().of(this.b3f_1.fw(), [item_0])).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1))));
+                          }
+                          suspendResult = this.h3f_1.b5(tmp0_mapTo_0, this);
+                          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                            return suspendResult;
+                          }
+                          continue $sm;
+                        }
+                      } else {
+                        if (this.i3f_1 === 'retract' ? true : this.i3f_1 === 'retractall') {
+                          this.o3f_1 = this.b3f_1.get(0);
+                          this.ci_1 = 8;
+                          var tmp_16 = Companion_getInstance_19();
+                          var tmp_17 = Companion_getInstance_3();
+                          var tmp_18 = this.b3f_1.fw();
+                          var tmp_19;
+                          var tmp_20;
+                          var tmp_21;
+                          if (this.o3f_1.mw()) {
+                            tmp_21 = true;
+                          } else {
+                            var tmp_22;
+                            var tmp_23 = this.o3f_1;
+                            if (isInterface(tmp_23, Struct)) {
+                              tmp_22 = this.o3f_1.fw() === ':-';
+                            } else {
+                              tmp_22 = false;
+                            }
+                            tmp_21 = tmp_22;
+                          }
+                          if (tmp_21) {
+                            tmp_20 = true;
+                          } else {
+                            tmp_20 = this.c3f_1.context.w1u().containsSignature(extractSignature(safeToStruct(this.o3f_1)));
+                          }
+                          if (tmp_20) {
+                            tmp_19 = this.o3f_1;
+                          } else {
+                            tmp_19 = withExplanation(this.o3f_1, this.e3f_1);
+                          }
+                          suspendResult = this.h3f_1.z4(tmp_16.b2h(this.c3f_1, this.d3f_1, tmp_17.of(tmp_18, [tmp_19])), this);
+                          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                            return suspendResult;
+                          }
+                          continue $sm;
+                        } else {
+                          if (this.i3f_1 === 'clause') {
+                            this.p3f_1 = this.b3f_1.get(0);
+                            var tmp_24;
+                            var tmp_25 = this.p3f_1;
+                            if (!isInterface(tmp_25, Struct)) {
+                              tmp_24 = true;
+                            } else {
+                              tmp_24 = this.c3f_1.context.w1u().hasProtected(extractSignature(this.p3f_1));
+                            }
+                            if (tmp_24) {
+                              this.ci_1 = 6;
+                              suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, this.b3f_1).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1))), this);
+                              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                                return suspendResult;
+                              }
+                              continue $sm;
+                            } else {
+                              this.ci_1 = 5;
+                              suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, Companion_getInstance_3().of(this.b3f_1.fw(), [withExplanation(this.b3f_1.get(0), this.e3f_1), this.b3f_1.get(1)])), this);
+                              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                                return suspendResult;
+                              }
+                              continue $sm;
+                            }
+                          } else {
+                            var tmp_26 = this;
+                            var tmp_27;
+                            var tmp_28 = this.f3f_1;
+                            if (isInterface(tmp_28, Truth)) {
+                              tmp_27 = true;
+                            } else {
+                              tmp_27 = this.c3f_1.context.w1u().containsSignature(this.g3f_1);
+                            }
+                            tmp_26.q3f_1 = tmp_27;
+                            if ((this.q3f_1 ? true : this.c3f_1.context.y1u().containsIndicator(this.g3f_1.toIndicator())) ? true : this.c3f_1.context.z1u().containsIndicator(this.g3f_1.toIndicator())) {
+                              this.ci_1 = 1;
+                              suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, this.b3f_1).plus(Companion_getInstance_19().b2h(this.c3f_1, this.e3f_1, toTerm(Companion_getInstance_21().l3d_1))), this);
+                              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                                return suspendResult;
+                              }
+                              continue $sm;
+                            } else {
+                              this.ci_1 = 2;
+                              continue $sm;
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+
+            break;
+          case 1:
+            this.ci_1 = 2;
+            continue $sm;
+          case 2:
+            if (!this.q3f_1) {
+              this.ci_1 = 3;
+              suspendResult = this.h3f_1.z4(Companion_getInstance_19().b2h(this.c3f_1, this.d3f_1, withExplanation(this.b3f_1, this.e3f_1)), this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.ci_1 = 4;
+              continue $sm;
+            }
+
+            break;
+          case 3:
+            this.ci_1 = 4;
+            continue $sm;
+          case 4:
+            this.ci_1 = 17;
+            continue $sm;
+          case 5:
+            this.ci_1 = 7;
+            continue $sm;
+          case 6:
+            this.ci_1 = 7;
+            continue $sm;
+          case 7:
+            this.ci_1 = 17;
+            continue $sm;
+          case 8:
+            this.ci_1 = 17;
+            continue $sm;
+          case 9:
+            this.ci_1 = 11;
+            continue $sm;
+          case 10:
+            this.ci_1 = 11;
+            continue $sm;
+          case 11:
+            this.ci_1 = 17;
+            continue $sm;
+          case 12:
+            this.ci_1 = 17;
+            continue $sm;
+          case 13:
+            this.ci_1 = 17;
+            continue $sm;
+          case 14:
+            this.ci_1 = 17;
+            continue $sm;
+          case 15:
+            this.ci_1 = 17;
+            continue $sm;
+          case 16:
+            this.ci_1 = 17;
+            continue $sm;
+          case 17:
+            return Unit_getInstance();
+          case 18:
+            throw this.fi_1;
+        }
+      } catch ($p) {
+        if (this.di_1 === 18) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  ProbHelper$computeAllSubstitutions$slambda.prototype.u2t = function ($this$sequence, completion) {
+    var i = new ProbHelper$computeAllSubstitutions$slambda(this.b3f_1, this.c3f_1, this.d3f_1, this.e3f_1, this.f3f_1, this.g3f_1, completion);
+    i.h3f_1 = $this$sequence;
+    return i;
+  };
+  function ProbHelper$computeAllSubstitutions$slambda_0($goal, $this_computeAllSubstitutions, $third, $first, $second, $goalSignature, resultContinuation) {
+    var i = new ProbHelper$computeAllSubstitutions$slambda($goal, $this_computeAllSubstitutions, $third, $first, $second, $goalSignature, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.t2t($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function ProbHelper() {
+    ProbHelper_instance = this;
+    ProblogLib_getInstance();
+    WithoutSideEffects.call(this, 'prob' + '_helper');
+  }
+  ProbHelper.prototype.r2p = function (_this__u8e3s4, first, second, third) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().n2h(_this__u8e3s4, 1);
+    var goal = safeToStruct(second);
+    var goalSignature = extractSignature(goal);
+    return sequence(ProbHelper$computeAllSubstitutions$slambda_0(goal, _this__u8e3s4, third, first, second, goalSignature, null));
+  };
+  ProbHelper.prototype.n2j = function (_this__u8e3s4, first, second, third) {
+    return this.r2p(_this__u8e3s4, first, second, third);
+  };
+  var ProbHelper_instance;
+  function ProbHelper_getInstance() {
+    if (ProbHelper_instance == null)
+      new ProbHelper();
+    return ProbHelper_instance;
+  }
+  function ProbNegationAsFailure() {
+    ProbNegationAsFailure_instance = this;
+    ProblogLib_getInstance();
+    NonBacktrackable_0.call(this, 'prob' + '_negation_as_failure');
+  }
+  ProbNegationAsFailure.prototype.x2p = function (_this__u8e3s4, first, second) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().n2h(_this__u8e3s4, 1);
+    var tmp;
+    if (!second.jx()) {
+      var tmp_0 = 'Probabilistic negation does not support non-ground goals: ' + second;
+      var tmp_1 = ResolutionException_init_$Create$(tmp_0, null, _this__u8e3s4.context, [], 10, null);
+      tmp = _this__u8e3s4.c2j(tmp_1, null, [], 6, null);
+    } else {
+      var explanationTermVar = Companion_getInstance_1().of('Explanation');
+      var tmp_2 = _this__u8e3s4.subSolver();
+      var tmp_3 = Companion_getInstance_3();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+      var tmp0__get_functor__thl4dk = ProbSolve_getInstance();
+      tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+      var solution = firstOrNull(tmp_2.solveWithOptions(tmp_3.of(tmp$ret$0, [explanationTermVar, second]), setProbabilistic(Companion_getInstance_5().DEFAULT, false)));
+      var tmp_4;
+      if (solution == null) {
+        tmp_4 = _this__u8e3s4.l2g(null, [], 3, null);
+      } else {
+        var explanationTerm = solution.r1u().a3(explanationTermVar);
+        var tmp_5;
+        var tmp_6;
+        if (explanationTerm == null) {
+          tmp_6 = true;
+        } else {
+          tmp_6 = !(explanationTerm instanceof ProbExplanationTerm);
+        }
+        if (tmp_6) {
+          var tmp_7 = 'No valid explanation has been solved for goal: ' + second;
+          var tmp_8 = ResolutionException_init_$Create$(tmp_7, null, _this__u8e3s4.context, [], 10, null);
+          tmp_5 = _this__u8e3s4.c2j(tmp_8, null, [], 6, null);
+        } else {
+          var tmp_9 = Companion_getInstance_9().ofSubstitution(Companion_getInstance_19().b2h(_this__u8e3s4, first, new ProbExplanationTerm(explanationTerm.h3c_1.not())), []);
+          tmp_5 = _this__u8e3s4.g2g(tmp_9, null, [], 6, null);
+        }
+        tmp_4 = tmp_5;
+      }
+      tmp = tmp_4;
+    }
+    return tmp;
+  };
+  ProbNegationAsFailure.prototype.a2g = function (_this__u8e3s4, first, second) {
+    return this.x2p(_this__u8e3s4, first, second);
+  };
+  var ProbNegationAsFailure_instance;
+  function ProbNegationAsFailure_getInstance() {
+    if (ProbNegationAsFailure_instance == null)
+      new ProbNegationAsFailure();
+    return ProbNegationAsFailure_instance;
+  }
+  function ProbQuery$computeAllSubstitutions$slambda$lambda($evidenceExplanation, $queryWithEvidenceExplanation) {
+    return function (v, _anonymous_parameter_1__qggqgd) {
+      return !v.equals($evidenceExplanation) ? !v.equals($queryWithEvidenceExplanation) : false;
+    };
+  }
+  function ProbQuery$computeAllSubstitutions$slambda($solutions, $queryWithEvidenceExplanation, $evidenceExplanation, $this_computeAllSubstitutions, $first, $fourth, resultContinuation) {
+    this.b3g_1 = $solutions;
+    this.c3g_1 = $queryWithEvidenceExplanation;
+    this.d3g_1 = $evidenceExplanation;
+    this.e3g_1 = $this_computeAllSubstitutions;
+    this.f3g_1 = $first;
+    this.g3g_1 = $fourth;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  ProbQuery$computeAllSubstitutions$slambda.prototype.t2t = function ($this$sequence, $cont) {
+    var tmp = this.u2t($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  ProbQuery$computeAllSubstitutions$slambda.prototype.wi = function (p1, $cont) {
+    return this.t2t(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  ProbQuery$computeAllSubstitutions$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 8;
+            this.i3g_1 = this.b3g_1.j();
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.i3g_1.m()) {
+              this.ci_1 = 7;
+              continue $sm;
+            }
+
+            this.j3g_1 = this.i3g_1.p();
+            if (this.j3g_1.f1w())
+              throw ensureNotNull(this.j3g_1.c1w());
+            this.k3g_1 = this.j3g_1.r1u().a3(this.c3g_1);
+            this.l3g_1 = this.j3g_1.r1u().a3(this.d3g_1);
+            var tmp_0;
+            var tmp_1;
+            var tmp_2;
+            if (this.k3g_1 == null) {
+              tmp_2 = true;
+            } else {
+              var tmp_3 = this.k3g_1;
+              tmp_2 = !(tmp_3 instanceof ProbExplanationTerm);
+            }
+
+            if (tmp_2) {
+              tmp_1 = true;
+            } else {
+              tmp_1 = this.l3g_1 == null;
+            }
+
+            if (tmp_1) {
+              tmp_0 = true;
+            } else {
+              var tmp_4 = this.l3g_1;
+              tmp_0 = !(tmp_4 instanceof ProbExplanationTerm);
+            }
+
+            if (tmp_0) {
+              this.ci_1 = 5;
+              suspendResult = this.h3g_1.z4(Companion_getInstance_9().failed(), this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.m3g_1 = this.k3g_1.h3c_1.y3d();
+              this.n3g_1 = this.l3g_1.h3c_1.y3d();
+              if (this.m3g_1 == null ? true : this.n3g_1 == null) {
+                this.ci_1 = 3;
+                suspendResult = this.h3g_1.z4(Companion_getInstance_9().failed(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+                continue $sm;
+              } else {
+                var tmp_5 = this;
+                var tmp_6 = this.j3g_1.r1u();
+                tmp_5.o3g_1 = tmp_6.filter(ProbQuery$computeAllSubstitutions$slambda$lambda(this.d3g_1, this.c3g_1));
+                this.p3g_1 = Companion_getInstance_10().ofDouble(this.m3g_1 / this.n3g_1);
+                this.ci_1 = 2;
+                suspendResult = this.h3g_1.z4(Companion_getInstance_9().ofSubstitution(this.o3g_1, [Companion_getInstance_19().b2h(this.e3g_1, this.f3g_1, this.p3g_1), Companion_getInstance_19().b2h(this.e3g_1, this.g3g_1, this.k3g_1)]), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+                continue $sm;
+              }
+            }
+
+            break;
+          case 2:
+            this.ci_1 = 4;
+            continue $sm;
+          case 3:
+            this.ci_1 = 4;
+            continue $sm;
+          case 4:
+            this.ci_1 = 6;
+            continue $sm;
+          case 5:
+            this.ci_1 = 6;
+            continue $sm;
+          case 6:
+            this.ci_1 = 1;
+            continue $sm;
+          case 7:
+            return Unit_getInstance();
+          case 8:
+            throw this.fi_1;
+        }
+      } catch ($p) {
+        if (this.di_1 === 8) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  ProbQuery$computeAllSubstitutions$slambda.prototype.u2t = function ($this$sequence, completion) {
+    var i = new ProbQuery$computeAllSubstitutions$slambda(this.b3g_1, this.c3g_1, this.d3g_1, this.e3g_1, this.f3g_1, this.g3g_1, completion);
+    i.h3g_1 = $this$sequence;
+    return i;
+  };
+  function ProbQuery$computeAllSubstitutions$slambda_0($solutions, $queryWithEvidenceExplanation, $evidenceExplanation, $this_computeAllSubstitutions, $first, $fourth, resultContinuation) {
+    var i = new ProbQuery$computeAllSubstitutions$slambda($solutions, $queryWithEvidenceExplanation, $evidenceExplanation, $this_computeAllSubstitutions, $first, $fourth, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.t2t($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function ProbQuery() {
+    ProbQuery_instance = this;
+    ProblogLib_getInstance();
+    WithoutSideEffects_0.call(this, 'prob' + '_query');
+  }
+  ProbQuery.prototype.r3g = function (_this__u8e3s4, first, second, third, fourth) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().n2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().l2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().h2h(_this__u8e3s4, 2);
+    var queryWithEvidenceExplanation = Companion_getInstance_1().of('QueryWithEvidenceExplanation');
+    var evidenceExplanation = Companion_getInstance_1().of('EvidenceExplanation');
+    var tmp = _this__u8e3s4.subSolver();
+    var tmp_0 = Companion_getInstance_2();
+    var tmp_1 = Companion_getInstance_3();
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp0__get_functor__thl4dk = ProbSetConfig_getInstance();
+    tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+    var tmp_2 = tmp_1.of(tmp$ret$0, [third]);
+    var tmp_3 = Companion_getInstance_3();
+    var tmp$ret$1;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp1__get_functor__4k11yf = ProbSolveWithEvidence_getInstance();
+    tmp$ret$1 = tmp1__get_functor__4k11yf.signature.name;
+    var solutions = tmp.solveWithOptions(tmp_0.of(tmp_2, tmp_3.of(tmp$ret$1, [queryWithEvidenceExplanation, evidenceExplanation, second])), ProbSetConfig_getInstance().s3g(third));
+    return sequence(ProbQuery$computeAllSubstitutions$slambda_0(solutions, queryWithEvidenceExplanation, evidenceExplanation, _this__u8e3s4, first, fourth, null));
+  };
+  ProbQuery.prototype.d2i = function (_this__u8e3s4, first, second, third, fourth) {
+    return this.r3g(_this__u8e3s4, first, second, third, fourth);
+  };
+  var ProbQuery_instance;
+  function ProbQuery_getInstance() {
+    if (ProbQuery_instance == null)
+      new ProbQuery();
+    return ProbQuery_instance;
+  }
+  function ProbSetConfig() {
+    ProbSetConfig_instance = this;
+    ProblogLib_getInstance();
+    NonBacktrackable_1.call(this, 'prob' + '_set_config');
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    tmp$ret$0 = this.signature.name;
+    tmp.d3c_1 = tmp$ret$0 + '_flag';
+    var tmp_0 = this;
+    var tmp$ret$1;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    tmp$ret$1 = this.signature.name;
+    tmp_0.e3c_1 = tmp$ret$1 + '_term';
+    var tmp_1 = this;
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    tmp$ret$2 = this.signature.name;
+    tmp_1.f3c_1 = 'it.unibo.tuprolog.solve.probability' + tmp$ret$2 + '_tag';
+  }
+  ProbSetConfig.prototype.g2p = function (_this__u8e3s4, first) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 0);
+    Companion_getInstance_19().q2h(_this__u8e3s4, 0);
+    var tmp$ret$2;
+    // Inline function 'kotlin.arrayOf' call
+    var tmp0_arrayOf = [SetFlags_init_$Create$([new Pair(this.d3c_1, first)])];
+    var tmp$ret$1;
+    // Inline function 'kotlin.js.unsafeCast' call
+    var tmp$ret$0;
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp$ret$0 = tmp0_arrayOf;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return _this__u8e3s4.m2g(null, null, tmp$ret$2.slice(), 3, null);
+  };
+  ProbSetConfig.prototype.a2k = function (_this__u8e3s4, first) {
+    return this.g2p(_this__u8e3s4, first);
+  };
+  ProbSetConfig.prototype.s3g = function (_this__u8e3s4) {
+    var tmp0_elvis_lhs = _this__u8e3s4.getTag(this.f3c_1);
+    return tmp0_elvis_lhs == null ? Companion_getInstance_5().DEFAULT : tmp0_elvis_lhs;
+  };
+  ProbSetConfig.prototype.g3c = function (_this__u8e3s4) {
+    return setTag(Companion_getInstance_8().of(this.e3c_1), this.f3c_1, _this__u8e3s4);
+  };
+  ProbSetConfig.prototype.t3g = function (_this__u8e3s4) {
+    var tmp0_safe_receiver = _this__u8e3s4.x1u().o9(this.d3c_1);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : this.s3g(tmp0_safe_receiver);
+    return tmp1_elvis_lhs == null ? Companion_getInstance_5().DEFAULT : tmp1_elvis_lhs;
+  };
+  ProbSetConfig.prototype.s3e = function (_this__u8e3s4) {
+    return !get_isProbabilistic(this.t3g(_this__u8e3s4));
+  };
+  var ProbSetConfig_instance;
+  function ProbSetConfig_getInstance() {
+    if (ProbSetConfig_instance == null)
+      new ProbSetConfig();
+    return ProbSetConfig_instance;
+  }
+  function ProbSolve$computeAllSubstitutions$lambda(it) {
+    if (it.f1w())
+      throw ensureNotNull(it.c1w());
+    return it.r1u();
+  }
+  function ProbSolve$computeAllSubstitutions$lambda_0(it) {
+    return !(it == null) ? isInterface(it, Halt) : false;
+  }
+  function ProbSolve$computeAllSubstitutions$lambda_1($explanationVar) {
+    return function (v, _anonymous_parameter_1__qggqgd) {
+      return !v.equals($explanationVar);
+    };
+  }
+  function ProbSolve$computeAllSubstitutions$slambda($solutionGroups, $explanationVar, $this_computeAllSubstitutions, $first, resultContinuation) {
+    this.c3h_1 = $solutionGroups;
+    this.d3h_1 = $explanationVar;
+    this.e3h_1 = $this_computeAllSubstitutions;
+    this.f3h_1 = $first;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  ProbSolve$computeAllSubstitutions$slambda.prototype.t2t = function ($this$sequence, $cont) {
+    var tmp = this.u2t($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  ProbSolve$computeAllSubstitutions$slambda.prototype.wi = function (p1, $cont) {
+    return this.t2t(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  ProbSolve$computeAllSubstitutions$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 4;
+            var tmp_0 = this;
+            tmp_0.h3h_1 = this.c3h_1.z().j();
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.h3h_1.m()) {
+              this.ci_1 = 3;
+              continue $sm;
+            }
+
+            this.i3h_1 = this.h3h_1.p();
+            var tmp_1 = this;
+            var tmp0_map = this.i3h_1.b1();
+            var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+            var tmp0_iterator = tmp0_map.j();
+            while (tmp0_iterator.m()) {
+              var item = tmp0_iterator.p();
+              tmp0_mapTo.g(item.r1u().a3(this.d3h_1));
+            }
+
+            var tmp1_filterIsInstance = tmp0_mapTo;
+            var tmp0_filterIsInstanceTo = ArrayList_init_$Create$_0();
+            var tmp0_iterator_0 = tmp1_filterIsInstance.j();
+            while (tmp0_iterator_0.m()) {
+              var element = tmp0_iterator_0.p();
+              if (element instanceof ProbExplanationTerm) {
+                tmp0_filterIsInstanceTo.g(element);
+              }
+            }
+
+            var tmp2_map = tmp0_filterIsInstanceTo;
+            var tmp0_mapTo_0 = ArrayList_init_$Create$(collectionSizeOrDefault(tmp2_map, 10));
+            var tmp0_iterator_1 = tmp2_map.j();
+            while (tmp0_iterator_1.m()) {
+              var item_0 = tmp0_iterator_1.p();
+              tmp0_mapTo_0.g(item_0.h3c_1);
+            }
+
+            var tmp3_reduce = tmp0_mapTo_0;
+            var iterator = tmp3_reduce.j();
+            if (!iterator.m())
+              throw UnsupportedOperationException_init_$Create$("Empty collection can't be reduced.");
+            var accumulator = iterator.p();
+            while (iterator.m()) {
+              var tmp4__anonymous__pkmkx7 = accumulator;
+              var tmp5__anonymous__kpxxpo = iterator.p();
+              accumulator = tmp5__anonymous__kpxxpo.x3d() === 1.0 ? tmp4__anonymous__pkmkx7 : tmp4__anonymous__pkmkx7.x3d() === 1.0 ? tmp5__anonymous__kpxxpo : tmp4__anonymous__pkmkx7.or(tmp5__anonymous__kpxxpo);
+            }
+
+            tmp_1.j3h_1 = accumulator;
+            this.k3h_1 = Companion_getInstance_9().ofSubstitution(this.i3h_1.a1(), [Companion_getInstance_19().b2h(this.e3h_1, this.f3h_1, new ProbExplanationTerm(this.j3h_1))]);
+            this.ci_1 = 2;
+            suspendResult = this.g3h_1.z4(this.k3h_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.ci_1 = 1;
+            continue $sm;
+          case 3:
+            return Unit_getInstance();
+          case 4:
+            throw this.fi_1;
+        }
+      } catch ($p) {
+        if (this.di_1 === 4) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  ProbSolve$computeAllSubstitutions$slambda.prototype.u2t = function ($this$sequence, completion) {
+    var i = new ProbSolve$computeAllSubstitutions$slambda(this.c3h_1, this.d3h_1, this.e3h_1, this.f3h_1, completion);
+    i.g3h_1 = $this$sequence;
+    return i;
+  };
+  function ProbSolve$computeAllSubstitutions$slambda_0($solutionGroups, $explanationVar, $this_computeAllSubstitutions, $first, resultContinuation) {
+    var i = new ProbSolve$computeAllSubstitutions$slambda($solutionGroups, $explanationVar, $this_computeAllSubstitutions, $first, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.t2t($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function ProbSolve() {
+    ProbSolve_instance = this;
+    ProblogLib_getInstance();
+    WithoutSideEffects_1.call(this, 'prob' + '_solve');
+  }
+  ProbSolve.prototype.w2q = function (_this__u8e3s4, first, second) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 1);
+    Companion_getInstance_19().n2h(_this__u8e3s4, 1);
+    if (ProbSetConfig_getInstance().s3e(_this__u8e3s4.context)) {
+      var tmp = _this__u8e3s4.subSolver();
+      var tmp_0 = Companion_getInstance_3();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+      var tmp0__get_functor__thl4dk = Prob_getInstance();
+      tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+      var tmp_1 = tmp.solveWithOptions(tmp_0.of(tmp$ret$0, [first, second]), ProbSetConfig_getInstance().t3g(_this__u8e3s4.context));
+      return map(tmp_1, ProbSolve$computeAllSubstitutions$lambda);
+    }
+    var tmp_2 = Companion_getInstance_1();
+    ProblogLib_getInstance();
+    var explanationVar = tmp_2.of('EXPL');
+    var tmp_3 = _this__u8e3s4.subSolver();
+    var tmp_4 = Companion_getInstance_3();
+    var tmp$ret$1;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp1__get_functor__4k11yf = Prob_getInstance();
+    tmp$ret$1 = tmp1__get_functor__4k11yf.signature.name;
+    var solutions = toList(tmp_3.solveWithOptions(tmp_4.of(tmp$ret$1, [explanationVar, second]), ProbSetConfig_getInstance().t3g(_this__u8e3s4.context)));
+    var tmp$ret$2;
+    // Inline function 'kotlin.sequences.filterIsInstance' call
+    var tmp2_filterIsInstance = asSequence(solutions);
+    var tmp_5 = filter(tmp2_filterIsInstance, ProbSolve$computeAllSubstitutions$lambda_0);
+    tmp$ret$2 = isInterface(tmp_5, Sequence) ? tmp_5 : THROW_CCE();
+    var error = firstOrNull(tmp$ret$2);
+    if (!(error == null))
+      throw error.c1w();
+    var tmp_6;
+    var tmp$ret$3;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.any' call
+      var tmp_7;
+      if (isInterface(solutions, Collection)) {
+        tmp_7 = solutions.d();
+      } else {
+        tmp_7 = false;
+      }
+      if (tmp_7) {
+        tmp$ret$3 = false;
+        break $l$block_0;
+      }
+      var tmp0_iterator = solutions.j();
+      while (tmp0_iterator.m()) {
+        var element = tmp0_iterator.p();
+        var tmp$ret$4;
+        // Inline function 'it.unibo.tuprolog.solve.problog.lib.primitive.ProbSolve.computeAllSubstitutions.<anonymous>' call
+        tmp$ret$4 = isInterface(element, Yes);
+        if (tmp$ret$4) {
+          tmp$ret$3 = true;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$3 = false;
+    }
+    if (!tmp$ret$3) {
+      tmp_6 = sequenceOf([Companion_getInstance_9().ofSubstitution(Companion_getInstance_19().b2h(_this__u8e3s4, first, new ProbExplanationTerm(Companion_getInstance_21().k3d_1)), [])]);
+    } else {
+      var tmp$ret$11;
+      // Inline function 'kotlin.collections.groupBy' call
+      var tmp$ret$6;
+      // Inline function 'kotlin.collections.filterIsInstance' call
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.filterIsInstanceTo' call
+      var tmp0_filterIsInstanceTo = ArrayList_init_$Create$_0();
+      var tmp0_iterator_0 = solutions.j();
+      while (tmp0_iterator_0.m()) {
+        var element_0 = tmp0_iterator_0.p();
+        if (!(element_0 == null) ? isInterface(element_0, Yes) : false) {
+          tmp0_filterIsInstanceTo.g(element_0);
+        }
+      }
+      tmp$ret$5 = tmp0_filterIsInstanceTo;
+      tmp$ret$6 = tmp$ret$5;
+      var tmp3_groupBy = tmp$ret$6;
+      var tmp$ret$10;
+      // Inline function 'kotlin.collections.groupByTo' call
+      var tmp0_groupByTo = LinkedHashMap_init_$Create$();
+      var tmp0_iterator_1 = tmp3_groupBy.j();
+      while (tmp0_iterator_1.m()) {
+        var element_1 = tmp0_iterator_1.p();
+        var tmp$ret$7;
+        // Inline function 'it.unibo.tuprolog.solve.problog.lib.primitive.ProbSolve.computeAllSubstitutions.<anonymous>' call
+        var tmp_8 = element_1.r1u();
+        tmp$ret$7 = tmp_8.l12(ProbSolve$computeAllSubstitutions$lambda_1(explanationVar));
+        var key = tmp$ret$7;
+        var tmp$ret$9;
+        // Inline function 'kotlin.collections.getOrPut' call
+        var value = tmp0_groupByTo.a3(key);
+        var tmp_9;
+        if (value == null) {
+          var tmp$ret$8;
+          // Inline function 'kotlin.collections.groupByTo.<anonymous>' call
+          tmp$ret$8 = ArrayList_init_$Create$_0();
+          var answer = tmp$ret$8;
+          tmp0_groupByTo.w3(key, answer);
+          tmp_9 = answer;
+        } else {
+          tmp_9 = value;
+        }
+        tmp$ret$9 = tmp_9;
+        var list = tmp$ret$9;
+        list.g(element_1);
+      }
+      tmp$ret$10 = tmp0_groupByTo;
+      tmp$ret$11 = tmp$ret$10;
+      var solutionGroups = tmp$ret$11;
+      tmp_6 = sequence(ProbSolve$computeAllSubstitutions$slambda_0(solutionGroups, explanationVar, _this__u8e3s4, first, null));
+    }
+    return tmp_6;
+  };
+  ProbSolve.prototype.i2g = function (_this__u8e3s4, first, second) {
+    return this.w2q(_this__u8e3s4, first, second);
+  };
+  var ProbSolve_instance;
+  function ProbSolve_getInstance() {
+    if (ProbSolve_instance == null)
+      new ProbSolve();
+    return ProbSolve_instance;
+  }
+  function ProbSolveEvidence$computeOne$lambda(it) {
+    return !(it == null) ? isInterface(it, Yes) : false;
+  }
+  function ProbSolveEvidence$computeOne$lambda_0($explanationVar) {
+    return function (s) {
+      return s.r1u().a3($explanationVar);
+    };
+  }
+  function ProbSolveEvidence$computeOne$lambda_1(it) {
+    return it instanceof ProbExplanationTerm;
+  }
+  function ProbSolveEvidence$computeOne$lambda_2(t) {
+    return t.h3c_1;
+  }
+  function ProbSolveEvidence() {
+    ProbSolveEvidence_instance = this;
+    ProblogLib_getInstance();
+    NonBacktrackable_1.call(this, 'prob' + '_solve_evidence');
+  }
+  ProbSolveEvidence.prototype.g2p = function (_this__u8e3s4, first) {
+    var tmp = Companion_getInstance_13();
+    ProblogLib_getInstance();
+    var evidenceIndicator = tmp.ofString('evidence', 2);
+    if (!_this__u8e3s4.context.y1u().containsIndicator(evidenceIndicator) ? !_this__u8e3s4.context.z1u().containsIndicator(evidenceIndicator) : false) {
+      var tmp_0 = Companion_getInstance_19().b2h(_this__u8e3s4, first, new ProbExplanationTerm(Companion_getInstance_21().l3d_1));
+      return _this__u8e3s4.g2g(tmp_0, null, [], 6, null);
+    }
+    var evidenceTermVar = Companion_getInstance_1().of('TermVar');
+    var evidenceTruthVar = Companion_getInstance_1().of('TruthVar');
+    var tmp_1 = Companion_getInstance_3();
+    ProblogLib_getInstance();
+    var subQuery = tmp_1.of('evidence', [evidenceTermVar, evidenceTruthVar]);
+    var tmp_2 = ProbSetConfig_getInstance().t3g(_this__u8e3s4.context);
+    Companion_getInstance_5();
+    var subOptions = tmp_2.setLimit(-1).setLazy(false);
+    var tmp$ret$10;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp$ret$7;
+    // Inline function 'kotlin.collections.map' call
+    var tmp$ret$0;
+    // Inline function 'kotlin.sequences.filterIsInstance' call
+    var tmp0_filterIsInstance = _this__u8e3s4.subSolver().solveWithOptions(subQuery, subOptions);
+    var tmp_3 = filter(tmp0_filterIsInstance, ProbSolveEvidence$computeOne$lambda);
+    tmp$ret$0 = isInterface(tmp_3, Sequence) ? tmp_3 : THROW_CCE();
+    var tmp1_map = toList(tmp$ret$0);
+    var tmp$ret$6;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp1_map, 10));
+    var tmp0_iterator = tmp1_map.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$5;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.primitive.ProbSolveEvidence.computeOne.<anonymous>' call
+      var truth = item.r1u().a3(evidenceTruthVar);
+      var term = item.r1u().a3(evidenceTermVar);
+      var tmp_4;
+      var tmp_5;
+      if ((term == null ? true : term.bx()) ? true : truth == null) {
+        tmp_5 = true;
+      } else {
+        tmp_5 = !(!(truth == null) ? isInterface(truth, Truth) : false);
+      }
+      if (tmp_5) {
+        tmp_4 = Companion_getInstance_21().k3d_1;
+      } else {
+        var tmp_6 = Companion_getInstance_1();
+        ProblogLib_getInstance();
+        var explanationVar = tmp_6.of('EXPL');
+        var tmp$ret$4;
+        // Inline function 'kotlin.sequences.reduce' call
+        var tmp$ret$2;
+        // Inline function 'kotlin.sequences.filterIsInstance' call
+        var tmp_7 = Companion_getInstance_3();
+        var tmp$ret$1;
+        // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+        var tmp0__get_functor__thl4dk = ProbSolve_getInstance();
+        tmp$ret$1 = tmp0__get_functor__thl4dk.signature.name;
+        var tmp_8 = tmp_7.of(tmp$ret$1, [explanationVar, term]);
+        var tmp_9 = _this__u8e3s4.e2j(tmp_8, new Long(0, 0), 2, null);
+        var tmp1_filterIsInstance = map(tmp_9, ProbSolveEvidence$computeOne$lambda_0(explanationVar));
+        var tmp_10 = filter(tmp1_filterIsInstance, ProbSolveEvidence$computeOne$lambda_1);
+        tmp$ret$2 = isInterface(tmp_10, Sequence) ? tmp_10 : THROW_CCE();
+        var tmp_11 = tmp$ret$2;
+        var tmp2_reduce = map(tmp_11, ProbSolveEvidence$computeOne$lambda_2);
+        var iterator = tmp2_reduce.j();
+        if (!iterator.m())
+          throw UnsupportedOperationException_init_$Create$("Empty sequence can't be reduced.");
+        var accumulator = iterator.p();
+        while (iterator.m()) {
+          var tmp$ret$3;
+          // Inline function 'it.unibo.tuprolog.solve.problog.lib.primitive.ProbSolveEvidence.computeOne.<anonymous>.<anonymous>' call
+          var tmp3__anonymous__ufb84q = accumulator;
+          var tmp4__anonymous__pkmkx7 = iterator.p();
+          tmp$ret$3 = tmp4__anonymous__pkmkx7.x3d() === 1.0 ? tmp3__anonymous__ufb84q : tmp3__anonymous__ufb84q.x3d() === 1.0 ? tmp4__anonymous__pkmkx7 : tmp4__anonymous__pkmkx7.or(tmp3__anonymous__ufb84q);
+          accumulator = tmp$ret$3;
+        }
+        tmp$ret$4 = accumulator;
+        var totalExplanation = tmp$ret$4;
+        tmp_4 = truth.dw() ? totalExplanation : totalExplanation.not();
+      }
+      tmp$ret$5 = tmp_4;
+      tmp0_mapTo.g(tmp$ret$5);
+    }
+    tmp$ret$6 = tmp0_mapTo;
+    tmp$ret$7 = tmp$ret$6;
+    var tmp2_filter = tmp$ret$7;
+    var tmp$ret$9;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$_0();
+    var tmp0_iterator_0 = tmp2_filter.j();
+    while (tmp0_iterator_0.m()) {
+      var element = tmp0_iterator_0.p();
+      var tmp$ret$8;
+      // Inline function 'it.unibo.tuprolog.solve.problog.lib.primitive.ProbSolveEvidence.computeOne.<anonymous>' call
+      tmp$ret$8 = !equals(element, Companion_getInstance_21().k3d_1);
+      if (tmp$ret$8) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$9 = tmp0_filterTo;
+    tmp$ret$10 = tmp$ret$9;
+    var result = tmp$ret$10;
+    var tmp_12;
+    if (result.d()) {
+      tmp_12 = Companion_getInstance_21().l3d_1;
+    } else {
+      var tmp$ret$12;
+      // Inline function 'kotlin.collections.reduce' call
+      var iterator_0 = result.j();
+      if (!iterator_0.m())
+        throw UnsupportedOperationException_init_$Create$("Empty collection can't be reduced.");
+      var accumulator_0 = iterator_0.p();
+      while (iterator_0.m()) {
+        var tmp$ret$11;
+        // Inline function 'it.unibo.tuprolog.solve.problog.lib.primitive.ProbSolveEvidence.computeOne.<anonymous>' call
+        var tmp3__anonymous__ufb84q_0 = accumulator_0;
+        var tmp4__anonymous__pkmkx7_0 = iterator_0.p();
+        tmp$ret$11 = tmp4__anonymous__pkmkx7_0.and(tmp3__anonymous__ufb84q_0);
+        accumulator_0 = tmp$ret$11;
+      }
+      tmp$ret$12 = accumulator_0;
+      tmp_12 = tmp$ret$12;
+    }
+    var resultExplanation = tmp_12;
+    var tmp_13 = Companion_getInstance_19().b2h(_this__u8e3s4, first, new ProbExplanationTerm(resultExplanation));
+    return _this__u8e3s4.g2g(tmp_13, null, [], 6, null);
+  };
+  ProbSolveEvidence.prototype.a2k = function (_this__u8e3s4, first) {
+    return this.g2p(_this__u8e3s4, first);
+  };
+  var ProbSolveEvidence_instance;
+  function ProbSolveEvidence_getInstance() {
+    if (ProbSolveEvidence_instance == null)
+      new ProbSolveEvidence();
+    return ProbSolveEvidence_instance;
+  }
+  function ProbSolveWithEvidence$computeAllSubstitutions$slambda$lambda($goalExplanationVar) {
+    return function (v, _anonymous_parameter_1__qggqgd) {
+      return !v.equals($goalExplanationVar);
+    };
+  }
+  function ProbSolveWithEvidence$computeAllSubstitutions$slambda($solutions, $goalExplanationVar, $evidenceExplanationTerm, $this_computeAllSubstitutions, $first, $second, resultContinuation) {
+    this.v3h_1 = $solutions;
+    this.w3h_1 = $goalExplanationVar;
+    this.x3h_1 = $evidenceExplanationTerm;
+    this.y3h_1 = $this_computeAllSubstitutions;
+    this.z3h_1 = $first;
+    this.a3i_1 = $second;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  ProbSolveWithEvidence$computeAllSubstitutions$slambda.prototype.t2t = function ($this$sequence, $cont) {
+    var tmp = this.u2t($this$sequence, $cont);
+    tmp.ei_1 = Unit_getInstance();
+    tmp.fi_1 = null;
+    return tmp.ki();
+  };
+  ProbSolveWithEvidence$computeAllSubstitutions$slambda.prototype.wi = function (p1, $cont) {
+    return this.t2t(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $cont);
+  };
+  ProbSolveWithEvidence$computeAllSubstitutions$slambda.prototype.ki = function () {
+    var suspendResult = this.ei_1;
+    $sm: do
+      try {
+        var tmp = this.ci_1;
+        switch (tmp) {
+          case 0:
+            this.di_1 = 6;
+            this.c3i_1 = this.v3h_1.j();
+            this.ci_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.c3i_1.m()) {
+              this.ci_1 = 5;
+              continue $sm;
+            }
+
+            this.d3i_1 = this.c3i_1.p();
+            if (this.d3i_1.f1w())
+              throw ensureNotNull(this.d3i_1.c1w());
+            this.e3i_1 = this.d3i_1.r1u().a3(this.w3h_1);
+            var tmp_0;
+            var tmp_1;
+            var tmp_2;
+            if (this.x3h_1 == null) {
+              tmp_2 = true;
+            } else {
+              var tmp_3 = this.x3h_1;
+              tmp_2 = !(tmp_3 instanceof ProbExplanationTerm);
+            }
+
+            if (tmp_2) {
+              tmp_1 = true;
+            } else {
+              tmp_1 = this.e3i_1 == null;
+            }
+
+            if (tmp_1) {
+              tmp_0 = true;
+            } else {
+              var tmp_4 = this.e3i_1;
+              tmp_0 = !(tmp_4 instanceof ProbExplanationTerm);
+            }
+
+            if (tmp_0) {
+              this.ci_1 = 3;
+              suspendResult = this.b3i_1.z4(Companion_getInstance_9().failed(), this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.f3i_1 = new ProbExplanationTerm(this.e3i_1.h3c_1.and(this.x3h_1.h3c_1));
+              this.ci_1 = 2;
+              var tmp_5 = Companion_getInstance_9();
+              var tmp_6 = Companion_getInstance_19().b2h(this.y3h_1, this.z3h_1, this.f3i_1);
+              var tmp_7 = Companion_getInstance_19().b2h(this.y3h_1, this.a3i_1, this.x3h_1);
+              var tmp_8 = this.d3i_1.r1u();
+              suspendResult = this.b3i_1.z4(tmp_5.ofSubstitution(tmp_6, [tmp_7, tmp_8.filter(ProbSolveWithEvidence$computeAllSubstitutions$slambda$lambda(this.w3h_1))]), this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            }
+
+            break;
+          case 2:
+            this.ci_1 = 4;
+            continue $sm;
+          case 3:
+            this.ci_1 = 4;
+            continue $sm;
+          case 4:
+            this.ci_1 = 1;
+            continue $sm;
+          case 5:
+            return Unit_getInstance();
+          case 6:
+            throw this.fi_1;
+        }
+      } catch ($p) {
+        if (this.di_1 === 6) {
+          throw $p;
+        } else {
+          this.ci_1 = this.di_1;
+          this.fi_1 = $p;
+        }
+      }
+     while (true);
+  };
+  ProbSolveWithEvidence$computeAllSubstitutions$slambda.prototype.u2t = function ($this$sequence, completion) {
+    var i = new ProbSolveWithEvidence$computeAllSubstitutions$slambda(this.v3h_1, this.w3h_1, this.x3h_1, this.y3h_1, this.z3h_1, this.a3i_1, completion);
+    i.b3i_1 = $this$sequence;
+    return i;
+  };
+  function ProbSolveWithEvidence$computeAllSubstitutions$slambda_0($solutions, $goalExplanationVar, $evidenceExplanationTerm, $this_computeAllSubstitutions, $first, $second, resultContinuation) {
+    var i = new ProbSolveWithEvidence$computeAllSubstitutions$slambda($solutions, $goalExplanationVar, $evidenceExplanationTerm, $this_computeAllSubstitutions, $first, $second, resultContinuation);
+    var l = function ($this$sequence, $cont) {
+      return i.t2t($this$sequence, $cont);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function ProbSolveWithEvidence() {
+    ProbSolveWithEvidence_instance = this;
+    ProblogLib_getInstance();
+    WithoutSideEffects.call(this, 'prob' + '_solve_with_evidence');
+  }
+  ProbSolveWithEvidence.prototype.r2p = function (_this__u8e3s4, first, second, third) {
+    Companion_getInstance_19().h2h(_this__u8e3s4, 2);
+    Companion_getInstance_19().n2h(_this__u8e3s4, 2);
+    var evidenceExplanationVar = Companion_getInstance_1().of('EvidenceExplanation');
+    var tmp;
+    if (ProbSetConfig_getInstance().s3e(_this__u8e3s4.context)) {
+      tmp = toTerm(Companion_getInstance_21().l3d_1);
+    } else {
+      var tmp_0 = Companion_getInstance_3();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+      var tmp0__get_functor__thl4dk = ProbSolveEvidence_getInstance();
+      tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+      var subQuery = tmp_0.of(tmp$ret$0, [evidenceExplanationVar]);
+      var solution = _this__u8e3s4.subSolver().solveOnceWithOptions(subQuery, ProbSetConfig_getInstance().t3g(_this__u8e3s4.context));
+      tmp = solution.r1u().a3(evidenceExplanationVar);
+    }
+    var evidenceExplanationTerm = tmp;
+    var goalExplanationVar = Companion_getInstance_1().of('GoalExplanation');
+    var tmp_1 = _this__u8e3s4.subSolver();
+    var tmp_2 = Companion_getInstance_3();
+    var tmp$ret$1;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp1__get_functor__4k11yf = ProbSolve_getInstance();
+    tmp$ret$1 = tmp1__get_functor__4k11yf.signature.name;
+    var solutions = tmp_1.solveWithOptions(tmp_2.of(tmp$ret$1, [goalExplanationVar, third]), ProbSetConfig_getInstance().t3g(_this__u8e3s4.context));
+    return sequence(ProbSolveWithEvidence$computeAllSubstitutions$slambda_0(solutions, goalExplanationVar, evidenceExplanationTerm, _this__u8e3s4, first, second, null));
+  };
+  ProbSolveWithEvidence.prototype.n2j = function (_this__u8e3s4, first, second, third) {
+    return this.r2p(_this__u8e3s4, first, second, third);
+  };
+  var ProbSolveWithEvidence_instance;
+  function ProbSolveWithEvidence_getInstance() {
+    if (ProbSolveWithEvidence_instance == null)
+      new ProbSolveWithEvidence();
+    return ProbSolveWithEvidence_instance;
+  }
+  function Prob() {
+    Prob_instance = this;
+    ProblogLib_getInstance();
+    RuleWrapper_init_$Init$('prob', 2, false, 4, null, this);
+  }
+  Prob.prototype.g2k = function (_this__u8e3s4) {
+    return _this__u8e3s4.ktListOf([_this__u8e3s4.varOf('EXPL'), _this__u8e3s4.varOf('GOAL')]);
+  };
+  Prob.prototype.h2k = function (_this__u8e3s4) {
+    var expl = _this__u8e3s4.varOf('EXPL');
+    var goal = _this__u8e3s4.varOf('GOAL');
+    var newGoal = _this__u8e3s4.varOf('NEW_GOAL');
+    var tmp = _this__u8e3s4.atomOf('!');
+    var tmp_0 = _this__u8e3s4.structOf('ensure_executable', [goal]);
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.functor' call
+    var tmp0__get_functor__thl4dk = ProbHelper_getInstance();
+    tmp$ret$0 = tmp0__get_functor__thl4dk.signature.name;
+    return _this__u8e3s4.tupleOf([tmp, tmp_0, _this__u8e3s4.structOf(tmp$ret$0, [expl, goal, newGoal]), newGoal]);
+  };
+  var Prob_instance;
+  function Prob_getInstance() {
+    if (Prob_instance == null)
+      new Prob();
+    return Prob_instance;
+  }
+  //region block: post-declaration
+  ProblogSolver.prototype.x1x = copy$default;
+  MutableProblogSolver.prototype.x1x = copy$default;
+  MutableProblogSolver.prototype.loadStaticClauses = loadStaticClauses;
+  MutableProblogSolver.prototype.loadStaticClausesIterable = loadStaticClausesIterable;
+  MutableProblogSolver.prototype.loadStaticClausesSequence = loadStaticClausesSequence;
+  MutableProblogSolver.prototype.loadDynamicClauses = loadDynamicClauses;
+  MutableProblogSolver.prototype.loadDynamicClausesIterable = loadDynamicClausesIterable;
+  MutableProblogSolver.prototype.loadDynamicClausesSequence = loadDynamicClausesSequence;
+  ProblogSolverFactory.prototype.u1y = solverOf$default;
+  ProblogSolverFactory.prototype.w1y = solverOf$default_0;
+  ProblogSolverFactory.prototype.a1z = mutableSolverOf$default;
+  ProblogSolverFactory.prototype.e1z = mutableSolverOf$default_0;
+  ProblogSolverFactory.prototype.newBuilder = newBuilder;
+  ProblogSolverFactory.prototype.c1y = get_defaultRuntime;
+  ProblogSolverFactory.prototype.e1y = get_defaultUnificator;
+  ProblogSolverFactory.prototype.i1y = get_defaultStaticKb;
+  ProblogSolverFactory.prototype.j1y = get_defaultDynamicKb;
+  ProblogSolverFactory.prototype.k1y = get_defaultInputChannel;
+  ProblogSolverFactory.prototype.l1y = get_defaultOutputChannel;
+  ProblogSolverFactory.prototype.m1y = get_defaultErrorChannel;
+  ProblogSolverFactory.prototype.n1y = get_defaultWarningsChannel;
+  ProblogSolverFactory.prototype.x1y = solverWithDefaultBuiltins;
+  ProblogSolverFactory.prototype.y1y = solverWithDefaultBuiltins$default;
+  ProblogSolverFactory.prototype.b1z = mutableSolverWithDefaultBuiltins;
+  ProblogSolverFactory.prototype.c1z = mutableSolverWithDefaultBuiltins$default;
+  DefaultBuiltins.prototype.containsSignature = containsSignature;
+  DefaultBuiltins.prototype.containsOperator = containsOperator;
+  DefaultBuiltins.prototype.hasPrimitive = hasPrimitive;
+  DefaultBuiltins.prototype.hasFunction = hasFunction;
+  DefaultBuiltins.prototype.j2e = get_ruleSignatures;
+  DefaultBuiltins.prototype.hasProtected = hasProtected;
+  MinimalBuiltins.prototype.containsSignature = containsSignature;
+  MinimalBuiltins.prototype.containsOperator = containsOperator;
+  MinimalBuiltins.prototype.hasPrimitive = hasPrimitive;
+  MinimalBuiltins.prototype.hasFunction = hasFunction;
+  MinimalBuiltins.prototype.j2e = get_ruleSignatures;
+  MinimalBuiltins.prototype.hasProtected = hasProtected;
+  ProblogLib.prototype.containsSignature = containsSignature;
+  ProblogLib.prototype.containsOperator = containsOperator;
+  ProblogLib.prototype.hasPrimitive = hasPrimitive;
+  ProblogLib.prototype.hasFunction = hasFunction;
+  ProblogLib.prototype.j2e = get_ruleSignatures;
+  ProblogLib.prototype.hasProtected = hasProtected;
+  BinaryDecisionDiagramExplanation.prototype.y3d = get_probabilityOrNull;
+  //endregion
+  //region block: init
+  ANNOTATION_FUNCTOR = '::';
+  //endregion
+  //region block: exports
+  function $jsExportAll$(_) {
+    var $it = _.it || (_.it = {});
+    var $it$unibo = $it.unibo || ($it.unibo = {});
+    var $it$unibo$tuprolog = $it$unibo.tuprolog || ($it$unibo.tuprolog = {});
+    var $it$unibo$tuprolog$solve = $it$unibo$tuprolog.solve || ($it$unibo$tuprolog.solve = {});
+    var $it$unibo$tuprolog$solve$problog = $it$unibo$tuprolog$solve.problog || ($it$unibo$tuprolog$solve.problog = {});
+    Object.defineProperty($it$unibo$tuprolog$solve$problog, 'ProblogSolverFactory', {
+      configurable: true,
+      get: ProblogSolverFactory_getInstance
+    });
+  }
+  $jsExportAll$(_);
+  _.$jsExportAll$ = $jsExportAll$;
+  //endregion
+  return _;
+}(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'), require('./2p-core.js'), require('./2p-solve.js'), require('./2p-solve-plp.js'), require('./2p-solve-classic.js'), require('./2p-bdd.js'), require('./2p-theory.js'), require('./2p-utils.js'), require('./2p-unify.js')));
+
+//# sourceMappingURL=2p-solve-problog.js.map