@tuprolog/arg2p 0.11.2 → 0.11.4

package/arg2p-core.js

@@ -1,8 +1,8 @@
 (function (factory) {
   if (typeof define === 'function' && define.amd)
-    define(['exports', './kotlin-kotlin-stdlib.js', './2p-solve.js', './2p-core.js', './2p-parser-core.js', './2p-solve-classic.js', './2p-theory.js', './2p-parser-theory.js', './2p-dsl-solve.js', './2p-dsl-core.js', './2p-dsl-unify.js', './2p-unify.js', './2p-dsl-theory.js'], factory);
+    define(['exports', './kotlin-kotlin-stdlib.js', './2p-solve.js', './2p-solve-classic.js', './2p-theory.js', './2p-parser-theory.js', './2p-dsl-solve.js', './2p-dsl-core.js', './2p-core.js', './2p-dsl-unify.js', './2p-unify.js', './2p-dsl-theory.js', './2p-parser-core.js'], factory);
   else if (typeof exports === 'object')
-    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-solve.js'), require('./2p-core.js'), require('./2p-parser-core.js'), require('./2p-solve-classic.js'), require('./2p-theory.js'), require('./2p-parser-theory.js'), require('./2p-dsl-solve.js'), require('./2p-dsl-core.js'), require('./2p-dsl-unify.js'), require('./2p-unify.js'), require('./2p-dsl-theory.js'));
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-solve.js'), require('./2p-solve-classic.js'), require('./2p-theory.js'), require('./2p-parser-theory.js'), require('./2p-dsl-solve.js'), require('./2p-dsl-core.js'), require('./2p-core.js'), require('./2p-dsl-unify.js'), require('./2p-unify.js'), require('./2p-dsl-theory.js'), require('./2p-parser-core.js'));
   else {
     if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'arg2p-core'.");
@@ -10,12 +10,6 @@
     if (typeof globalThis['2p-solve'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-solve' was not found. Please, check whether '2p-solve' is loaded prior to 'arg2p-core'.");
     }
-    if (typeof globalThis['2p-core'] === 'undefined') {
-      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to 'arg2p-core'.");
-    }
-    if (typeof globalThis['2p-parser-core'] === 'undefined') {
-      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-parser-core' was not found. Please, check whether '2p-parser-core' is loaded prior to 'arg2p-core'.");
-    }
     if (typeof globalThis['2p-solve-classic'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-solve-classic' was not found. Please, check whether '2p-solve-classic' is loaded prior to 'arg2p-core'.");
     }
@@ -31,6 +25,9 @@
     if (typeof globalThis['2p-dsl-core'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-dsl-core' was not found. Please, check whether '2p-dsl-core' is loaded prior to 'arg2p-core'.");
     }
+    if (typeof globalThis['2p-core'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to 'arg2p-core'.");
+    }
     if (typeof globalThis['2p-dsl-unify'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-dsl-unify' was not found. Please, check whether '2p-dsl-unify' is loaded prior to 'arg2p-core'.");
     }
@@ -40,9 +37,12 @@
     if (typeof globalThis['2p-dsl-theory'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-dsl-theory' was not found. Please, check whether '2p-dsl-theory' is loaded prior to 'arg2p-core'.");
     }
-    globalThis['arg2p-core'] = factory(typeof globalThis['arg2p-core'] === 'undefined' ? {} : globalThis['arg2p-core'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-solve'], globalThis['2p-core'], globalThis['2p-parser-core'], globalThis['2p-solve-classic'], globalThis['2p-theory'], globalThis['2p-parser-theory'], globalThis['2p-dsl-solve'], globalThis['2p-dsl-core'], globalThis['2p-dsl-unify'], globalThis['2p-unify'], globalThis['2p-dsl-theory']);
+    if (typeof globalThis['2p-parser-core'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-parser-core' was not found. Please, check whether '2p-parser-core' is loaded prior to 'arg2p-core'.");
+    }
+    globalThis['arg2p-core'] = factory(typeof globalThis['arg2p-core'] === 'undefined' ? {} : globalThis['arg2p-core'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-solve'], globalThis['2p-solve-classic'], globalThis['2p-theory'], globalThis['2p-parser-theory'], globalThis['2p-dsl-solve'], globalThis['2p-dsl-core'], globalThis['2p-core'], globalThis['2p-dsl-unify'], globalThis['2p-unify'], globalThis['2p-dsl-theory'], globalThis['2p-parser-core']);
   }
-}(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_parser_core, kotlin_it_unibo_tuprolog_solve_classic, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_dsl_solve, kotlin_it_unibo_tuprolog_dsl_core, kotlin_it_unibo_tuprolog_dsl_unify, kotlin_it_unibo_tuprolog_unify, kotlin_it_unibo_tuprolog_dsl_theory) {
+}(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_solve_classic, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_dsl_solve, kotlin_it_unibo_tuprolog_dsl_core, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_dsl_unify, kotlin_it_unibo_tuprolog_unify, kotlin_it_unibo_tuprolog_dsl_theory, kotlin_it_unibo_tuprolog_parser_core) {
   'use strict';
   //region block: imports
   var imul = Math.imul;
@@ -59,14 +59,10 @@
   var Unit_instance = kotlin_kotlin.$_$.k1;
   var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.c1;
   var initMetadataForInterface = kotlin_kotlin.$_$.z5;
-  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.u;
-  var parseStruct = kotlin_it_unibo_tuprolog_parser_core.$_$.d;
-  var filter = kotlin_kotlin.$_$.t7;
-  var map = kotlin_kotlin.$_$.f8;
   var listOf_0 = kotlin_kotlin.$_$.b3;
   var plus_0 = kotlin_kotlin.$_$.u3;
   var ClassicSolverFactory_instance = kotlin_it_unibo_tuprolog_solve_classic.$_$.a;
-  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_solve.$_$.d1;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.d1;
   var Unknown_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.g1;
   var TrackVariables_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.f1;
   var Companion_instance_0 = kotlin_it_unibo_tuprolog_theory.$_$.b;
@@ -84,21 +80,22 @@
   var matchAny = kotlin_it_unibo_tuprolog_dsl_unify.$_$.a;
   var unifyAny = kotlin_it_unibo_tuprolog_dsl_unify.$_$.c;
   var solverOf = kotlin_it_unibo_tuprolog_dsl_solve.$_$.a;
+  var LogicProgrammingScopeWithOperators = kotlin_it_unibo_tuprolog_dsl_core.$_$.w1;
   var LogicProgrammingScopeWithPrologStandardLibrary = kotlin_it_unibo_tuprolog_dsl_core.$_$.h4;
+  var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var MinimalLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.c5;
   var LogicProgrammingScopeWithSubstitutions = kotlin_it_unibo_tuprolog_dsl_core.$_$.o4;
-  var LogicProgrammingScopeWithResolution = kotlin_it_unibo_tuprolog_dsl_solve.$_$.c;
   var BaseLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.e;
-  var LogicProgrammingScopeWithUnification = kotlin_it_unibo_tuprolog_dsl_unify.$_$.j;
-  var LogicProgrammingScopeWithOperators = kotlin_it_unibo_tuprolog_dsl_core.$_$.w1;
-  var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var LogicProgrammingScopeWithResolution = kotlin_it_unibo_tuprolog_dsl_solve.$_$.c;
   var LogicProgrammingScopeWithTheories = kotlin_it_unibo_tuprolog_dsl_theory.$_$.h;
-  var MinimalLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.c5;
-  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_core.$_$.i;
+  var LogicProgrammingScopeWithUnification = kotlin_it_unibo_tuprolog_dsl_unify.$_$.j;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.i;
   var lazy = kotlin_kotlin.$_$.ra;
   var KProperty1 = kotlin_kotlin.$_$.g7;
   var getPropertyCallableRef = kotlin_kotlin.$_$.u5;
   var CoroutineImpl = kotlin_kotlin.$_$.p4;
   var SequenceScope = kotlin_kotlin.$_$.h7;
+  var map = kotlin_kotlin.$_$.f8;
   var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.o4;
   var initMetadataForLambda = kotlin_kotlin.$_$.a6;
   var Signature = kotlin_it_unibo_tuprolog_solve.$_$.u2;
@@ -106,18 +103,19 @@
   var Primitive = kotlin_it_unibo_tuprolog_solve.$_$.w1;
   var sequence = kotlin_kotlin.$_$.n8;
   var Companion_instance_2 = kotlin_it_unibo_tuprolog_theory.$_$.a;
-  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_unify.$_$.b;
-  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_solve.$_$.h1;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_unify.$_$.b;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_solve.$_$.h1;
   var mapCapacity = kotlin_kotlin.$_$.d3;
   var coerceAtLeast = kotlin_kotlin.$_$.a7;
   var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.e;
   var ensureNotNull = kotlin_kotlin.$_$.pa;
-  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.v;
-  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.q;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.q;
   var first = kotlin_kotlin.$_$.v7;
   var to = kotlin_kotlin.$_$.ya;
   var mutableMapOf = kotlin_kotlin.$_$.n3;
-  var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_solve.$_$.o1;
+  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_solve.$_$.o1;
+  var filter = kotlin_kotlin.$_$.t7;
   var Companion_instance_3 = kotlin_it_unibo_tuprolog_solve.$_$.b1;
   var Expected_LIST_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.b;
   var Atom = kotlin_it_unibo_tuprolog_core.$_$.f1;
@@ -131,8 +129,10 @@
   var Specifier_XFX_getInstance = kotlin_it_unibo_tuprolog_core.$_$.a;
   var Operator = kotlin_it_unibo_tuprolog_core.$_$.e1;
   var OperatorSet_init_$Create$ = kotlin_it_unibo_tuprolog_core.$_$.f;
-  var Companion_getInstance_7 = kotlin_it_unibo_tuprolog_core.$_$.l;
+  var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_core.$_$.l;
   var parseClause = kotlin_it_unibo_tuprolog_parser_core.$_$.c;
+  var Companion_getInstance_7 = kotlin_it_unibo_tuprolog_core.$_$.u;
+  var parseStruct = kotlin_it_unibo_tuprolog_parser_core.$_$.d;
   var toString = kotlin_kotlin.$_$.p6;
   var getBooleanHashCode = kotlin_kotlin.$_$.t5;
   var getStringHashCode = kotlin_kotlin.$_$.v5;
@@ -219,12 +219,12 @@
   initMetadataForClass(Arg2pSolver$Companion$of$1, VOID, VOID, VOID, [Arg2pSolver]);
   initMetadataForCompanion(Companion);
   initMetadataForObject(Arg2pSolverFactory, 'Arg2pSolverFactory');
-  initMetadataForClass(PrologWithArgumentationImpl, 'PrologWithArgumentationImpl', PrologWithArgumentationImpl, VOID, [LogicProgrammingScopeWithPrologStandardLibrary, LogicProgrammingScopeWithSubstitutions, LogicProgrammingScopeWithResolution, BaseLogicProgrammingScope, LogicProgrammingScopeWithUnification, LogicProgrammingScopeWithOperators, Scope, LogicProgrammingScopeWithTheories, MinimalLogicProgrammingScope]);
+  initMetadataForClass(PrologWithArgumentationImpl, 'PrologWithArgumentationImpl', PrologWithArgumentationImpl, VOID, [LogicProgrammingScopeWithOperators, LogicProgrammingScopeWithPrologStandardLibrary, Scope, MinimalLogicProgrammingScope, LogicProgrammingScopeWithSubstitutions, BaseLogicProgrammingScope, LogicProgrammingScopeWithResolution, LogicProgrammingScopeWithTheories, LogicProgrammingScopeWithUnification]);
   function get_theoryOperators() {
-    return Companion_getInstance_1().DEFAULT;
+    return Companion_getInstance_0().DEFAULT;
   }
   function content() {
-    return this.z39();
+    return this.y39();
   }
   initMetadataForInterface(ArgLibrary, 'ArgLibrary');
   initMetadataForInterface(Loadable, 'Loadable');
@@ -398,39 +398,19 @@
   }
   function Arg2pSolver() {
   }
-  function Arg2pSolverFactory$evaluate$lambda$lambda(it) {
-    return it.d1u();
-  }
-  function Arg2pSolverFactory$evaluate$lambda$lambda_0($solver) {
-    return function (it) {
-      return mineActiveGraph($solver);
-    };
-  }
-  function Arg2pSolverFactory$evaluate$lambda($kb, $flags) {
-    return function ($this$arg2pScope) {
-      // Inline function 'kotlin.let' call
-      var solver = Arg2pSolverFactory_instance.v39($kb, $flags.u39());
-      var tmp = solver.solve(parseStruct(Companion_getInstance(), 'buildLabelSetsSilent'));
-      var tmp_0 = filter(tmp, Arg2pSolverFactory$evaluate$lambda$lambda);
-      return map(tmp_0, Arg2pSolverFactory$evaluate$lambda$lambda_0(solver));
-    };
-  }
   function Arg2pSolverFactory() {
   }
-  protoOf(Arg2pSolverFactory).w39 = function (theory, settings, staticLibs, dynamicLibs) {
+  protoOf(Arg2pSolverFactory).j39 = function (theory, settings, staticLibs, dynamicLibs) {
     // Inline function 'kotlin.let' call
     var it = Companion_instance_7.f39(plus_0(staticLibs, listOf_0(settings)), dynamicLibs);
-    return ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, it.c39(), Companion_getInstance_0().z1v_1.setNotable(Unknown_getInstance(), Unknown_getInstance().f27_1).setNotable(TrackVariables_getInstance(), TrackVariables_getInstance().z26_1), parseTheoryWithOperators(Companion_instance_0, theory, it.d39()));
+    return ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, it.c39(), Companion_getInstance().z1v_1.setNotable(Unknown_getInstance(), Unknown_getInstance().f27_1).setNotable(TrackVariables_getInstance(), TrackVariables_getInstance().z26_1), parseTheoryWithOperators(Companion_instance_0, theory, it.d39()));
   };
-  protoOf(Arg2pSolverFactory).v39 = function (theory, settings, staticLibs, dynamicLibs, $super) {
+  protoOf(Arg2pSolverFactory).k39 = function (theory, settings, staticLibs, dynamicLibs, $super) {
     theory = theory === VOID ? '' : theory;
-    settings = settings === VOID ? (new FlagsBuilder()).u39() : settings;
+    settings = settings === VOID ? (new FlagsBuilder()).w39() : settings;
     staticLibs = staticLibs === VOID ? emptyList() : staticLibs;
     dynamicLibs = dynamicLibs === VOID ? emptyList() : dynamicLibs;
-    return $super === VOID ? this.w39(theory, settings, staticLibs, dynamicLibs) : $super.w39.call(this, theory, settings, staticLibs, dynamicLibs);
-  };
-  protoOf(Arg2pSolverFactory).x39 = function (kb, flags) {
-    return arg2pScope(Arg2pSolverFactory$evaluate$lambda(kb, flags));
+    return $super === VOID ? this.j39(theory, settings, staticLibs, dynamicLibs) : $super.j39.call(this, theory, settings, staticLibs, dynamicLibs);
   };
   var Arg2pSolverFactory_instance;
   function Arg2pSolverFactory_getInstance() {
@@ -440,910 +420,910 @@
     return function_0(new PrologWithArgumentationImpl());
   }
   function PrologWithArgumentationImpl() {
-    this.y39_1 = Companion_instance_1.ofSolverFactory(ClassicSolverFactory_instance);
+    this.x39_1 = Companion_instance_1.ofSolverFactory(ClassicSolverFactory_instance);
   }
   protoOf(PrologWithArgumentationImpl).call1 = function (goal) {
-    return this.y39_1.call1(goal);
+    return this.x39_1.call1(goal);
   };
   protoOf(PrologWithArgumentationImpl).stringInvoke = function (_this__u8e3s4, term, terms) {
-    return this.y39_1.stringInvoke(_this__u8e3s4, term, terms);
+    return this.x39_1.stringInvoke(_this__u8e3s4, term, terms);
   };
   protoOf(PrologWithArgumentationImpl).structOfAny = function (functor, args) {
-    return this.y39_1.structOfAny(functor, args);
+    return this.x39_1.structOfAny(functor, args);
   };
   protoOf(PrologWithArgumentationImpl).structOf = function (functor, args) {
-    return this.y39_1.structOf(functor, args);
+    return this.x39_1.structOf(functor, args);
   };
   protoOf(PrologWithArgumentationImpl).structOfSequence = function (functor, args) {
-    return this.y39_1.structOfSequence(functor, args);
+    return this.x39_1.structOfSequence(functor, args);
   };
   protoOf(PrologWithArgumentationImpl).structOfIterable = function (functor, args) {
-    return this.y39_1.structOfIterable(functor, args);
+    return this.x39_1.structOfIterable(functor, args);
   };
   protoOf(PrologWithArgumentationImpl).structOfList = function (functor, args) {
-    return this.y39_1.structOfList(functor, args);
+    return this.x39_1.structOfList(functor, args);
   };
   protoOf(PrologWithArgumentationImpl).tupleOfAny = function (terms) {
-    return this.y39_1.tupleOfAny(terms);
+    return this.x39_1.tupleOfAny(terms);
   };
   protoOf(PrologWithArgumentationImpl).tupleOf = function (terms) {
-    return this.y39_1.tupleOf(terms);
+    return this.x39_1.tupleOf(terms);
   };
   protoOf(PrologWithArgumentationImpl).tupleOfIterable = function (terms) {
-    return this.y39_1.tupleOfIterable(terms);
+    return this.x39_1.tupleOfIterable(terms);
   };
   protoOf(PrologWithArgumentationImpl).tupleOfSequence = function (terms) {
-    return this.y39_1.tupleOfSequence(terms);
+    return this.x39_1.tupleOfSequence(terms);
   };
   protoOf(PrologWithArgumentationImpl).logicListOfAny = function (terms) {
-    return this.y39_1.logicListOfAny(terms);
+    return this.x39_1.logicListOfAny(terms);
   };
   protoOf(PrologWithArgumentationImpl).logicListOf = function (terms) {
-    return this.y39_1.logicListOf(terms);
+    return this.x39_1.logicListOf(terms);
   };
   protoOf(PrologWithArgumentationImpl).logicListOfIterable = function (terms) {
-    return this.y39_1.logicListOfIterable(terms);
+    return this.x39_1.logicListOfIterable(terms);
   };
   protoOf(PrologWithArgumentationImpl).logicListOfSequence = function (terms) {
-    return this.y39_1.logicListOfSequence(terms);
+    return this.x39_1.logicListOfSequence(terms);
   };
   protoOf(PrologWithArgumentationImpl).blockOfAny = function (terms) {
-    return this.y39_1.blockOfAny(terms);
+    return this.x39_1.blockOfAny(terms);
   };
   protoOf(PrologWithArgumentationImpl).blockOf = function (terms) {
-    return this.y39_1.blockOf(terms);
+    return this.x39_1.blockOf(terms);
   };
   protoOf(PrologWithArgumentationImpl).blockOfIterable = function (terms) {
-    return this.y39_1.blockOfIterable(terms);
+    return this.x39_1.blockOfIterable(terms);
   };
   protoOf(PrologWithArgumentationImpl).blockOfSequence = function (terms) {
-    return this.y39_1.blockOfSequence(terms);
+    return this.x39_1.blockOfSequence(terms);
   };
   protoOf(PrologWithArgumentationImpl).factOfAny = function (term) {
-    return this.y39_1.factOfAny(term);
+    return this.x39_1.factOfAny(term);
   };
   protoOf(PrologWithArgumentationImpl).factOf = function (head) {
-    return this.y39_1.factOf(head);
+    return this.x39_1.factOf(head);
   };
   protoOf(PrologWithArgumentationImpl).consOfAny = function (head, tail) {
-    return this.y39_1.consOfAny(head, tail);
+    return this.x39_1.consOfAny(head, tail);
   };
   protoOf(PrologWithArgumentationImpl).consOf = function (head, tail) {
-    return this.y39_1.consOf(head, tail);
+    return this.x39_1.consOf(head, tail);
   };
   protoOf(PrologWithArgumentationImpl).directiveOfAny = function (term, terms) {
-    return this.y39_1.directiveOfAny(term, terms);
+    return this.x39_1.directiveOfAny(term, terms);
   };
   protoOf(PrologWithArgumentationImpl).directiveOf = function (body1, body) {
-    return this.y39_1.directiveOf(body1, body);
+    return this.x39_1.directiveOf(body1, body);
   };
   protoOf(PrologWithArgumentationImpl).withScope = function (function_0) {
-    return this.y39_1.withScope(function_0);
+    return this.x39_1.withScope(function_0);
   };
   protoOf(PrologWithArgumentationImpl).a1g = function () {
-    return this.y39_1.a1g();
+    return this.x39_1.a1g();
   };
   protoOf(PrologWithArgumentationImpl).r2x = function (items, tail) {
-    return this.y39_1.r2x(items, tail);
+    return this.x39_1.r2x(items, tail);
   };
   protoOf(PrologWithArgumentationImpl).rule = function (function_0) {
-    return this.y39_1.rule(function_0);
+    return this.x39_1.rule(function_0);
   };
   protoOf(PrologWithArgumentationImpl).clause2 = function (head, body) {
-    return this.y39_1.clause2(head, body);
+    return this.x39_1.clause2(head, body);
   };
   protoOf(PrologWithArgumentationImpl).directive = function (function_0) {
-    return this.y39_1.directive(function_0);
+    return this.x39_1.directive(function_0);
   };
   protoOf(PrologWithArgumentationImpl).fact = function (function_0) {
-    return this.y39_1.fact(function_0);
+    return this.x39_1.fact(function_0);
   };
   protoOf(PrologWithArgumentationImpl).convertToTerm = function (_this__u8e3s4) {
-    return this.y39_1.convertToTerm(_this__u8e3s4);
+    return this.x39_1.convertToTerm(_this__u8e3s4);
   };
   protoOf(PrologWithArgumentationImpl).convertToSpecificSubTypeOfTerm = function (_this__u8e3s4, type, converter) {
-    return this.y39_1.convertToSpecificSubTypeOfTerm(_this__u8e3s4, type, converter);
+    return this.x39_1.convertToSpecificSubTypeOfTerm(_this__u8e3s4, type, converter);
   };
   protoOf(PrologWithArgumentationImpl).newScope = function () {
-    return this.y39_1.newScope();
+    return this.x39_1.newScope();
   };
   protoOf(PrologWithArgumentationImpl).l2x = function () {
-    return this.y39_1.l2x();
+    return this.x39_1.l2x();
   };
   protoOf(PrologWithArgumentationImpl).containsVar = function (variable) {
-    return this.y39_1.containsVar(variable);
+    return this.x39_1.containsVar(variable);
   };
   protoOf(PrologWithArgumentationImpl).contains = function (variable) {
-    return this.y39_1.contains(variable);
+    return this.x39_1.contains(variable);
   };
   protoOf(PrologWithArgumentationImpl).substitutionContains = function (_this__u8e3s4, term) {
-    return this.y39_1.substitutionContains(_this__u8e3s4, term);
+    return this.x39_1.substitutionContains(_this__u8e3s4, term);
   };
   protoOf(PrologWithArgumentationImpl).get = function (variable) {
-    return this.y39_1.get(variable);
+    return this.x39_1.get(variable);
   };
   protoOf(PrologWithArgumentationImpl).substitutionGet = function (_this__u8e3s4, term) {
-    return this.y39_1.substitutionGet(_this__u8e3s4, term);
+    return this.x39_1.substitutionGet(_this__u8e3s4, term);
   };
   protoOf(PrologWithArgumentationImpl).where = function (lambda) {
-    return this.y39_1.where(lambda);
+    return this.x39_1.where(lambda);
   };
   protoOf(PrologWithArgumentationImpl).with = function (lambda) {
-    return this.y39_1.with(lambda);
+    return this.x39_1.with(lambda);
   };
   protoOf(PrologWithArgumentationImpl).varOf = function (name) {
-    return this.y39_1.varOf(name);
+    return this.x39_1.varOf(name);
   };
   protoOf(PrologWithArgumentationImpl).varOfChar = function (name) {
-    return this.y39_1.varOfChar(name);
+    return this.x39_1.varOfChar(name);
   };
   protoOf(PrologWithArgumentationImpl).atomOf = function (value) {
-    return this.y39_1.atomOf(value);
+    return this.x39_1.atomOf(value);
   };
   protoOf(PrologWithArgumentationImpl).atomOfChar = function (value) {
-    return this.y39_1.atomOfChar(value);
+    return this.x39_1.atomOfChar(value);
   };
   protoOf(PrologWithArgumentationImpl).xz = function (terms, last) {
-    return this.y39_1.xz(terms, last);
+    return this.x39_1.xz(terms, last);
   };
   protoOf(PrologWithArgumentationImpl).yz = function (terms, last) {
-    return this.y39_1.yz(terms, last);
+    return this.x39_1.yz(terms, last);
   };
   protoOf(PrologWithArgumentationImpl).zz = function (terms, last) {
-    return this.y39_1.zz(terms, last);
+    return this.x39_1.zz(terms, last);
   };
   protoOf(PrologWithArgumentationImpl).ruleOf = function (head, body1, body) {
-    return this.y39_1.ruleOf(head, body1, body);
+    return this.x39_1.ruleOf(head, body1, body);
   };
   protoOf(PrologWithArgumentationImpl).clauseOf = function (head, body) {
-    return this.y39_1.clauseOf(head, body);
+    return this.x39_1.clauseOf(head, body);
   };
   protoOf(PrologWithArgumentationImpl).indicatorOf = function (name, arity) {
-    return this.y39_1.indicatorOf(name, arity);
+    return this.x39_1.indicatorOf(name, arity);
   };
   protoOf(PrologWithArgumentationImpl).indicatorOfStringInt = function (name, arity) {
-    return this.y39_1.indicatorOfStringInt(name, arity);
+    return this.x39_1.indicatorOfStringInt(name, arity);
   };
   protoOf(PrologWithArgumentationImpl).anonymous = function () {
-    return this.y39_1.anonymous();
+    return this.x39_1.anonymous();
   };
   protoOf(PrologWithArgumentationImpl).whatever = function () {
-    return this.y39_1.whatever();
+    return this.x39_1.whatever();
   };
   protoOf(PrologWithArgumentationImpl).numOfBigDecimal = function (value) {
-    return this.y39_1.numOfBigDecimal(value);
+    return this.x39_1.numOfBigDecimal(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfDouble = function (value) {
-    return this.y39_1.numOfDouble(value);
+    return this.x39_1.numOfDouble(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfFloat = function (value) {
-    return this.y39_1.numOfFloat(value);
+    return this.x39_1.numOfFloat(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfBigInteger = function (value) {
-    return this.y39_1.numOfBigInteger(value);
+    return this.x39_1.numOfBigInteger(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfInt = function (value) {
-    return this.y39_1.numOfInt(value);
+    return this.x39_1.numOfInt(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfLong = function (value) {
-    return this.y39_1.numOfLong(value);
+    return this.x39_1.numOfLong(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfShort = function (value) {
-    return this.y39_1.numOfShort(value);
+    return this.x39_1.numOfShort(value);
   };
   protoOf(PrologWithArgumentationImpl).numOfByte = function (value) {
-    return this.y39_1.numOfByte(value);
+    return this.x39_1.numOfByte(value);
   };
   protoOf(PrologWithArgumentationImpl).parseNum = function (value) {
-    return this.y39_1.parseNum(value);
+    return this.x39_1.parseNum(value);
   };
   protoOf(PrologWithArgumentationImpl).numOf = function (value) {
-    return this.y39_1.numOf(value);
+    return this.x39_1.numOf(value);
   };
   protoOf(PrologWithArgumentationImpl).intOfBigInteger = function (value) {
-    return this.y39_1.intOfBigInteger(value);
+    return this.x39_1.intOfBigInteger(value);
   };
   protoOf(PrologWithArgumentationImpl).intOf = function (value) {
-    return this.y39_1.intOf(value);
+    return this.x39_1.intOf(value);
   };
   protoOf(PrologWithArgumentationImpl).intOfLong = function (value) {
-    return this.y39_1.intOfLong(value);
+    return this.x39_1.intOfLong(value);
   };
   protoOf(PrologWithArgumentationImpl).intOfShort = function (value) {
-    return this.y39_1.intOfShort(value);
+    return this.x39_1.intOfShort(value);
   };
   protoOf(PrologWithArgumentationImpl).intOfByte = function (value) {
-    return this.y39_1.intOfByte(value);
+    return this.x39_1.intOfByte(value);
   };
   protoOf(PrologWithArgumentationImpl).parseInt = function (value) {
-    return this.y39_1.parseInt(value);
+    return this.x39_1.parseInt(value);
   };
   protoOf(PrologWithArgumentationImpl).parseIntRadix = function (value, radix) {
-    return this.y39_1.parseIntRadix(value, radix);
+    return this.x39_1.parseIntRadix(value, radix);
   };
   protoOf(PrologWithArgumentationImpl).realOfBigDecimal = function (value) {
-    return this.y39_1.realOfBigDecimal(value);
+    return this.x39_1.realOfBigDecimal(value);
   };
   protoOf(PrologWithArgumentationImpl).realOf = function (value) {
-    return this.y39_1.realOf(value);
+    return this.x39_1.realOf(value);
   };
   protoOf(PrologWithArgumentationImpl).realOfFloat = function (value) {
-    return this.y39_1.realOfFloat(value);
+    return this.x39_1.realOfFloat(value);
   };
   protoOf(PrologWithArgumentationImpl).parseReal = function (value) {
-    return this.y39_1.parseReal(value);
+    return this.x39_1.parseReal(value);
   };
   protoOf(PrologWithArgumentationImpl).truthOf = function (value) {
-    return this.y39_1.truthOf(value);
+    return this.x39_1.truthOf(value);
   };
   protoOf(PrologWithArgumentationImpl).unifierOf = function (assignments) {
-    return this.y39_1.unifierOf(assignments);
+    return this.x39_1.unifierOf(assignments);
   };
   protoOf(PrologWithArgumentationImpl).unifierOfIterable = function (assignments) {
-    return this.y39_1.unifierOfIterable(assignments);
+    return this.x39_1.unifierOfIterable(assignments);
   };
   protoOf(PrologWithArgumentationImpl).unifierOfSequence = function (assignments) {
-    return this.y39_1.unifierOfSequence(assignments);
+    return this.x39_1.unifierOfSequence(assignments);
   };
   protoOf(PrologWithArgumentationImpl).substitutionOf = function (assignments) {
-    return this.y39_1.substitutionOf(assignments);
+    return this.x39_1.substitutionOf(assignments);
   };
   protoOf(PrologWithArgumentationImpl).substitutionOfIterable = function (assignments) {
-    return this.y39_1.substitutionOfIterable(assignments);
+    return this.x39_1.substitutionOfIterable(assignments);
   };
   protoOf(PrologWithArgumentationImpl).substitutionOfSequence = function (assignments) {
-    return this.y39_1.substitutionOfSequence(assignments);
+    return this.x39_1.substitutionOfSequence(assignments);
   };
   protoOf(PrologWithArgumentationImpl).vz = function () {
-    return this.y39_1.vz();
+    return this.x39_1.vz();
   };
   protoOf(PrologWithArgumentationImpl).wz = function () {
-    return this.y39_1.wz();
+    return this.x39_1.wz();
   };
   protoOf(PrologWithArgumentationImpl).varTo = function (_this__u8e3s4, termObject) {
-    return this.y39_1.varTo(_this__u8e3s4, termObject);
+    return this.x39_1.varTo(_this__u8e3s4, termObject);
   };
   protoOf(PrologWithArgumentationImpl).stringTo = function (_this__u8e3s4, termObject) {
-    return this.y39_1.stringTo(_this__u8e3s4, termObject);
+    return this.x39_1.stringTo(_this__u8e3s4, termObject);
   };
   protoOf(PrologWithArgumentationImpl).substitutionContainsKey = function (_this__u8e3s4, term) {
-    return this.y39_1.substitutionContainsKey(_this__u8e3s4, term);
+    return this.x39_1.substitutionContainsKey(_this__u8e3s4, term);
   };
   protoOf(PrologWithArgumentationImpl).substitutionContainsValue = function (_this__u8e3s4, term) {
-    return this.y39_1.substitutionContainsValue(_this__u8e3s4, term);
+    return this.x39_1.substitutionContainsValue(_this__u8e3s4, term);
   };
   protoOf(PrologWithArgumentationImpl).at_end_of_stream1 = function (alias) {
-    return this.y39_1.at_end_of_stream1(alias);
+    return this.x39_1.at_end_of_stream1(alias);
   };
   protoOf(PrologWithArgumentationImpl).catch3 = function (goal, error, continuation) {
-    return this.y39_1.catch3(goal, error, continuation);
+    return this.x39_1.catch3(goal, error, continuation);
   };
   protoOf(PrologWithArgumentationImpl).throw1 = function (error) {
-    return this.y39_1.throw1(error);
+    return this.x39_1.throw1(error);
   };
   protoOf(PrologWithArgumentationImpl).not1 = function (goal) {
-    return this.y39_1.not1(goal);
+    return this.x39_1.not1(goal);
   };
   protoOf(PrologWithArgumentationImpl).naf1 = function (goal) {
-    return this.y39_1.naf1(goal);
+    return this.x39_1.naf1(goal);
   };
   protoOf(PrologWithArgumentationImpl).assert1 = function (clause) {
-    return this.y39_1.assert1(clause);
+    return this.x39_1.assert1(clause);
   };
   protoOf(PrologWithArgumentationImpl).asserta1 = function (clause) {
-    return this.y39_1.asserta1(clause);
+    return this.x39_1.asserta1(clause);
   };
   protoOf(PrologWithArgumentationImpl).assertz1 = function (clause) {
-    return this.y39_1.assertz1(clause);
+    return this.x39_1.assertz1(clause);
   };
   protoOf(PrologWithArgumentationImpl).arg3 = function (index, compound, argument) {
-    return this.y39_1.arg3(index, compound, argument);
+    return this.x39_1.arg3(index, compound, argument);
   };
   protoOf(PrologWithArgumentationImpl).atom1 = function (atom) {
-    return this.y39_1.atom1(atom);
+    return this.x39_1.atom1(atom);
   };
   protoOf(PrologWithArgumentationImpl).atomic1 = function (atomic) {
-    return this.y39_1.atomic1(atomic);
+    return this.x39_1.atomic1(atomic);
   };
   protoOf(PrologWithArgumentationImpl).between3 = function (min, max, number) {
-    return this.y39_1.between3(min, max, number);
+    return this.x39_1.between3(min, max, number);
   };
   protoOf(PrologWithArgumentationImpl).callable1 = function (goal) {
-    return this.y39_1.callable1(goal);
+    return this.x39_1.callable1(goal);
   };
   protoOf(PrologWithArgumentationImpl).compound1 = function (struct) {
-    return this.y39_1.compound1(struct);
+    return this.x39_1.compound1(struct);
   };
   protoOf(PrologWithArgumentationImpl).current_op3 = function (precedence, specifier, functor) {
-    return this.y39_1.current_op3(precedence, specifier, functor);
+    return this.x39_1.current_op3(precedence, specifier, functor);
   };
   protoOf(PrologWithArgumentationImpl).op3 = function (precedence, specifier, functor) {
-    return this.y39_1.op3(precedence, specifier, functor);
+    return this.x39_1.op3(precedence, specifier, functor);
   };
   protoOf(PrologWithArgumentationImpl).findall3 = function (template, goal, bag) {
-    return this.y39_1.findall3(template, goal, bag);
+    return this.x39_1.findall3(template, goal, bag);
   };
   protoOf(PrologWithArgumentationImpl).float1 = function (number) {
-    return this.y39_1.float1(number);
+    return this.x39_1.float1(number);
   };
   protoOf(PrologWithArgumentationImpl).functor3 = function (struct, functor, arity) {
-    return this.y39_1.functor3(struct, functor, arity);
+    return this.x39_1.functor3(struct, functor, arity);
   };
   protoOf(PrologWithArgumentationImpl).ground1 = function (term) {
-    return this.y39_1.ground1(term);
+    return this.x39_1.ground1(term);
   };
   protoOf(PrologWithArgumentationImpl).integer1 = function (number) {
-    return this.y39_1.integer1(number);
+    return this.x39_1.integer1(number);
   };
   protoOf(PrologWithArgumentationImpl).natural = function (number) {
-    return this.y39_1.natural(number);
+    return this.x39_1.natural(number);
   };
   protoOf(PrologWithArgumentationImpl).nonvar1 = function (number) {
-    return this.y39_1.nonvar1(number);
+    return this.x39_1.nonvar1(number);
   };
   protoOf(PrologWithArgumentationImpl).number1 = function (number) {
-    return this.y39_1.number1(number);
+    return this.x39_1.number1(number);
   };
   protoOf(PrologWithArgumentationImpl).var1 = function (term) {
-    return this.y39_1.var1(term);
+    return this.x39_1.var1(term);
   };
   protoOf(PrologWithArgumentationImpl).write1 = function (term) {
-    return this.y39_1.write1(term);
+    return this.x39_1.write1(term);
   };
   protoOf(PrologWithArgumentationImpl).univ2 = function (_this__u8e3s4, other) {
-    return this.y39_1.univ2(_this__u8e3s4, other);
+    return this.x39_1.univ2(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).eq2 = function (_this__u8e3s4, right) {
-    return this.y39_1.eq2(_this__u8e3s4, right);
+    return this.x39_1.eq2(_this__u8e3s4, right);
   };
   protoOf(PrologWithArgumentationImpl).neq2 = function (_this__u8e3s4, right) {
-    return this.y39_1.neq2(_this__u8e3s4, right);
+    return this.x39_1.neq2(_this__u8e3s4, right);
   };
   protoOf(PrologWithArgumentationImpl).id2 = function (_this__u8e3s4, right) {
-    return this.y39_1.id2(_this__u8e3s4, right);
+    return this.x39_1.id2(_this__u8e3s4, right);
   };
   protoOf(PrologWithArgumentationImpl).nid2 = function (_this__u8e3s4, right) {
-    return this.y39_1.nid2(_this__u8e3s4, right);
+    return this.x39_1.nid2(_this__u8e3s4, right);
   };
   protoOf(PrologWithArgumentationImpl).arithEq2 = function (_this__u8e3s4, right) {
-    return this.y39_1.arithEq2(_this__u8e3s4, right);
+    return this.x39_1.arithEq2(_this__u8e3s4, right);
   };
   protoOf(PrologWithArgumentationImpl).arithNeq2 = function (_this__u8e3s4, right) {
-    return this.y39_1.arithNeq2(_this__u8e3s4, right);
+    return this.x39_1.arithNeq2(_this__u8e3s4, right);
   };
   protoOf(PrologWithArgumentationImpl).member2 = function (item, list) {
-    return this.y39_1.member2(item, list);
+    return this.x39_1.member2(item, list);
   };
   protoOf(PrologWithArgumentationImpl).retract1 = function (clause) {
-    return this.y39_1.retract1(clause);
+    return this.x39_1.retract1(clause);
   };
   protoOf(PrologWithArgumentationImpl).retract = function (clause) {
-    return this.y39_1.retract(clause);
+    return this.x39_1.retract(clause);
   };
   protoOf(PrologWithArgumentationImpl).retractByHead = function (fact) {
-    return this.y39_1.retractByHead(fact);
+    return this.x39_1.retractByHead(fact);
   };
   protoOf(PrologWithArgumentationImpl).append3 = function (left, right, result) {
-    return this.y39_1.append3(left, right, result);
+    return this.x39_1.append3(left, right, result);
   };
   protoOf(PrologWithArgumentationImpl).retractall1 = function (clause) {
-    return this.y39_1.retractall1(clause);
+    return this.x39_1.retractall1(clause);
   };
   protoOf(PrologWithArgumentationImpl).abolish1 = function (indicator) {
-    return this.y39_1.abolish1(indicator);
+    return this.x39_1.abolish1(indicator);
   };
   protoOf(PrologWithArgumentationImpl).atom_chars2 = function (atom, chars) {
-    return this.y39_1.atom_chars2(atom, chars);
+    return this.x39_1.atom_chars2(atom, chars);
   };
   protoOf(PrologWithArgumentationImpl).atom_codes2 = function (atom, codes) {
-    return this.y39_1.atom_codes2(atom, codes);
+    return this.x39_1.atom_codes2(atom, codes);
   };
   protoOf(PrologWithArgumentationImpl).atom_concat3 = function (first, second, result) {
-    return this.y39_1.atom_concat3(first, second, result);
+    return this.x39_1.atom_concat3(first, second, result);
   };
   protoOf(PrologWithArgumentationImpl).atom_length2 = function (atom, length) {
-    return this.y39_1.atom_length2(atom, length);
+    return this.x39_1.atom_length2(atom, length);
   };
   protoOf(PrologWithArgumentationImpl).char_code2 = function (char, code) {
-    return this.y39_1.char_code2(char, code);
+    return this.x39_1.char_code2(char, code);
   };
   protoOf(PrologWithArgumentationImpl).copy_term2 = function (term, copy) {
-    return this.y39_1.copy_term2(term, copy);
+    return this.x39_1.copy_term2(term, copy);
   };
   protoOf(PrologWithArgumentationImpl).current_flag2 = function (name, value) {
-    return this.y39_1.current_flag2(name, value);
+    return this.x39_1.current_flag2(name, value);
   };
   protoOf(PrologWithArgumentationImpl).current_prolog_flag2 = function (name, value) {
-    return this.y39_1.current_prolog_flag2(name, value);
+    return this.x39_1.current_prolog_flag2(name, value);
   };
   protoOf(PrologWithArgumentationImpl).sub_atom5 = function (atom, before, length, after, sub_atom) {
-    return this.y39_1.sub_atom5(atom, before, length, after, sub_atom);
+    return this.x39_1.sub_atom5(atom, before, length, after, sub_atom);
   };
   protoOf(PrologWithArgumentationImpl).number_chars2 = function (first, second) {
-    return this.y39_1.number_chars2(first, second);
+    return this.x39_1.number_chars2(first, second);
   };
   protoOf(PrologWithArgumentationImpl).number_codes2 = function (first, second) {
-    return this.y39_1.number_codes2(first, second);
+    return this.x39_1.number_codes2(first, second);
   };
   protoOf(PrologWithArgumentationImpl).bagof3 = function (template, goal, bag) {
-    return this.y39_1.bagof3(template, goal, bag);
+    return this.x39_1.bagof3(template, goal, bag);
   };
   protoOf(PrologWithArgumentationImpl).setof3 = function (template, goal, bag) {
-    return this.y39_1.setof3(template, goal, bag);
+    return this.x39_1.setof3(template, goal, bag);
   };
   protoOf(PrologWithArgumentationImpl).consult1 = function (url) {
-    return this.y39_1.consult1(url);
+    return this.x39_1.consult1(url);
   };
   protoOf(PrologWithArgumentationImpl).set_flag2 = function (name, value) {
-    return this.y39_1.set_flag2(name, value);
+    return this.x39_1.set_flag2(name, value);
   };
   protoOf(PrologWithArgumentationImpl).set_prolog_flag2 = function (name, value) {
-    return this.y39_1.set_prolog_flag2(name, value);
+    return this.x39_1.set_prolog_flag2(name, value);
   };
   protoOf(PrologWithArgumentationImpl).dynamic1 = function (indicator) {
-    return this.y39_1.dynamic1(indicator);
+    return this.x39_1.dynamic1(indicator);
   };
   protoOf(PrologWithArgumentationImpl).static1 = function (indicator) {
-    return this.y39_1.static1(indicator);
+    return this.x39_1.static1(indicator);
   };
   protoOf(PrologWithArgumentationImpl).solve1 = function (goal) {
-    return this.y39_1.solve1(goal);
+    return this.x39_1.solve1(goal);
   };
   protoOf(PrologWithArgumentationImpl).solveWithTimeout = function (goal, timeout) {
-    return this.y39_1.solveWithTimeout(goal, timeout);
+    return this.x39_1.solveWithTimeout(goal, timeout);
   };
   protoOf(PrologWithArgumentationImpl).solve = function (goal) {
-    return this.y39_1.solve(goal);
+    return this.x39_1.solve(goal);
   };
   protoOf(PrologWithArgumentationImpl).solveWithOptions = function (goal, options) {
-    return this.y39_1.solveWithOptions(goal, options);
+    return this.x39_1.solveWithOptions(goal, options);
   };
   protoOf(PrologWithArgumentationImpl).initialization1 = function (goal) {
-    return this.y39_1.initialization1(goal);
+    return this.x39_1.initialization1(goal);
   };
   protoOf(PrologWithArgumentationImpl).load1 = function (url) {
-    return this.y39_1.load1(url);
+    return this.x39_1.load1(url);
   };
   protoOf(PrologWithArgumentationImpl).include1 = function (url) {
-    return this.y39_1.include1(url);
+    return this.x39_1.include1(url);
   };
   protoOf(PrologWithArgumentationImpl).termPlus = function (_this__u8e3s4, other) {
-    return this.y39_1.termPlus(_this__u8e3s4, other);
+    return this.x39_1.termPlus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).number = function (_this__u8e3s4, other) {
-    return this.y39_1.number(_this__u8e3s4, other);
+    return this.x39_1.number(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).booleanPlus = function (_this__u8e3s4, other) {
-    return this.y39_1.booleanPlus(_this__u8e3s4, other);
+    return this.x39_1.booleanPlus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).charPlus = function (_this__u8e3s4, other) {
-    return this.y39_1.charPlus(_this__u8e3s4, other);
+    return this.x39_1.charPlus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).termMinus = function (_this__u8e3s4, other) {
-    return this.y39_1.termMinus(_this__u8e3s4, other);
+    return this.x39_1.termMinus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).numberMinus = function (_this__u8e3s4, other) {
-    return this.y39_1.numberMinus(_this__u8e3s4, other);
+    return this.x39_1.numberMinus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).booleanMinus = function (_this__u8e3s4, other) {
-    return this.y39_1.booleanMinus(_this__u8e3s4, other);
+    return this.x39_1.booleanMinus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).charMinus = function (_this__u8e3s4, other) {
-    return this.y39_1.charMinus(_this__u8e3s4, other);
+    return this.x39_1.charMinus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).stringMinus = function (_this__u8e3s4, other) {
-    return this.y39_1.stringMinus(_this__u8e3s4, other);
+    return this.x39_1.stringMinus(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).termTimes = function (_this__u8e3s4, other) {
-    return this.y39_1.termTimes(_this__u8e3s4, other);
+    return this.x39_1.termTimes(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).numberTimes = function (_this__u8e3s4, other) {
-    return this.y39_1.numberTimes(_this__u8e3s4, other);
+    return this.x39_1.numberTimes(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).booleanTimes = function (_this__u8e3s4, other) {
-    return this.y39_1.booleanTimes(_this__u8e3s4, other);
+    return this.x39_1.booleanTimes(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).charTimes = function (_this__u8e3s4, other) {
-    return this.y39_1.charTimes(_this__u8e3s4, other);
+    return this.x39_1.charTimes(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).stringTimes = function (_this__u8e3s4, other) {
-    return this.y39_1.stringTimes(_this__u8e3s4, other);
+    return this.x39_1.stringTimes(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).termDiv = function (_this__u8e3s4, other) {
-    return this.y39_1.termDiv(_this__u8e3s4, other);
+    return this.x39_1.termDiv(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).numberDiv = function (_this__u8e3s4, other) {
-    return this.y39_1.numberDiv(_this__u8e3s4, other);
+    return this.x39_1.numberDiv(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).booleanDiv = function (_this__u8e3s4, other) {
-    return this.y39_1.booleanDiv(_this__u8e3s4, other);
+    return this.x39_1.booleanDiv(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).charDiv = function (_this__u8e3s4, other) {
-    return this.y39_1.charDiv(_this__u8e3s4, other);
+    return this.x39_1.charDiv(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).stringDiv = function (_this__u8e3s4, other) {
-    return this.y39_1.stringDiv(_this__u8e3s4, other);
+    return this.x39_1.stringDiv(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyEqualsTo = function (_this__u8e3s4, other) {
-    return this.y39_1.anyEqualsTo(_this__u8e3s4, other);
+    return this.x39_1.anyEqualsTo(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyNotEqualsTo = function (_this__u8e3s4, other) {
-    return this.y39_1.anyNotEqualsTo(_this__u8e3s4, other);
+    return this.x39_1.anyNotEqualsTo(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyGreaterThan = function (_this__u8e3s4, other) {
-    return this.y39_1.anyGreaterThan(_this__u8e3s4, other);
+    return this.x39_1.anyGreaterThan(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyGreaterThanOrEqualsTo = function (_this__u8e3s4, other) {
-    return this.y39_1.anyGreaterThanOrEqualsTo(_this__u8e3s4, other);
+    return this.x39_1.anyGreaterThanOrEqualsTo(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyNonLowerThan = function (_this__u8e3s4, other) {
-    return this.y39_1.anyNonLowerThan(_this__u8e3s4, other);
+    return this.x39_1.anyNonLowerThan(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyLowerThan = function (_this__u8e3s4, other) {
-    return this.y39_1.anyLowerThan(_this__u8e3s4, other);
+    return this.x39_1.anyLowerThan(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyLowerThanOrEqualsTo = function (_this__u8e3s4, other) {
-    return this.y39_1.anyLowerThanOrEqualsTo(_this__u8e3s4, other);
+    return this.x39_1.anyLowerThanOrEqualsTo(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyNonGreaterThan = function (_this__u8e3s4, other) {
-    return this.y39_1.anyNonGreaterThan(_this__u8e3s4, other);
+    return this.x39_1.anyNonGreaterThan(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyIntDiv = function (_this__u8e3s4, other) {
-    return this.y39_1.anyIntDiv(_this__u8e3s4, other);
+    return this.x39_1.anyIntDiv(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).termRem = function (_this__u8e3s4, other) {
-    return this.y39_1.termRem(_this__u8e3s4, other);
+    return this.x39_1.termRem(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).numberRem = function (_this__u8e3s4, other) {
-    return this.y39_1.numberRem(_this__u8e3s4, other);
+    return this.x39_1.numberRem(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).booleanRem = function (_this__u8e3s4, other) {
-    return this.y39_1.booleanRem(_this__u8e3s4, other);
+    return this.x39_1.booleanRem(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).charRem = function (_this__u8e3s4, other) {
-    return this.y39_1.charRem(_this__u8e3s4, other);
+    return this.x39_1.charRem(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).stringRem = function (_this__u8e3s4, other) {
-    return this.y39_1.stringRem(_this__u8e3s4, other);
+    return this.x39_1.stringRem(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyAnd = function (_this__u8e3s4, other) {
-    return this.y39_1.anyAnd(_this__u8e3s4, other);
+    return this.x39_1.anyAnd(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyOr = function (_this__u8e3s4, other) {
-    return this.y39_1.anyOr(_this__u8e3s4, other);
+    return this.x39_1.anyOr(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyPow = function (_this__u8e3s4, other) {
-    return this.y39_1.anyPow(_this__u8e3s4, other);
+    return this.x39_1.anyPow(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anySup = function (_this__u8e3s4, other) {
-    return this.y39_1.anySup(_this__u8e3s4, other);
+    return this.x39_1.anySup(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyIs = function (_this__u8e3s4, other) {
-    return this.y39_1.anyIs(_this__u8e3s4, other);
+    return this.x39_1.anyIs(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyThen = function (_this__u8e3s4, other) {
-    return this.y39_1.anyThen(_this__u8e3s4, other);
+    return this.x39_1.anyThen(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyImpliedBy = function (_this__u8e3s4, other) {
-    return this.y39_1.anyImpliedBy(_this__u8e3s4, other);
+    return this.x39_1.anyImpliedBy(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyImpliedByVararg = function (_this__u8e3s4, other) {
-    return this.y39_1.anyImpliedByVararg(_this__u8e3s4, other);
+    return this.x39_1.anyImpliedByVararg(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyIf = function (_this__u8e3s4, other) {
-    return this.y39_1.anyIf(_this__u8e3s4, other);
+    return this.x39_1.anyIf(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyIfVararg = function (_this__u8e3s4, other) {
-    return this.y39_1.anyIfVararg(_this__u8e3s4, other);
+    return this.x39_1.anyIfVararg(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).b1g = function (scope) {
-    return this.y39_1.b1g(scope);
+    return this.x39_1.b1g(scope);
   };
   protoOf(PrologWithArgumentationImpl).t1q = function (unificator) {
-    return this.y39_1.t1q(unificator);
+    return this.x39_1.t1q(unificator);
   };
   protoOf(PrologWithArgumentationImpl).q1t = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
-    return this.y39_1.q1t(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
+    return this.x39_1.q1t(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
   };
   protoOf(PrologWithArgumentationImpl).copy = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
     return this.copy(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof PrologWithArgumentationImpl) ? $super : THROW_CCE());
   };
   protoOf(PrologWithArgumentationImpl).getValue = function (thisRef, property) {
-    return this.y39_1.getValue(thisRef, property);
+    return this.x39_1.getValue(thisRef, property);
   };
   protoOf(PrologWithArgumentationImpl).d1g = function () {
-    return this.y39_1.d1g();
+    return this.x39_1.d1g();
   };
   protoOf(PrologWithArgumentationImpl).e1g = function () {
-    return this.y39_1.e1g();
+    return this.x39_1.e1g();
   };
   protoOf(PrologWithArgumentationImpl).anyMguWith = function (_this__u8e3s4, other) {
-    return this.y39_1.anyMguWith(_this__u8e3s4, other);
+    return this.x39_1.anyMguWith(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyMatches = function (_this__u8e3s4, other) {
-    return this.y39_1.anyMatches(_this__u8e3s4, other);
+    return this.x39_1.anyMatches(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).anyUnifyWith = function (_this__u8e3s4, other) {
-    return this.y39_1.anyUnifyWith(_this__u8e3s4, other);
+    return this.x39_1.anyUnifyWith(_this__u8e3s4, other);
   };
   protoOf(PrologWithArgumentationImpl).w2x = function (term1, term2, occurCheckEnabled) {
-    return this.y39_1.w2x(term1, term2, occurCheckEnabled);
+    return this.x39_1.w2x(term1, term2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).u1h = function (term1, term2, occurCheckEnabled) {
-    return this.y39_1.u1h(term1, term2, occurCheckEnabled);
+    return this.x39_1.u1h(term1, term2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).mgu = function (term1, term2) {
-    return this.y39_1.mgu(term1, term2);
+    return this.x39_1.mgu(term1, term2);
   };
   protoOf(PrologWithArgumentationImpl).x2x = function (term1, term2, occurCheckEnabled) {
-    return this.y39_1.x2x(term1, term2, occurCheckEnabled);
+    return this.x39_1.x2x(term1, term2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).matchWithOccurCheck = function (term1, term2, occurCheckEnabled) {
-    return this.y39_1.matchWithOccurCheck(term1, term2, occurCheckEnabled);
+    return this.x39_1.matchWithOccurCheck(term1, term2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).match = function (term1, term2) {
-    return this.y39_1.match(term1, term2);
+    return this.x39_1.match(term1, term2);
   };
   protoOf(PrologWithArgumentationImpl).y2x = function (term1, term2, occurCheckEnabled) {
-    return this.y39_1.y2x(term1, term2, occurCheckEnabled);
+    return this.x39_1.y2x(term1, term2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).unifyWithOccurCheck = function (term1, term2, occurCheckEnabled) {
-    return this.y39_1.unifyWithOccurCheck(term1, term2, occurCheckEnabled);
+    return this.x39_1.unifyWithOccurCheck(term1, term2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).unify = function (term1, term2) {
-    return this.y39_1.unify(term1, term2);
+    return this.x39_1.unify(term1, term2);
   };
   protoOf(PrologWithArgumentationImpl).b1j = function () {
-    return this.y39_1.b1j();
+    return this.x39_1.b1j();
   };
   protoOf(PrologWithArgumentationImpl).mergeWithOccurCheck = function (substitution1, substitution2, occurCheckEnabled) {
-    return this.y39_1.mergeWithOccurCheck(substitution1, substitution2, occurCheckEnabled);
+    return this.x39_1.mergeWithOccurCheck(substitution1, substitution2, occurCheckEnabled);
   };
   protoOf(PrologWithArgumentationImpl).merge = function (substitution1, substitution2) {
-    return this.y39_1.merge(substitution1, substitution2);
+    return this.x39_1.merge(substitution1, substitution2);
   };
   protoOf(PrologWithArgumentationImpl).convertToClause = function (_this__u8e3s4) {
-    return this.y39_1.convertToClause(_this__u8e3s4);
+    return this.x39_1.convertToClause(_this__u8e3s4);
   };
   protoOf(PrologWithArgumentationImpl).theory = function (clauseFunctions) {
-    return this.y39_1.theory(clauseFunctions);
+    return this.x39_1.theory(clauseFunctions);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfConcatenatedSequences = function (clauses, otherClauses) {
-    return this.y39_1.theoryOfConcatenatedSequences(clauses, otherClauses);
+    return this.x39_1.theoryOfConcatenatedSequences(clauses, otherClauses);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfConcatenatedIterables = function (clauses, otherClauses) {
-    return this.y39_1.theoryOfConcatenatedIterables(clauses, otherClauses);
+    return this.x39_1.theoryOfConcatenatedIterables(clauses, otherClauses);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.y39_1.theoryOfIterableWithUnificator(clauses, unificator);
+    return this.x39_1.theoryOfIterableWithUnificator(clauses, unificator);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfIterable = function (clauses) {
-    return this.y39_1.theoryOfIterable(clauses);
+    return this.x39_1.theoryOfIterable(clauses);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfWithUnificator = function (unificator, clauses) {
-    return this.y39_1.theoryOfWithUnificator(unificator, clauses);
+    return this.x39_1.theoryOfWithUnificator(unificator, clauses);
   };
   protoOf(PrologWithArgumentationImpl).theoryOf = function (clauses) {
-    return this.y39_1.theoryOf(clauses);
+    return this.x39_1.theoryOf(clauses);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.y39_1.theoryOfSequenceWithUnificator(clauses, unificator);
+    return this.x39_1.theoryOfSequenceWithUnificator(clauses, unificator);
   };
   protoOf(PrologWithArgumentationImpl).theoryOfSequence = function (clauses) {
-    return this.y39_1.theoryOfSequence(clauses);
+    return this.x39_1.theoryOfSequence(clauses);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheory = function (clauseFunctions) {
-    return this.y39_1.mutableTheory(clauseFunctions);
+    return this.x39_1.mutableTheory(clauseFunctions);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfConcatenatedSequences = function (clauses, otherClauses) {
-    return this.y39_1.mutableTheoryOfConcatenatedSequences(clauses, otherClauses);
+    return this.x39_1.mutableTheoryOfConcatenatedSequences(clauses, otherClauses);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfConcatenatedIterables = function (clauses, otherClauses) {
-    return this.y39_1.mutableTheoryOfConcatenatedIterables(clauses, otherClauses);
+    return this.x39_1.mutableTheoryOfConcatenatedIterables(clauses, otherClauses);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
-    return this.y39_1.mutableTheoryOfIterableWithUnificator(clauses, unificator);
+    return this.x39_1.mutableTheoryOfIterableWithUnificator(clauses, unificator);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfIterable = function (clauses) {
-    return this.y39_1.mutableTheoryOfIterable(clauses);
+    return this.x39_1.mutableTheoryOfIterable(clauses);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfWithUnificator = function (unificator, clauses) {
-    return this.y39_1.mutableTheoryOfWithUnificator(unificator, clauses);
+    return this.x39_1.mutableTheoryOfWithUnificator(unificator, clauses);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOf = function (clauses) {
-    return this.y39_1.mutableTheoryOf(clauses);
+    return this.x39_1.mutableTheoryOf(clauses);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
-    return this.y39_1.mutableTheoryOfSequenceWithUnificator(clauses, unificator);
+    return this.x39_1.mutableTheoryOfSequenceWithUnificator(clauses, unificator);
   };
   protoOf(PrologWithArgumentationImpl).mutableTheoryOfSequence = function (clauses) {
-    return this.y39_1.mutableTheoryOfSequence(clauses);
+    return this.x39_1.mutableTheoryOfSequence(clauses);
   };
   protoOf(PrologWithArgumentationImpl).emptyTheoryWithUnificator = function (unificator) {
-    return this.y39_1.emptyTheoryWithUnificator(unificator);
+    return this.x39_1.emptyTheoryWithUnificator(unificator);
   };
   protoOf(PrologWithArgumentationImpl).emptyTheory = function () {
-    return this.y39_1.emptyTheory();
+    return this.x39_1.emptyTheory();
   };
   protoOf(PrologWithArgumentationImpl).emptyMutableTheoryWithUnificator = function (unificator) {
-    return this.y39_1.emptyMutableTheoryWithUnificator(unificator);
+    return this.x39_1.emptyMutableTheoryWithUnificator(unificator);
   };
   protoOf(PrologWithArgumentationImpl).emptyMutableTheory = function () {
-    return this.y39_1.emptyMutableTheory();
+    return this.x39_1.emptyMutableTheory();
   };
   protoOf(PrologWithArgumentationImpl).m1w = function (unificator, otherLibraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
-    return this.y39_1.m1w(unificator, otherLibraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
+    return this.x39_1.m1w(unificator, otherLibraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
   };
   protoOf(PrologWithArgumentationImpl).staticKbByArray = function (clauses) {
-    this.y39_1.staticKbByArray(clauses);
+    this.x39_1.staticKbByArray(clauses);
   };
   protoOf(PrologWithArgumentationImpl).staticKbByIterable = function (clauses) {
-    this.y39_1.staticKbByIterable(clauses);
+    this.x39_1.staticKbByIterable(clauses);
   };
   protoOf(PrologWithArgumentationImpl).staticKbBySequence = function (clauses) {
-    this.y39_1.staticKbBySequence(clauses);
+    this.x39_1.staticKbBySequence(clauses);
   };
   protoOf(PrologWithArgumentationImpl).staticKbByTheory = function (theory) {
-    this.y39_1.staticKbByTheory(theory);
+    this.x39_1.staticKbByTheory(theory);
   };
   protoOf(PrologWithArgumentationImpl).b1t = function () {
-    return this.y39_1.b1t();
+    return this.x39_1.b1t();
   };
   protoOf(PrologWithArgumentationImpl).dynamicKbByArray = function (clauses) {
-    this.y39_1.dynamicKbByArray(clauses);
+    this.x39_1.dynamicKbByArray(clauses);
   };
   protoOf(PrologWithArgumentationImpl).dynamicKbByIterable = function (clauses) {
-    this.y39_1.dynamicKbByIterable(clauses);
+    this.x39_1.dynamicKbByIterable(clauses);
   };
   protoOf(PrologWithArgumentationImpl).dynamicKbBySequence = function (clauses) {
-    this.y39_1.dynamicKbBySequence(clauses);
+    this.x39_1.dynamicKbBySequence(clauses);
   };
   protoOf(PrologWithArgumentationImpl).dynamicKbByTheory = function (theory) {
-    this.y39_1.dynamicKbByTheory(theory);
+    this.x39_1.dynamicKbByTheory(theory);
   };
   protoOf(PrologWithArgumentationImpl).c1t = function () {
-    return this.y39_1.c1t();
+    return this.x39_1.c1t();
   };
   protoOf(PrologWithArgumentationImpl).r2y = function () {
-    return this.y39_1.r2y();
+    return this.x39_1.r2y();
   };
   protoOf(PrologWithArgumentationImpl).s2y = function () {
-    return this.y39_1.s2y();
+    return this.x39_1.s2y();
   };
   protoOf(PrologWithArgumentationImpl).loadLibrary = function (library) {
-    this.y39_1.loadLibrary(library);
+    this.x39_1.loadLibrary(library);
   };
   protoOf(PrologWithArgumentationImpl).unloadLibrary = function (library) {
-    this.y39_1.unloadLibrary(library);
+    this.x39_1.unloadLibrary(library);
   };
   protoOf(PrologWithArgumentationImpl).setLibraries = function (libraries) {
-    this.y39_1.setLibraries(libraries);
+    this.x39_1.setLibraries(libraries);
   };
   protoOf(PrologWithArgumentationImpl).loadStaticKb = function (theory) {
-    this.y39_1.loadStaticKb(theory);
+    this.x39_1.loadStaticKb(theory);
   };
   protoOf(PrologWithArgumentationImpl).loadStaticClauses = function (clauses) {
-    this.y39_1.loadStaticClauses(clauses);
+    this.x39_1.loadStaticClauses(clauses);
   };
   protoOf(PrologWithArgumentationImpl).loadStaticClausesIterable = function (clauses) {
-    this.y39_1.loadStaticClausesIterable(clauses);
+    this.x39_1.loadStaticClausesIterable(clauses);
   };
   protoOf(PrologWithArgumentationImpl).loadStaticClausesSequence = function (clauses) {
-    this.y39_1.loadStaticClausesSequence(clauses);
+    this.x39_1.loadStaticClausesSequence(clauses);
   };
   protoOf(PrologWithArgumentationImpl).appendStaticKb = function (theory) {
-    this.y39_1.appendStaticKb(theory);
+    this.x39_1.appendStaticKb(theory);
   };
   protoOf(PrologWithArgumentationImpl).resetStaticKb = function () {
-    this.y39_1.resetStaticKb();
+    this.x39_1.resetStaticKb();
   };
   protoOf(PrologWithArgumentationImpl).loadDynamicKb = function (theory) {
-    this.y39_1.loadDynamicKb(theory);
+    this.x39_1.loadDynamicKb(theory);
   };
   protoOf(PrologWithArgumentationImpl).loadDynamicClauses = function (clauses) {
-    this.y39_1.loadDynamicClauses(clauses);
+    this.x39_1.loadDynamicClauses(clauses);
   };
   protoOf(PrologWithArgumentationImpl).loadDynamicClausesIterable = function (clauses) {
-    this.y39_1.loadDynamicClausesIterable(clauses);
+    this.x39_1.loadDynamicClausesIterable(clauses);
   };
   protoOf(PrologWithArgumentationImpl).loadDynamicClausesSequence = function (clauses) {
-    this.y39_1.loadDynamicClausesSequence(clauses);
+    this.x39_1.loadDynamicClausesSequence(clauses);
   };
   protoOf(PrologWithArgumentationImpl).appendDynamicKb = function (theory) {
-    this.y39_1.appendDynamicKb(theory);
+    this.x39_1.appendDynamicKb(theory);
   };
   protoOf(PrologWithArgumentationImpl).resetDynamicKb = function () {
-    this.y39_1.resetDynamicKb();
+    this.x39_1.resetDynamicKb();
   };
   protoOf(PrologWithArgumentationImpl).assertA = function (clause) {
-    this.y39_1.assertA(clause);
+    this.x39_1.assertA(clause);
   };
   protoOf(PrologWithArgumentationImpl).assertAFact = function (fact) {
-    this.y39_1.assertAFact(fact);
+    this.x39_1.assertAFact(fact);
   };
   protoOf(PrologWithArgumentationImpl).assertZ = function (clause) {
-    this.y39_1.assertZ(clause);
+    this.x39_1.assertZ(clause);
   };
   protoOf(PrologWithArgumentationImpl).assertZFact = function (fact) {
-    this.y39_1.assertZFact(fact);
+    this.x39_1.assertZFact(fact);
   };
   protoOf(PrologWithArgumentationImpl).retractAll = function (clause) {
-    return this.y39_1.retractAll(clause);
+    return this.x39_1.retractAll(clause);
   };
   protoOf(PrologWithArgumentationImpl).retractAllBeHead = function (fact) {
-    return this.y39_1.retractAllBeHead(fact);
+    return this.x39_1.retractAllBeHead(fact);
   };
   protoOf(PrologWithArgumentationImpl).setFlag = function (name, value) {
-    this.y39_1.setFlag(name, value);
+    this.x39_1.setFlag(name, value);
   };
   protoOf(PrologWithArgumentationImpl).setFlagPair = function (flag) {
-    this.y39_1.setFlagPair(flag);
+    this.x39_1.setFlagPair(flag);
   };
   protoOf(PrologWithArgumentationImpl).setFlagNotable = function (flag) {
-    this.y39_1.setFlagNotable(flag);
+    this.x39_1.setFlagNotable(flag);
   };
   protoOf(PrologWithArgumentationImpl).setStandardInput = function (stdIn) {
-    this.y39_1.setStandardInput(stdIn);
+    this.x39_1.setStandardInput(stdIn);
   };
   protoOf(PrologWithArgumentationImpl).setStandardError = function (stdErr) {
-    this.y39_1.setStandardError(stdErr);
+    this.x39_1.setStandardError(stdErr);
   };
   protoOf(PrologWithArgumentationImpl).setStandardOutput = function (stdOut) {
-    this.y39_1.setStandardOutput(stdOut);
+    this.x39_1.setStandardOutput(stdOut);
   };
   protoOf(PrologWithArgumentationImpl).setWarnings = function (warnings) {
-    this.y39_1.setWarnings(warnings);
+    this.x39_1.setWarnings(warnings);
   };
   protoOf(PrologWithArgumentationImpl).q1q = function () {
-    return this.y39_1.q1q();
+    return this.x39_1.q1q();
   };
   protoOf(PrologWithArgumentationImpl).clone = function () {
     return this.q1q();
   };
   protoOf(PrologWithArgumentationImpl).solveListWithTimeout = function (goal, timeout) {
-    return this.y39_1.solveListWithTimeout(goal, timeout);
+    return this.x39_1.solveListWithTimeout(goal, timeout);
   };
   protoOf(PrologWithArgumentationImpl).solveList = function (goal) {
-    return this.y39_1.solveList(goal);
+    return this.x39_1.solveList(goal);
   };
   protoOf(PrologWithArgumentationImpl).solveListWithOptions = function (goal, options) {
-    return this.y39_1.solveListWithOptions(goal, options);
+    return this.x39_1.solveListWithOptions(goal, options);
   };
   protoOf(PrologWithArgumentationImpl).solveOnceWithTimeout = function (goal, timeout) {
-    return this.y39_1.solveOnceWithTimeout(goal, timeout);
+    return this.x39_1.solveOnceWithTimeout(goal, timeout);
   };
   protoOf(PrologWithArgumentationImpl).solveOnce = function (goal) {
-    return this.y39_1.solveOnce(goal);
+    return this.x39_1.solveOnce(goal);
   };
   protoOf(PrologWithArgumentationImpl).solveOnceWithOptions = function (goal, options) {
-    return this.y39_1.solveOnceWithOptions(goal, options);
+    return this.x39_1.solveOnceWithOptions(goal, options);
   };
   protoOf(PrologWithArgumentationImpl).z1s = function () {
-    return this.y39_1.z1s();
+    return this.x39_1.z1s();
   };
   protoOf(PrologWithArgumentationImpl).a1t = function () {
-    return this.y39_1.a1t();
+    return this.x39_1.a1t();
   };
   protoOf(PrologWithArgumentationImpl).i1t = function () {
-    return this.y39_1.i1t();
+    return this.x39_1.i1t();
   };
   protoOf(PrologWithArgumentationImpl).d1t = function () {
-    return this.y39_1.d1t();
+    return this.x39_1.d1t();
   };
   protoOf(PrologWithArgumentationImpl).e1t = function () {
-    return this.y39_1.e1t();
+    return this.x39_1.e1t();
   };
   protoOf(PrologWithArgumentationImpl).j1t = function () {
-    return this.y39_1.j1t();
+    return this.x39_1.j1t();
   };
   protoOf(PrologWithArgumentationImpl).k1t = function () {
-    return this.y39_1.k1t();
+    return this.x39_1.k1t();
   };
   protoOf(PrologWithArgumentationImpl).l1t = function () {
-    return this.y39_1.l1t();
+    return this.x39_1.l1t();
   };
   protoOf(PrologWithArgumentationImpl).m1t = function () {
-    return this.y39_1.m1t();
+    return this.x39_1.m1t();
   };
   function ArgLibrary() {
   }
@@ -1351,20 +1331,20 @@
   }
   function LazyRawPrologContent$prologTheory$delegate$lambda(this$0) {
     return function () {
-      return parseTheoryWithOperators(Companion_instance_0, this$0.c3a(), this$0.i39());
+      return parseTheoryWithOperators(Companion_instance_0, this$0.b3a(), this$0.i39());
     };
   }
   function LazyRawPrologContent$_get_prologTheory_$ref_uti0i4() {
     return function (p0) {
-      return p0.d3a();
+      return p0.c3a();
     };
   }
   function LazyRawPrologContent() {
     var tmp = this;
-    tmp.b3a_1 = lazy(LazyRawPrologContent$prologTheory$delegate$lambda(this));
+    tmp.a3a_1 = lazy(LazyRawPrologContent$prologTheory$delegate$lambda(this));
   }
-  protoOf(LazyRawPrologContent).d3a = function () {
-    var tmp0 = this.b3a_1;
+  protoOf(LazyRawPrologContent).c3a = function () {
+    var tmp0 = this.a3a_1;
     var tmp = KProperty1;
     // Inline function 'kotlin.getValue' call
     getPropertyCallableRef('prologTheory', 1, tmp, LazyRawPrologContent$_get_prologTheory_$ref_uti0i4(), null);
@@ -1376,9 +1356,9 @@
     };
   }
   function Cache$CacheGet$solve$slambda(this$0, $term, $request, resultContinuation) {
-    this.m3a_1 = this$0;
-    this.n3a_1 = $term;
-    this.o3a_1 = $request;
+    this.l3a_1 = this$0;
+    this.m3a_1 = $term;
+    this.n3a_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(Cache$CacheGet$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1399,8 +1379,8 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp_0 = this.m3a_1.q3a_1.solve(this.n3a_1.castToStruct());
-            suspendResult = this.p3a_1.sc(map(tmp_0, Cache$CacheGet$solve$slambda$lambda(this.o3a_1)), this);
+            var tmp_0 = this.l3a_1.p3a_1.solve(this.m3a_1.castToStruct());
+            suspendResult = this.o3a_1.sc(map(tmp_0, Cache$CacheGet$solve$slambda$lambda(this.n3a_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -1423,8 +1403,8 @@
      while (true);
   };
   protoOf(Cache$CacheGet$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new Cache$CacheGet$solve$slambda(this.m3a_1, this.n3a_1, this.o3a_1, completion);
-    i.p3a_1 = $this$sequence;
+    var i = new Cache$CacheGet$solve$slambda(this.l3a_1, this.m3a_1, this.n3a_1, completion);
+    i.o3a_1 = $this$sequence;
     return i;
   };
   function Cache$CacheGet$solve$slambda_0(this$0, $term, $request, resultContinuation) {
@@ -1436,45 +1416,45 @@
     return l;
   }
   function CacheAssert($outer) {
-    this.t3a_1 = $outer;
-    this.s3a_1 = new Signature('cache_assert', 1);
+    this.s3a_1 = $outer;
+    this.r3a_1 = new Signature('cache_assert', 1);
   }
   protoOf(CacheAssert).m1s = function () {
-    return this.s3a_1;
+    return this.r3a_1;
   };
   protoOf(CacheAssert).g2e = function (request) {
     var term = request.arguments.w(0);
-    this.t3a_1.q3a_1.assertAFact(term.castToStruct());
+    this.s3a_1.p3a_1.assertAFact(term.castToStruct());
     return sequenceOf(request.replyWithCondition(true, VOID, []));
   };
   protoOf(CacheAssert).solve = function (request) {
     return this.g2e(request);
   };
   function CacheRetract($outer) {
-    this.v3a_1 = $outer;
-    this.u3a_1 = new Signature('cache_retract', 1);
+    this.u3a_1 = $outer;
+    this.t3a_1 = new Signature('cache_retract', 1);
   }
   protoOf(CacheRetract).m1s = function () {
-    return this.u3a_1;
+    return this.t3a_1;
   };
   protoOf(CacheRetract).g2e = function (request) {
     var term = request.arguments.w(0);
-    this.v3a_1.q3a_1.retractAllBeHead(term.castToStruct());
+    this.u3a_1.p3a_1.retractAllBeHead(term.castToStruct());
     return sequenceOf(request.replyWithCondition(true, VOID, []));
   };
   protoOf(CacheRetract).solve = function (request) {
     return this.g2e(request);
   };
   function CacheGet($outer) {
-    this.x3a_1 = $outer;
-    this.w3a_1 = new Signature('cache_check', 1);
+    this.w3a_1 = $outer;
+    this.v3a_1 = new Signature('cache_check', 1);
   }
   protoOf(CacheGet).m1s = function () {
-    return this.w3a_1;
+    return this.v3a_1;
   };
   protoOf(CacheGet).g2e = function (request) {
     var term = request.arguments.w(0);
-    return sequence(Cache$CacheGet$solve$slambda_0(this.x3a_1, term, request, null));
+    return sequence(Cache$CacheGet$solve$slambda_0(this.w3a_1, term, request, null));
   };
   protoOf(CacheGet).solve = function (request) {
     return this.g2e(request);
@@ -1482,18 +1462,18 @@
   function Cache() {
     var tmp = this;
     // Inline function 'kotlin.also' call
-    var this_0 = ClassicSolverFactory_instance.rawMutableSolverOf(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_2().u1i()));
+    var this_0 = ClassicSolverFactory_instance.rawMutableSolverOf(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_1().u1i()));
     this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
-    tmp.q3a_1 = this_0;
-    this.r3a_1 = 'prolog.argumentation.cache';
+    tmp.p3a_1 = this_0;
+    this.q3a_1 = 'prolog.argumentation.cache';
   }
   protoOf(Cache).y2b = function () {
-    return this.r3a_1;
+    return this.q3a_1;
   };
-  protoOf(Cache).z39 = function () {
+  protoOf(Cache).y39 = function () {
     // Inline function 'kotlin.let' call
     var primitives = listOf([new CacheAssert(this), new CacheRetract(this), new CacheGet(this)]);
-    var tmp = Companion_getInstance_3();
+    var tmp = Companion_getInstance_2();
     // Inline function 'kotlin.collections.associateBy' call
     var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(primitives, 10)), 16);
     // Inline function 'kotlin.collections.associateByTo' call
@@ -1504,16 +1484,16 @@
       var tmp$ret$0 = element.m1s();
       destination.k4(tmp$ret$0, element);
     }
-    return tmp.of(this.r3a_1, destination);
+    return tmp.of(this.q3a_1, destination);
   };
   function Context$DynamicCacheAssert$solve$lambda(this$0, $term) {
     return function ($this$arg2pScope) {
-      return ensureNotNull(this$0.a3b_1.h2(this$0.z3a_1)).solve($this$arg2pScope.stringInvoke('asserta', $term, []));
+      return ensureNotNull(this$0.z3a_1.h2(this$0.y3a_1)).solve($this$arg2pScope.stringInvoke('asserta', $term, []));
     };
   }
   function Context$DynamicCacheRetract$solve$lambda(this$0, $term) {
     return function ($this$arg2pScope) {
-      return ensureNotNull(this$0.a3b_1.h2(this$0.z3a_1)).solve($this$arg2pScope.stringInvoke('retractall', $term, []));
+      return ensureNotNull(this$0.z3a_1.h2(this$0.y3a_1)).solve($this$arg2pScope.stringInvoke('retractall', $term, []));
     };
   }
   function Context$DynamicCacheGet$solve$slambda$lambda($request) {
@@ -1522,9 +1502,9 @@
     };
   }
   function Context$DynamicCacheGet$solve$slambda(this$0, $term, $request, resultContinuation) {
-    this.k3b_1 = this$0;
-    this.l3b_1 = $term;
-    this.m3b_1 = $request;
+    this.j3b_1 = this$0;
+    this.k3b_1 = $term;
+    this.l3b_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(Context$DynamicCacheGet$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1545,8 +1525,8 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp_0 = ensureNotNull(this.k3b_1.a3b_1.h2(this.k3b_1.z3a_1)).solve(this.l3b_1.castToStruct());
-            suspendResult = this.n3b_1.sc(map(tmp_0, Context$DynamicCacheGet$solve$slambda$lambda(this.m3b_1)), this);
+            var tmp_0 = ensureNotNull(this.j3b_1.z3a_1.h2(this.j3b_1.y3a_1)).solve(this.k3b_1.castToStruct());
+            suspendResult = this.m3b_1.sc(map(tmp_0, Context$DynamicCacheGet$solve$slambda$lambda(this.l3b_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -1569,8 +1549,8 @@
      while (true);
   };
   protoOf(Context$DynamicCacheGet$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new Context$DynamicCacheGet$solve$slambda(this.k3b_1, this.l3b_1, this.m3b_1, completion);
-    i.n3b_1 = $this$sequence;
+    var i = new Context$DynamicCacheGet$solve$slambda(this.j3b_1, this.k3b_1, this.l3b_1, completion);
+    i.m3b_1 = $this$sequence;
     return i;
   };
   function Context$DynamicCacheGet$solve$slambda_0(this$0, $term, $request, resultContinuation) {
@@ -1587,10 +1567,10 @@
     };
   }
   function Context$DynamicCacheGetIndexed$solve$slambda(this$0, $index, $term, $request, resultContinuation) {
-    this.w3b_1 = this$0;
-    this.x3b_1 = $index;
-    this.y3b_1 = $term;
-    this.z3b_1 = $request;
+    this.v3b_1 = this$0;
+    this.w3b_1 = $index;
+    this.x3b_1 = $term;
+    this.y3b_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(Context$DynamicCacheGetIndexed$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1611,8 +1591,8 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp_0 = ensureNotNull(this.w3b_1.a3b_1.h2(this.x3b_1)).solve(this.y3b_1.castToStruct());
-            suspendResult = this.a3c_1.sc(map(tmp_0, Context$DynamicCacheGetIndexed$solve$slambda$lambda(this.z3b_1)), this);
+            var tmp_0 = ensureNotNull(this.v3b_1.z3a_1.h2(this.w3b_1)).solve(this.x3b_1.castToStruct());
+            suspendResult = this.z3b_1.sc(map(tmp_0, Context$DynamicCacheGetIndexed$solve$slambda$lambda(this.y3b_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -1635,8 +1615,8 @@
      while (true);
   };
   protoOf(Context$DynamicCacheGetIndexed$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new Context$DynamicCacheGetIndexed$solve$slambda(this.w3b_1, this.x3b_1, this.y3b_1, this.z3b_1, completion);
-    i.a3c_1 = $this$sequence;
+    var i = new Context$DynamicCacheGetIndexed$solve$slambda(this.v3b_1, this.w3b_1, this.x3b_1, this.y3b_1, completion);
+    i.z3b_1 = $this$sequence;
     return i;
   };
   function Context$DynamicCacheGetIndexed$solve$slambda_0(this$0, $index, $term, $request, resultContinuation) {
@@ -1648,19 +1628,19 @@
     return l;
   }
   function DynamicCacheReset($outer) {
-    this.c3c_1 = $outer;
-    this.b3c_1 = new Signature('context_reset', 0);
+    this.b3c_1 = $outer;
+    this.a3c_1 = new Signature('context_reset', 0);
   }
   protoOf(DynamicCacheReset).m1s = function () {
-    return this.b3c_1;
+    return this.a3c_1;
   };
   protoOf(DynamicCacheReset).g2e = function (request) {
-    this.c3c_1.z3a_1 = 0;
-    this.c3c_1.y3a_1 = 1;
-    this.c3c_1.a3b_1.d3();
-    var tmp0 = this.c3c_1.a3b_1;
+    this.b3c_1.y3a_1 = 0;
+    this.b3c_1.x3a_1 = 1;
+    this.b3c_1.z3a_1.d3();
+    var tmp0 = this.b3c_1.z3a_1;
     // Inline function 'kotlin.also' call
-    var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_2().u1i()));
+    var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_1().u1i()));
     this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
     // Inline function 'kotlin.collections.set' call
     tmp0.k4(0, this_0);
@@ -1670,137 +1650,137 @@
     return this.g2e(request);
   };
   function DynamicCacheSelected($outer) {
-    this.e3c_1 = $outer;
-    this.d3c_1 = new Signature('context_active', 1);
+    this.d3c_1 = $outer;
+    this.c3c_1 = new Signature('context_active', 1);
   }
   protoOf(DynamicCacheSelected).m1s = function () {
-    return this.d3c_1;
+    return this.c3c_1;
   };
   protoOf(DynamicCacheSelected).g2e = function (request) {
     var term = request.arguments.w(0);
-    return sequenceOf(request.replyWith(Companion_getInstance_4().of(term.castToVar(), Companion_getInstance_5().ofInteger(this.e3c_1.z3a_1)), VOID, []));
+    return sequenceOf(request.replyWith(Companion_getInstance_3().of(term.castToVar(), Companion_getInstance_4().ofInteger(this.d3c_1.y3a_1)), VOID, []));
   };
   protoOf(DynamicCacheSelected).solve = function (request) {
     return this.g2e(request);
   };
   function DynamicCacheCheckout($outer) {
-    this.g3c_1 = $outer;
-    this.f3c_1 = new Signature('context_checkout', 1);
+    this.f3c_1 = $outer;
+    this.e3c_1 = new Signature('context_checkout', 1);
   }
   protoOf(DynamicCacheCheckout).m1s = function () {
-    return this.f3c_1;
+    return this.e3c_1;
   };
   protoOf(DynamicCacheCheckout).g2e = function (request) {
     var target = request.arguments.w(0).castToInteger().py().toInt();
-    var result = this.g3c_1.a3b_1.i2().u(target);
-    this.g3c_1.z3a_1 = target;
+    var result = this.f3c_1.z3a_1.i2().u(target);
+    this.f3c_1.y3a_1 = target;
     return sequenceOf(request.replyWithCondition(result, VOID, []));
   };
   protoOf(DynamicCacheCheckout).solve = function (request) {
     return this.g2e(request);
   };
   function DynamicCacheBranch($outer) {
-    this.i3c_1 = $outer;
-    this.h3c_1 = new Signature('context_branch', 2);
+    this.h3c_1 = $outer;
+    this.g3c_1 = new Signature('context_branch', 2);
   }
   protoOf(DynamicCacheBranch).m1s = function () {
-    return this.h3c_1;
+    return this.g3c_1;
   };
   protoOf(DynamicCacheBranch).g2e = function (request) {
     var target = request.arguments.w(0).castToInteger().py().toInt();
     var result = request.arguments.w(1);
-    var tmp0 = this.i3c_1.a3b_1;
-    var tmp2 = this.i3c_1.y3a_1;
+    var tmp0 = this.h3c_1.z3a_1;
+    var tmp2 = this.h3c_1.x3a_1;
     // Inline function 'kotlin.also' call
-    var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.ofIterable(Companion_getInstance_2().u1i(), ensureNotNull(this.i3c_1.a3b_1.h2(target)).c1t()));
+    var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.ofIterable(Companion_getInstance_1().u1i(), ensureNotNull(this.h3c_1.z3a_1.h2(target)).c1t()));
     this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
     // Inline function 'kotlin.collections.set' call
     tmp0.k4(tmp2, this_0);
-    var tmp = this.i3c_1;
-    var _unary__edvuaz = this.i3c_1.y3a_1;
-    this.i3c_1.y3a_1 = _unary__edvuaz + 1 | 0;
-    tmp.z3a_1 = _unary__edvuaz;
-    return sequenceOf(request.replyWith(Companion_getInstance_4().of(result.castToVar(), Companion_getInstance_5().ofInteger(this.i3c_1.z3a_1)), VOID, []));
+    var tmp = this.h3c_1;
+    var _unary__edvuaz = this.h3c_1.x3a_1;
+    this.h3c_1.x3a_1 = _unary__edvuaz + 1 | 0;
+    tmp.y3a_1 = _unary__edvuaz;
+    return sequenceOf(request.replyWith(Companion_getInstance_3().of(result.castToVar(), Companion_getInstance_4().ofInteger(this.h3c_1.y3a_1)), VOID, []));
   };
   protoOf(DynamicCacheBranch).solve = function (request) {
     return this.g2e(request);
   };
   function DynamicCacheAssert($outer) {
-    this.k3c_1 = $outer;
-    this.j3c_1 = new Signature('context_assert', 1);
+    this.j3c_1 = $outer;
+    this.i3c_1 = new Signature('context_assert', 1);
   }
   protoOf(DynamicCacheAssert).m1s = function () {
-    return this.j3c_1;
+    return this.i3c_1;
   };
   protoOf(DynamicCacheAssert).g2e = function (request) {
     var term = request.arguments.w(0);
-    first(arg2pScope(Context$DynamicCacheAssert$solve$lambda(this.k3c_1, term)));
+    first(arg2pScope(Context$DynamicCacheAssert$solve$lambda(this.j3c_1, term)));
     return sequenceOf(request.replyWithCondition(true, VOID, []));
   };
   protoOf(DynamicCacheAssert).solve = function (request) {
     return this.g2e(request);
   };
   function DynamicCacheRetract($outer) {
-    this.m3c_1 = $outer;
-    this.l3c_1 = new Signature('context_retract', 1);
+    this.l3c_1 = $outer;
+    this.k3c_1 = new Signature('context_retract', 1);
   }
   protoOf(DynamicCacheRetract).m1s = function () {
-    return this.l3c_1;
+    return this.k3c_1;
   };
   protoOf(DynamicCacheRetract).g2e = function (request) {
     var term = request.arguments.w(0);
-    first(arg2pScope(Context$DynamicCacheRetract$solve$lambda(this.m3c_1, term)));
+    first(arg2pScope(Context$DynamicCacheRetract$solve$lambda(this.l3c_1, term)));
     return sequenceOf(request.replyWithCondition(true, VOID, []));
   };
   protoOf(DynamicCacheRetract).solve = function (request) {
     return this.g2e(request);
   };
   function DynamicCacheGet($outer) {
-    this.o3c_1 = $outer;
-    this.n3c_1 = new Signature('context_check', 1);
+    this.n3c_1 = $outer;
+    this.m3c_1 = new Signature('context_check', 1);
   }
   protoOf(DynamicCacheGet).m1s = function () {
-    return this.n3c_1;
+    return this.m3c_1;
   };
   protoOf(DynamicCacheGet).g2e = function (request) {
     var term = request.arguments.w(0);
-    return sequence(Context$DynamicCacheGet$solve$slambda_0(this.o3c_1, term, request, null));
+    return sequence(Context$DynamicCacheGet$solve$slambda_0(this.n3c_1, term, request, null));
   };
   protoOf(DynamicCacheGet).solve = function (request) {
     return this.g2e(request);
   };
   function DynamicCacheGetIndexed($outer) {
-    this.q3c_1 = $outer;
-    this.p3c_1 = new Signature('context_check', 2);
+    this.p3c_1 = $outer;
+    this.o3c_1 = new Signature('context_check', 2);
   }
   protoOf(DynamicCacheGetIndexed).m1s = function () {
-    return this.p3c_1;
+    return this.o3c_1;
   };
   protoOf(DynamicCacheGetIndexed).g2e = function (request) {
     var index = ensureNotNull(request.arguments.w(0).asNumeric()).py().toInt();
     var term = request.arguments.w(1);
-    return sequence(Context$DynamicCacheGetIndexed$solve$slambda_0(this.q3c_1, index, term, request, null));
+    return sequence(Context$DynamicCacheGetIndexed$solve$slambda_0(this.p3c_1, index, term, request, null));
   };
   protoOf(DynamicCacheGetIndexed).solve = function (request) {
     return this.g2e(request);
   };
   function Context() {
-    this.y3a_1 = 1;
-    this.z3a_1 = 0;
+    this.x3a_1 = 1;
+    this.y3a_1 = 0;
     var tmp = this;
     // Inline function 'kotlin.also' call
-    var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_2().u1i()));
+    var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_1().u1i()));
     this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
-    tmp.a3b_1 = mutableMapOf([to(0, this_0)]);
-    this.b3b_1 = 'prolog.argumentation.context';
+    tmp.z3a_1 = mutableMapOf([to(0, this_0)]);
+    this.a3b_1 = 'prolog.argumentation.context';
   }
   protoOf(Context).y2b = function () {
-    return this.b3b_1;
+    return this.a3b_1;
   };
-  protoOf(Context).z39 = function () {
+  protoOf(Context).y39 = function () {
     // Inline function 'kotlin.let' call
     var primitives = listOf([new DynamicCacheReset(this), new DynamicCacheCheckout(this), new DynamicCacheSelected(this), new DynamicCacheBranch(this), new DynamicCacheAssert(this), new DynamicCacheRetract(this), new DynamicCacheGet(this), new DynamicCacheGetIndexed(this)]);
-    var tmp = Companion_getInstance_3();
+    var tmp = Companion_getInstance_2();
     // Inline function 'kotlin.collections.associateBy' call
     var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(primitives, 10)), 16);
     // Inline function 'kotlin.collections.associateByTo' call
@@ -1811,7 +1791,7 @@
       var tmp$ret$0 = element.m1s();
       destination.k4(tmp$ret$0, element);
     }
-    return tmp.of(this.b3b_1, destination);
+    return tmp.of(this.a3b_1, destination);
   };
   function DynamicLoader$AbstractWithLib$solve$slambda$lambda($request) {
     return function (it) {
@@ -1819,9 +1799,9 @@
     };
   }
   function DynamicLoader$AbstractWithLib$solve$slambda($solver, $goal, $request, resultContinuation) {
-    this.z3c_1 = $solver;
-    this.a3d_1 = $goal;
-    this.b3d_1 = $request;
+    this.y3c_1 = $solver;
+    this.z3c_1 = $goal;
+    this.a3d_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(DynamicLoader$AbstractWithLib$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1842,8 +1822,8 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp_0 = this.z3c_1.solveWithOptions(this.a3d_1, Companion_getInstance_6().allLazilyWithTimeout(9223372036854775807n));
-            suspendResult = this.c3d_1.sc(map(tmp_0, DynamicLoader$AbstractWithLib$solve$slambda$lambda(this.b3d_1)), this);
+            var tmp_0 = this.y3c_1.solveWithOptions(this.z3c_1, Companion_getInstance_5().allLazilyWithTimeout(9223372036854775807n));
+            suspendResult = this.b3d_1.sc(map(tmp_0, DynamicLoader$AbstractWithLib$solve$slambda$lambda(this.a3d_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -1866,8 +1846,8 @@
      while (true);
   };
   protoOf(DynamicLoader$AbstractWithLib$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new DynamicLoader$AbstractWithLib$solve$slambda(this.z3c_1, this.a3d_1, this.b3d_1, completion);
-    i.c3d_1 = $this$sequence;
+    var i = new DynamicLoader$AbstractWithLib$solve$slambda(this.y3c_1, this.z3c_1, this.a3d_1, completion);
+    i.b3d_1 = $this$sequence;
     return i;
   };
   function DynamicLoader$AbstractWithLib$solve$slambda_0($solver, $goal, $request, resultContinuation) {
@@ -1894,7 +1874,7 @@
     };
   }
   function AbstractWithLib($outer) {
-    this.d3d_1 = $outer;
+    this.c3d_1 = $outer;
   }
   protoOf(AbstractWithLib).g2e = function (request) {
     var lib = request.arguments.w(0);
@@ -1905,14 +1885,14 @@
     if (!isInterface(goal, Struct)) {
       throw Companion_instance_3.forGoal(request.context, request.signature, Expected_CALLABLE_getInstance(), goal);
     }
-    var tmp0 = this.d3d_1.f3d_1.b39();
+    var tmp0 = this.c3d_1.e3d_1.b39();
     var tmp$ret$1;
     $l$block: {
       // Inline function 'kotlin.collections.firstOrNull' call
       var _iterator__ex2g4s = tmp0.p();
       while (_iterator__ex2g4s.s()) {
         var element = _iterator__ex2g4s.t();
-        if ((isInterface(element, Loadable) ? element : THROW_CCE()).a3a() === lib.toString()) {
+        if ((isInterface(element, Loadable) ? element : THROW_CCE()).z39() === lib.toString()) {
           tmp$ret$1 = element;
           break $l$block;
         }
@@ -1937,7 +1917,7 @@
     while (_iterator__ex2g4s_0.s()) {
       var element_0 = _iterator__ex2g4s_0.t();
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.d3d_1.f3d_1.b39();
+      var this_0 = this.c3d_1.e3d_1.b39();
       // Inline function 'kotlin.collections.mapTo' call
       var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s_1 = this_0.p();
@@ -1951,32 +1931,32 @@
       }
     }
     var solver = request.context.createMutableSolver(VOID, tmp_0.ofIterable(destination).plusLibrary(library.h39()), VOID, request.context.b1t());
-    this.e3d(lib.toString(), solver);
+    this.d3d(lib.toString(), solver);
     return sequence(DynamicLoader$AbstractWithLib$solve$slambda_0(solver, goal, request, null));
   };
   protoOf(AbstractWithLib).solve = function (request) {
     return this.g2e(request);
   };
   function WithLib($outer) {
-    this.k3d_1 = $outer;
+    this.j3d_1 = $outer;
     AbstractWithLib.call(this, $outer);
-    this.j3d_1 = new Signature('::', 2);
+    this.i3d_1 = new Signature('::', 2);
   }
   protoOf(WithLib).m1s = function () {
-    return this.j3d_1;
+    return this.i3d_1;
   };
-  protoOf(WithLib).e3d = function (module_0, solver) {
+  protoOf(WithLib).d3d = function (module_0, solver) {
     return Unit_instance;
   };
   function WithLibInNewContext($outer) {
-    this.n3d_1 = $outer;
+    this.m3d_1 = $outer;
     AbstractWithLib.call(this, $outer);
-    this.m3d_1 = new Signature(':::', 2);
+    this.l3d_1 = new Signature(':::', 2);
   }
   protoOf(WithLibInNewContext).m1s = function () {
-    return this.m3d_1;
+    return this.l3d_1;
   };
-  protoOf(WithLibInNewContext).e3d = function (module_0, solver) {
+  protoOf(WithLibInNewContext).d3d = function (module_0, solver) {
     return logicProgramming(DynamicLoader$WithLibInNewContext$execute$lambda(solver));
   };
   function Companion_0() {
@@ -1989,17 +1969,17 @@
     return Companion_instance_8;
   }
   function DynamicLoader(solver) {
-    this.f3d_1 = solver;
-    this.g3d_1 = 'prolog.argumentation.loader';
-    this.h3d_1 = Companion_instance_8.d39();
+    this.e3d_1 = solver;
+    this.f3d_1 = 'prolog.argumentation.loader';
+    this.g3d_1 = Companion_instance_8.d39();
   }
   protoOf(DynamicLoader).y2b = function () {
-    return this.g3d_1;
+    return this.f3d_1;
   };
-  protoOf(DynamicLoader).z39 = function () {
+  protoOf(DynamicLoader).y39 = function () {
     // Inline function 'kotlin.let' call
     var it = listOf([new WithLib(this), new WithLibInNewContext(this)]);
-    var tmp = Companion_getInstance_3();
+    var tmp = Companion_getInstance_2();
     // Inline function 'kotlin.collections.associateBy' call
     var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(it, 10)), 16);
     // Inline function 'kotlin.collections.associateByTo' call
@@ -2010,55 +1990,55 @@
       var tmp$ret$0 = element.m1s();
       destination.k4(tmp$ret$0, element);
     }
-    return tmp.of(this.g3d_1, destination, VOID, Companion_instance_8.d39());
+    return tmp.of(this.f3d_1, destination, VOID, Companion_instance_8.d39());
   };
   protoOf(DynamicLoader).i39 = function () {
-    return this.h3d_1;
+    return this.g3d_1;
   };
   function EngineInterfaceBase() {
     LazyRawPrologContent.call(this);
-    this.p3d_1 = 'prolog.argumentation.interface';
-    this.q3d_1 = Companion_instance_10.d39().plusOperatorSet(Companion_instance_8.d39()).plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.o3d_1 = 'prolog.argumentation.interface';
+    this.p3d_1 = Companion_instance_10.d39().plusOperatorSet(Companion_instance_8.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(EngineInterfaceBase).y2b = function () {
-    return this.p3d_1;
+    return this.o3d_1;
   };
-  protoOf(EngineInterfaceBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a(), Companion_instance_10.d39());
+  protoOf(EngineInterfaceBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a(), Companion_instance_10.d39());
   };
   protoOf(EngineInterfaceBase).i39 = function () {
-    return this.q3d_1;
+    return this.p3d_1;
   };
   function Companion_1() {
   }
-  protoOf(Companion_1).r3d = function (target) {
+  protoOf(Companion_1).q3d = function (target) {
     // Inline function 'kotlin.also' call
-    var this_0 = Companion_instance_2.empty(Companion_getInstance_2().u1i());
+    var this_0 = Companion_instance_2.empty(Companion_getInstance_1().u1i());
     $l$block: {
-      if (target.j39_1) {
+      if (target.l39_1) {
         break $l$block;
       }
       // Inline function 'kotlin.collections.forEach' call
-      var _iterator__ex2g4s = target.t39_1.p();
+      var _iterator__ex2g4s = target.v39_1.p();
       while (_iterator__ex2g4s.s()) {
         var element = _iterator__ex2g4s.t();
-        this_0.g1q(parseClause(Companion_getInstance_7(), GraphExtension_instance.s3d() + '(X) :- X = ' + element));
+        this_0.g1q(parseClause(Companion_getInstance_6(), GraphExtension_instance.r3d() + '(X) :- X = ' + element));
       }
-      if (target.k39_1) {
-        this_0.g1r(parseStruct(Companion_getInstance(), QueryMode_instance.s3d()));
+      if (target.m39_1) {
+        this_0.g1r(parseStruct(Companion_getInstance_7(), QueryMode_instance.r3d()));
       }
-      if (target.l39_1) {
-        this_0.g1r(parseStruct(Companion_getInstance(), AutoTransposition_instance.s3d()));
+      if (target.n39_1) {
+        this_0.g1r(parseStruct(Companion_getInstance_7(), AutoTransposition_instance.r3d()));
       }
-      if (target.m39_1) {
-        this_0.g1r(parseStruct(Companion_getInstance(), PrologStrictCompatibility_instance.s3d()));
+      if (target.o39_1) {
+        this_0.g1r(parseStruct(Companion_getInstance_7(), PrologStrictCompatibility_instance.r3d()));
       }
-      this_0.g1r(parseStruct(Companion_getInstance(), GraphBuildMode_instance.s3d() + '(' + target.n39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance(), ArgumentLabellingMode_instance.s3d() + '(' + target.o39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance(), StatementLabellingMode_instance.s3d() + '(' + target.p39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance(), OrderingPrinciple_instance.s3d() + '(' + target.q39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance(), OrderingComparator_instance.s3d() + '(' + target.r39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance(), ModulesPath_instance.s3d() + '(' + target.s39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), GraphBuildMode_instance.r3d() + '(' + target.p39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), ArgumentLabellingMode_instance.r3d() + '(' + target.q39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), StatementLabellingMode_instance.r3d() + '(' + target.r39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingPrinciple_instance.r3d() + '(' + target.s39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingComparator_instance.r3d() + '(' + target.t39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), ModulesPath_instance.r3d() + '(' + target.u39_1 + ')'));
     }
     return this_0;
   };
@@ -2067,57 +2047,57 @@
     return Companion_instance_9;
   }
   function FlagsBuilder$create$1(this$0) {
-    this.u3d_1 = this$0;
-    this.t3d_1 = 'prolog.argumentation.flags';
+    this.t3d_1 = this$0;
+    this.s3d_1 = 'prolog.argumentation.flags';
   }
   protoOf(FlagsBuilder$create$1).y2b = function () {
-    return this.t3d_1;
+    return this.s3d_1;
   };
-  protoOf(FlagsBuilder$create$1).z39 = function () {
-    return Companion_getInstance_3().of(this.t3d_1, VOID, Companion_instance_9.r3d(this.u3d_1));
+  protoOf(FlagsBuilder$create$1).y39 = function () {
+    return Companion_getInstance_2().of(this.s3d_1, VOID, Companion_instance_9.q3d(this.t3d_1));
   };
   function FlagsBuilder(emptyBuilder, queryMode, autoTransposition, prologStrictCompatibility, graphBuildMode, argumentLabellingMode, statementLabellingMode, orderingPrinciple, orderingComparator, modulesPath, graphExtensions) {
     emptyBuilder = emptyBuilder === VOID ? false : emptyBuilder;
-    queryMode = queryMode === VOID ? QueryMode_instance.v3d() : queryMode;
-    autoTransposition = autoTransposition === VOID ? AutoTransposition_instance.v3d() : autoTransposition;
-    prologStrictCompatibility = prologStrictCompatibility === VOID ? PrologStrictCompatibility_instance.v3d() : prologStrictCompatibility;
-    graphBuildMode = graphBuildMode === VOID ? GraphBuildMode_instance.v3d() : graphBuildMode;
-    argumentLabellingMode = argumentLabellingMode === VOID ? ArgumentLabellingMode_instance.v3d() : argumentLabellingMode;
-    statementLabellingMode = statementLabellingMode === VOID ? StatementLabellingMode_instance.v3d() : statementLabellingMode;
-    orderingPrinciple = orderingPrinciple === VOID ? OrderingPrinciple_instance.v3d() : orderingPrinciple;
-    orderingComparator = orderingComparator === VOID ? OrderingComparator_instance.v3d() : orderingComparator;
-    modulesPath = modulesPath === VOID ? ModulesPath_instance.v3d() : modulesPath;
-    graphExtensions = graphExtensions === VOID ? GraphExtension_instance.v3d() : graphExtensions;
-    this.j39_1 = emptyBuilder;
-    this.k39_1 = queryMode;
-    this.l39_1 = autoTransposition;
-    this.m39_1 = prologStrictCompatibility;
-    this.n39_1 = graphBuildMode;
-    this.o39_1 = argumentLabellingMode;
-    this.p39_1 = statementLabellingMode;
-    this.q39_1 = orderingPrinciple;
-    this.r39_1 = orderingComparator;
-    this.s39_1 = modulesPath;
-    this.t39_1 = graphExtensions;
-  }
-  protoOf(FlagsBuilder).u39 = function () {
+    queryMode = queryMode === VOID ? QueryMode_instance.u3d() : queryMode;
+    autoTransposition = autoTransposition === VOID ? AutoTransposition_instance.u3d() : autoTransposition;
+    prologStrictCompatibility = prologStrictCompatibility === VOID ? PrologStrictCompatibility_instance.u3d() : prologStrictCompatibility;
+    graphBuildMode = graphBuildMode === VOID ? GraphBuildMode_instance.u3d() : graphBuildMode;
+    argumentLabellingMode = argumentLabellingMode === VOID ? ArgumentLabellingMode_instance.u3d() : argumentLabellingMode;
+    statementLabellingMode = statementLabellingMode === VOID ? StatementLabellingMode_instance.u3d() : statementLabellingMode;
+    orderingPrinciple = orderingPrinciple === VOID ? OrderingPrinciple_instance.u3d() : orderingPrinciple;
+    orderingComparator = orderingComparator === VOID ? OrderingComparator_instance.u3d() : orderingComparator;
+    modulesPath = modulesPath === VOID ? ModulesPath_instance.u3d() : modulesPath;
+    graphExtensions = graphExtensions === VOID ? GraphExtension_instance.u3d() : graphExtensions;
+    this.l39_1 = emptyBuilder;
+    this.m39_1 = queryMode;
+    this.n39_1 = autoTransposition;
+    this.o39_1 = prologStrictCompatibility;
+    this.p39_1 = graphBuildMode;
+    this.q39_1 = argumentLabellingMode;
+    this.r39_1 = statementLabellingMode;
+    this.s39_1 = orderingPrinciple;
+    this.t39_1 = orderingComparator;
+    this.u39_1 = modulesPath;
+    this.v39_1 = graphExtensions;
+  }
+  protoOf(FlagsBuilder).w39 = function () {
     return new FlagsBuilder$create$1(this);
   };
   protoOf(FlagsBuilder).toString = function () {
-    return 'FlagsBuilder(emptyBuilder=' + this.j39_1 + ', queryMode=' + this.k39_1 + ', autoTransposition=' + this.l39_1 + ', prologStrictCompatibility=' + this.m39_1 + ', graphBuildMode=' + this.n39_1 + ', argumentLabellingMode=' + this.o39_1 + ', statementLabellingMode=' + this.p39_1 + ', orderingPrinciple=' + this.q39_1 + ', orderingComparator=' + this.r39_1 + ', modulesPath=' + this.s39_1 + ', graphExtensions=' + toString(this.t39_1) + ')';
+    return 'FlagsBuilder(emptyBuilder=' + this.l39_1 + ', queryMode=' + this.m39_1 + ', autoTransposition=' + this.n39_1 + ', prologStrictCompatibility=' + this.o39_1 + ', graphBuildMode=' + this.p39_1 + ', argumentLabellingMode=' + this.q39_1 + ', statementLabellingMode=' + this.r39_1 + ', orderingPrinciple=' + this.s39_1 + ', orderingComparator=' + this.t39_1 + ', modulesPath=' + this.u39_1 + ', graphExtensions=' + toString(this.v39_1) + ')';
   };
   protoOf(FlagsBuilder).hashCode = function () {
-    var result = getBooleanHashCode(this.j39_1);
-    result = imul(result, 31) + getBooleanHashCode(this.k39_1) | 0;
-    result = imul(result, 31) + getBooleanHashCode(this.l39_1) | 0;
+    var result = getBooleanHashCode(this.l39_1);
     result = imul(result, 31) + getBooleanHashCode(this.m39_1) | 0;
-    result = imul(result, 31) + getStringHashCode(this.n39_1) | 0;
-    result = imul(result, 31) + getStringHashCode(this.o39_1) | 0;
+    result = imul(result, 31) + getBooleanHashCode(this.n39_1) | 0;
+    result = imul(result, 31) + getBooleanHashCode(this.o39_1) | 0;
     result = imul(result, 31) + getStringHashCode(this.p39_1) | 0;
     result = imul(result, 31) + getStringHashCode(this.q39_1) | 0;
     result = imul(result, 31) + getStringHashCode(this.r39_1) | 0;
     result = imul(result, 31) + getStringHashCode(this.s39_1) | 0;
-    result = imul(result, 31) + hashCode(this.t39_1) | 0;
+    result = imul(result, 31) + getStringHashCode(this.t39_1) | 0;
+    result = imul(result, 31) + getStringHashCode(this.u39_1) | 0;
+    result = imul(result, 31) + hashCode(this.v39_1) | 0;
     return result;
   };
   protoOf(FlagsBuilder).equals = function (other) {
@@ -2125,10 +2105,6 @@
       return true;
     if (!(other instanceof FlagsBuilder))
       return false;
-    if (!(this.j39_1 === other.j39_1))
-      return false;
-    if (!(this.k39_1 === other.k39_1))
-      return false;
     if (!(this.l39_1 === other.l39_1))
       return false;
     if (!(this.m39_1 === other.m39_1))
@@ -2145,20 +2121,24 @@
       return false;
     if (!(this.s39_1 === other.s39_1))
       return false;
-    if (!equals(this.t39_1, other.t39_1))
+    if (!(this.t39_1 === other.t39_1))
+      return false;
+    if (!(this.u39_1 === other.u39_1))
+      return false;
+    if (!equals(this.v39_1, other.v39_1))
       return false;
     return true;
   };
   function MetaInterpreter() {
-    this.w3d_1 = 'prolog.argumentation.meta.crossjustice';
+    this.v3d_1 = 'prolog.argumentation.meta.crossjustice';
   }
   protoOf(MetaInterpreter).y2b = function () {
-    return this.w3d_1;
+    return this.v3d_1;
   };
-  protoOf(MetaInterpreter).z39 = function () {
-    return Companion_getInstance_3().of(this.w3d_1, VOID, parseTheory(Companion_instance_0, '% with_facts_and_length/3\nwith_facts_and_length(X, Y, L) :-\n    solve(X, R),\n    recover_facts(R, Y),\n    length(Y, L).\n\n% lenght/2\n\nlength([], 0).\nlength([_|T], X) :- length(T, Y), X is Y + 1.\n\n% recover_facts/2\n\nrecover_facts([], []) :- !.\nrecover_facts([H|T], C) :-\n    is_list(H), !,\n    recover_facts(T, TC),\n    recover_facts(H, HC),\n    append(TC, HC, C).\nrecover_facts([H|T], C) :-\n    \\+ is_list(H),\n    recover_facts(T, TC),\n    evaluate(H, HC),\n    append(TC, HC, C).\n\nevaluate(user_fact(X), [X]) :- !.\nevaluate(_, []) :- !.\n\n% solve/2\n\nsolve((A,B), Result) :- !,\n    solve(A, ARes),\n    solve(B, BRes),\n    append(ARes, BRes, Result).\n\nsolve((A;B), Result) :- !,\n    solve(A, Result);\n    solve(B, Result).\n\nsolve(member(A, B), [system_predicate]) :- !,\n    call(member(A, B)).\n\nsolve(\\+(A), [not(A)]) :- !,\n    call(\\+(A)).\n\nsolve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n    call((A)\\=(B)).\n\nsolve(A, [system_predicate]) :-\n    catch(clause(A, _), B, true),\n    \\+ var(B), !,\n    call(A).\n\nsolve(A, [A]) :-\n    \\+ clause(A, B), !,\n    call(A).\n\nsolve(A, [A|[Res]]) :-\n    clause(A, B),\n    solve(B, Res).\n\n% is_list/1\n\nis_list(X) :- var(X), !, fail.\nis_list([]).\nis_list([_|T]) :- is_list(T).\n\n% fetch_argument_facts/2\n\nfetch_argument_facts(Conclusion, Facts) :-\n    argument([R, TR, [Conclusion]]),\n    findall(user_fact(Fact), \n        support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n    Facts).'));
+  protoOf(MetaInterpreter).y39 = function () {
+    return Companion_getInstance_2().of(this.v3d_1, VOID, parseTheory(Companion_instance_0, '% with_facts_and_length/3\nwith_facts_and_length(X, Y, L) :-\n    solve(X, R),\n    recover_facts(R, Y),\n    length(Y, L).\n\n% lenght/2\n\nlength([], 0).\nlength([_|T], X) :- length(T, Y), X is Y + 1.\n\n% recover_facts/2\n\nrecover_facts([], []) :- !.\nrecover_facts([H|T], C) :-\n    is_list(H), !,\n    recover_facts(T, TC),\n    recover_facts(H, HC),\n    append(TC, HC, C).\nrecover_facts([H|T], C) :-\n    \\+ is_list(H),\n    recover_facts(T, TC),\n    evaluate(H, HC),\n    append(TC, HC, C).\n\nevaluate(user_fact(X), [X]) :- !.\nevaluate(_, []) :- !.\n\n% solve/2\n\nsolve((A,B), Result) :- !,\n    solve(A, ARes),\n    solve(B, BRes),\n    append(ARes, BRes, Result).\n\nsolve((A;B), Result) :- !,\n    solve(A, Result);\n    solve(B, Result).\n\nsolve(member(A, B), [system_predicate]) :- !,\n    call(member(A, B)).\n\nsolve(\\+(A), [not(A)]) :- !,\n    call(\\+(A)).\n\nsolve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n    call((A)\\=(B)).\n\nsolve(A, [system_predicate]) :-\n    catch(clause(A, _), B, true),\n    \\+ var(B), !,\n    call(A).\n\nsolve(A, [A]) :-\n    \\+ clause(A, B), !,\n    call(A).\n\nsolve(A, [A|[Res]]) :-\n    clause(A, B),\n    solve(B, Res).\n\n% is_list/1\n\nis_list(X) :- var(X), !, fail.\nis_list([]).\nis_list([_|T]) :- is_list(T).\n\n% fetch_argument_facts/2\n\nfetch_argument_facts(Conclusion, Facts) :-\n    argument([R, TR, [Conclusion]]),\n    findall(user_fact(Fact), \n        support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n    Facts).'));
   };
-  protoOf(MetaInterpreter).a3a = function () {
+  protoOf(MetaInterpreter).z39 = function () {
     return 'interpreter';
   };
   var MetaInterpreter_instance;
@@ -2166,15 +2146,15 @@
     return MetaInterpreter_instance;
   }
   function ModuleCalls() {
-    this.x3d_1 = 'prolog.argumentation.modularity';
+    this.w3d_1 = 'prolog.argumentation.modularity';
   }
   protoOf(ModuleCalls).y2b = function () {
-    return this.x3d_1;
+    return this.w3d_1;
   };
-  protoOf(ModuleCalls).z39 = function () {
-    return Companion_getInstance_3().of(this.x3d_1, mapOf(to(ModuleCall_getInstance().y3d_1, ModuleCall_getInstance())));
+  protoOf(ModuleCalls).y39 = function () {
+    return Companion_getInstance_2().of(this.w3d_1, mapOf(to(ModuleCall_getInstance().x3d_1, ModuleCall_getInstance())));
   };
-  protoOf(ModuleCalls).a3a = function () {
+  protoOf(ModuleCalls).z39 = function () {
     return 'module';
   };
   var ModuleCalls_instance;
@@ -2200,9 +2180,9 @@
     return logicProgramming_0(VOID, ModuleCall$getCleanSolver$lambda_0(context, modules, module_0));
   }
   function ModuleCall$solve$slambda($solver, $goal, $request, resultContinuation) {
-    this.h3e_1 = $solver;
-    this.i3e_1 = $goal;
-    this.j3e_1 = $request;
+    this.g3e_1 = $solver;
+    this.h3e_1 = $goal;
+    this.i3e_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(ModuleCall$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -2223,8 +2203,8 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp_0 = this.h3e_1.solve(this.i3e_1);
-            suspendResult = this.k3e_1.sc(map(tmp_0, ModuleCall$solve$slambda$lambda(this.j3e_1)), this);
+            var tmp_0 = this.g3e_1.solve(this.h3e_1);
+            suspendResult = this.j3e_1.sc(map(tmp_0, ModuleCall$solve$slambda$lambda(this.i3e_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -2247,8 +2227,8 @@
      while (true);
   };
   protoOf(ModuleCall$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new ModuleCall$solve$slambda(this.h3e_1, this.i3e_1, this.j3e_1, completion);
-    i.k3e_1 = $this$sequence;
+    var i = new ModuleCall$solve$slambda(this.g3e_1, this.h3e_1, this.i3e_1, completion);
+    i.j3e_1 = $this$sequence;
     return i;
   };
   function ModuleCall$solve$slambda_0($solver, $goal, $request, resultContinuation) {
@@ -2296,7 +2276,7 @@
   }
   function ModuleCall() {
     ModuleCall_instance = this;
-    this.y3d_1 = new Signature('call_module', 2);
+    this.x3d_1 = new Signature('call_module', 2);
   }
   protoOf(ModuleCall).g2e = function (request) {
     var modules = request.arguments.w(0);
@@ -2332,10 +2312,10 @@
   }
   function ModulesPath() {
   }
-  protoOf(ModulesPath).s3d = function () {
+  protoOf(ModulesPath).r3d = function () {
     return 'modulesPath';
   };
-  protoOf(ModulesPath).v3d = function () {
+  protoOf(ModulesPath).u3d = function () {
     return 'none';
   };
   var ModulesPath_instance;
@@ -2344,27 +2324,27 @@
   }
   function AbstractModeBase() {
     LazyRawPrologContent.call(this);
-    this.m3e_1 = 'prolog.argumentation.abstract';
-    this.n3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.l3e_1 = 'prolog.argumentation.abstract';
+    this.m3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(AbstractModeBase).y2b = function () {
-    return this.m3e_1;
+    return this.l3e_1;
   };
-  protoOf(AbstractModeBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(AbstractModeBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(AbstractModeBase).a3a = function () {
+  protoOf(AbstractModeBase).z39 = function () {
     return 'abstract';
   };
   protoOf(AbstractModeBase).i39 = function () {
-    return this.n3e_1;
+    return this.m3e_1;
   };
   function GraphExtension() {
   }
-  protoOf(GraphExtension).s3d = function () {
+  protoOf(GraphExtension).r3d = function () {
     return 'graphExtension';
   };
-  protoOf(GraphExtension).v3d = function () {
+  protoOf(GraphExtension).u3d = function () {
     return listOf_0('standardPref');
   };
   var GraphExtension_instance;
@@ -2373,10 +2353,10 @@
   }
   function ArgumentLabellingMode() {
   }
-  protoOf(ArgumentLabellingMode).s3d = function () {
+  protoOf(ArgumentLabellingMode).r3d = function () {
     return 'argumentLabellingMode';
   };
-  protoOf(ArgumentLabellingMode).v3d = function () {
+  protoOf(ArgumentLabellingMode).u3d = function () {
     return 'grounded';
   };
   var ArgumentLabellingMode_instance;
@@ -2385,10 +2365,10 @@
   }
   function StatementLabellingMode() {
   }
-  protoOf(StatementLabellingMode).s3d = function () {
+  protoOf(StatementLabellingMode).r3d = function () {
     return 'statementLabellingMode';
   };
-  protoOf(StatementLabellingMode).v3d = function () {
+  protoOf(StatementLabellingMode).u3d = function () {
     return 'statement';
   };
   var StatementLabellingMode_instance;
@@ -2397,10 +2377,10 @@
   }
   function GraphBuildMode() {
   }
-  protoOf(GraphBuildMode).s3d = function () {
+  protoOf(GraphBuildMode).r3d = function () {
     return 'graphBuildMode';
   };
-  protoOf(GraphBuildMode).v3d = function () {
+  protoOf(GraphBuildMode).u3d = function () {
     return 'standard_af';
   };
   var GraphBuildMode_instance;
@@ -2409,122 +2389,122 @@
   }
   function ArgumentationGraphBuilderBase() {
     LazyRawPrologContent.call(this);
-    this.p3e_1 = 'prolog.argumentation.graph';
-    this.q3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.o3e_1 = 'prolog.argumentation.graph';
+    this.p3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(ArgumentationGraphBuilderBase).y2b = function () {
-    return this.p3e_1;
+    return this.o3e_1;
   };
-  protoOf(ArgumentationGraphBuilderBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(ArgumentationGraphBuilderBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(ArgumentationGraphBuilderBase).a3a = function () {
+  protoOf(ArgumentationGraphBuilderBase).z39 = function () {
     return 'standard_af';
   };
   protoOf(ArgumentationGraphBuilderBase).i39 = function () {
-    return this.q3e_1;
+    return this.p3e_1;
   };
   function AttackRestrictionHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.s3e_1 = 'prolog.argumentation.graph.rebutrestriction';
-    this.t3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.r3e_1 = 'prolog.argumentation.graph.rebutrestriction';
+    this.s3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(AttackRestrictionHandlerBase).y2b = function () {
-    return this.s3e_1;
+    return this.r3e_1;
   };
-  protoOf(AttackRestrictionHandlerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(AttackRestrictionHandlerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(AttackRestrictionHandlerBase).a3a = function () {
+  protoOf(AttackRestrictionHandlerBase).z39 = function () {
     return 'rebutRestriction';
   };
   protoOf(AttackRestrictionHandlerBase).i39 = function () {
-    return this.t3e_1;
+    return this.s3e_1;
   };
   function BpMetaGraphHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.v3e_1 = 'prolog.argumentation.graph.meta.bp';
-    this.w3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.u3e_1 = 'prolog.argumentation.graph.meta.bp';
+    this.v3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpMetaGraphHandlerBase).y2b = function () {
-    return this.v3e_1;
+    return this.u3e_1;
   };
-  protoOf(BpMetaGraphHandlerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(BpMetaGraphHandlerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(BpMetaGraphHandlerBase).a3a = function () {
+  protoOf(BpMetaGraphHandlerBase).z39 = function () {
     return 'bp';
   };
   protoOf(BpMetaGraphHandlerBase).i39 = function () {
-    return this.w3e_1;
+    return this.v3e_1;
   };
   function DefeasiblePreferencesHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.y3e_1 = 'prolog.argumentation.graph.preferences.defeasible';
-    this.z3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.x3e_1 = 'prolog.argumentation.graph.preferences.defeasible';
+    this.y3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(DefeasiblePreferencesHandlerBase).y2b = function () {
-    return this.y3e_1;
+    return this.x3e_1;
   };
-  protoOf(DefeasiblePreferencesHandlerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(DefeasiblePreferencesHandlerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(DefeasiblePreferencesHandlerBase).a3a = function () {
+  protoOf(DefeasiblePreferencesHandlerBase).z39 = function () {
     return 'defeasiblePref';
   };
   protoOf(DefeasiblePreferencesHandlerBase).i39 = function () {
-    return this.z3e_1;
+    return this.y3e_1;
   };
   function GenericDefeasiblePreferencesHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.b3f_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
-    this.c3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.a3f_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
+    this.b3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(GenericDefeasiblePreferencesHandlerBase).y2b = function () {
-    return this.b3f_1;
+    return this.a3f_1;
   };
-  protoOf(GenericDefeasiblePreferencesHandlerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(GenericDefeasiblePreferencesHandlerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(GenericDefeasiblePreferencesHandlerBase).a3a = function () {
+  protoOf(GenericDefeasiblePreferencesHandlerBase).z39 = function () {
     return 'defeasibleAllPref';
   };
   protoOf(GenericDefeasiblePreferencesHandlerBase).i39 = function () {
-    return this.c3f_1;
+    return this.b3f_1;
   };
   function StrictPreferencesHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.e3f_1 = 'prolog.argumentation.graph.preferences.strict';
-    this.f3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.d3f_1 = 'prolog.argumentation.graph.preferences.strict';
+    this.e3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(StrictPreferencesHandlerBase).y2b = function () {
-    return this.e3f_1;
+    return this.d3f_1;
   };
-  protoOf(StrictPreferencesHandlerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(StrictPreferencesHandlerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(StrictPreferencesHandlerBase).a3a = function () {
+  protoOf(StrictPreferencesHandlerBase).z39 = function () {
     return 'standardPref';
   };
   protoOf(StrictPreferencesHandlerBase).i39 = function () {
-    return this.f3f_1;
+    return this.e3f_1;
   };
   function BinaryStatementLabeller() {
     BinaryStatementLabeller_instance = this;
-    this.g3f_1 = 'prolog.argumentation.graph.labelling.statement.binary';
-    this.h3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.f3f_1 = 'prolog.argumentation.graph.labelling.statement.binary';
+    this.g3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BinaryStatementLabeller).y2b = function () {
-    return this.g3f_1;
+    return this.f3f_1;
   };
-  protoOf(BinaryStatementLabeller).z39 = function () {
-    return Companion_getInstance_3().of(this.g3f_1, VOID, Companion_instance_0.ofWithDefaultUnificator([BinaryLabelling_getInstance().n1s()]));
+  protoOf(BinaryStatementLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.f3f_1, VOID, Companion_instance_0.ofWithDefaultUnificator([BinaryLabelling_getInstance().n1s()]));
   };
-  protoOf(BinaryStatementLabeller).a3a = function () {
+  protoOf(BinaryStatementLabeller).z39 = function () {
     return 'statement_binary';
   };
   protoOf(BinaryStatementLabeller).i39 = function () {
-    return this.h3f_1;
+    return this.g3f_1;
   };
   var BinaryStatementLabeller_instance;
   function BinaryStatementLabeller_getInstance() {
@@ -2550,122 +2530,122 @@
   }
   function BpCompleteLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.m3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
-    this.n3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.l3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
+    this.m3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpCompleteLabellerBase).y2b = function () {
-    return this.m3f_1;
+    return this.l3f_1;
   };
-  protoOf(BpCompleteLabellerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(BpCompleteLabellerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(BpCompleteLabellerBase).a3a = function () {
+  protoOf(BpCompleteLabellerBase).z39 = function () {
     return 'bp_grounded_complete';
   };
   protoOf(BpCompleteLabellerBase).i39 = function () {
-    return this.n3f_1;
+    return this.m3f_1;
   };
   function BpLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.p3f_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
-    this.q3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.o3f_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
+    this.p3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpLabellerBase).y2b = function () {
-    return this.p3f_1;
+    return this.o3f_1;
   };
-  protoOf(BpLabellerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(BpLabellerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(BpLabellerBase).a3a = function () {
+  protoOf(BpLabellerBase).z39 = function () {
     return 'bp_grounded';
   };
   protoOf(BpLabellerBase).i39 = function () {
-    return this.q3f_1;
+    return this.p3f_1;
   };
   function BpPartialLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.s3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
-    this.t3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.r3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
+    this.s3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpPartialLabellerBase).y2b = function () {
-    return this.s3f_1;
+    return this.r3f_1;
   };
-  protoOf(BpPartialLabellerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(BpPartialLabellerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(BpPartialLabellerBase).a3a = function () {
+  protoOf(BpPartialLabellerBase).z39 = function () {
     return 'bp_grounded_partial';
   };
   protoOf(BpPartialLabellerBase).i39 = function () {
-    return this.t3f_1;
+    return this.s3f_1;
   };
   function CompleteLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.v3f_1 = 'prolog.argumentation.graph.labelling.complete';
-    this.w3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.u3f_1 = 'prolog.argumentation.graph.labelling.complete';
+    this.v3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(CompleteLabellerBase).y2b = function () {
-    return this.v3f_1;
+    return this.u3f_1;
   };
-  protoOf(CompleteLabellerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(CompleteLabellerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(CompleteLabellerBase).a3a = function () {
+  protoOf(CompleteLabellerBase).z39 = function () {
     return 'complete';
   };
   protoOf(CompleteLabellerBase).i39 = function () {
-    return this.w3f_1;
+    return this.v3f_1;
   };
   function GroundedLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.y3f_1 = 'prolog.argumentation.graph.labelling.grounded';
-    this.z3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.x3f_1 = 'prolog.argumentation.graph.labelling.grounded';
+    this.y3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(GroundedLabellerBase).y2b = function () {
-    return this.y3f_1;
+    return this.x3f_1;
   };
-  protoOf(GroundedLabellerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(GroundedLabellerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(GroundedLabellerBase).a3a = function () {
+  protoOf(GroundedLabellerBase).z39 = function () {
     return 'grounded';
   };
   protoOf(GroundedLabellerBase).i39 = function () {
-    return this.z3f_1;
+    return this.y3f_1;
   };
   function GroundedLabellerOptimizedBase() {
     LazyRawPrologContent.call(this);
-    this.b3g_1 = 'prolog.argumentation.graph.labelling.grounded.optimized';
-    this.c3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.a3g_1 = 'prolog.argumentation.graph.labelling.grounded.optimized';
+    this.b3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(GroundedLabellerOptimizedBase).y2b = function () {
-    return this.b3g_1;
+    return this.a3g_1;
   };
-  protoOf(GroundedLabellerOptimizedBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(GroundedLabellerOptimizedBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(GroundedLabellerOptimizedBase).a3a = function () {
+  protoOf(GroundedLabellerOptimizedBase).z39 = function () {
     return 'grounded_hash';
   };
   protoOf(GroundedLabellerOptimizedBase).i39 = function () {
-    return this.c3g_1;
+    return this.b3g_1;
   };
   function PassThroughStatementLabeller() {
     PassThroughStatementLabeller_instance = this;
-    this.d3g_1 = 'prolog.argumentation.graph.labelling.statement.pt';
-    this.e3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.c3g_1 = 'prolog.argumentation.graph.labelling.statement.pt';
+    this.d3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(PassThroughStatementLabeller).y2b = function () {
-    return this.d3g_1;
+    return this.c3g_1;
   };
-  protoOf(PassThroughStatementLabeller).z39 = function () {
-    return Companion_getInstance_3().of(this.d3g_1, VOID, Companion_instance_0.ofWithDefaultUnificator([Labelling_getInstance().n1s()]));
+  protoOf(PassThroughStatementLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.c3g_1, VOID, Companion_instance_0.ofWithDefaultUnificator([Labelling_getInstance().n1s()]));
   };
-  protoOf(PassThroughStatementLabeller).a3a = function () {
+  protoOf(PassThroughStatementLabeller).z39 = function () {
     return 'statement_pass_through';
   };
   protoOf(PassThroughStatementLabeller).i39 = function () {
-    return this.e3g_1;
+    return this.d3g_1;
   };
   var PassThroughStatementLabeller_instance;
   function PassThroughStatementLabeller_getInstance() {
@@ -2691,20 +2671,20 @@
   }
   function StatementLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.j3g_1 = 'prolog.argumentation.graph.labelling.statement';
-    this.k3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.i3g_1 = 'prolog.argumentation.graph.labelling.statement';
+    this.j3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(StatementLabellerBase).y2b = function () {
-    return this.j3g_1;
+    return this.i3g_1;
   };
-  protoOf(StatementLabellerBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(StatementLabellerBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(StatementLabellerBase).a3a = function () {
+  protoOf(StatementLabellerBase).z39 = function () {
     return 'statement';
   };
   protoOf(StatementLabellerBase).i39 = function () {
-    return this.k3g_1;
+    return this.j3g_1;
   };
   function Companion_2() {
   }
@@ -2766,14 +2746,14 @@
   }
   function RuleParserBase() {
     LazyRawPrologContent.call(this);
-    this.m3g_1 = 'prolog.argumentation.parser';
-    this.n3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_instance_10.d39()).plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.l3g_1 = 'prolog.argumentation.parser';
+    this.m3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_instance_10.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(RuleParserBase).y2b = function () {
-    return this.m3g_1;
+    return this.l3g_1;
   };
-  protoOf(RuleParserBase).z39 = function () {
-    var tmp = Companion_getInstance_3();
+  protoOf(RuleParserBase).y39 = function () {
+    var tmp = Companion_getInstance_2();
     var tmp_0 = this.y2b();
     var tmp_1 = KProperty0;
     var tmp_2 = getPropertyCallableRef('descriptionPair', 0, tmp_1, StrictRules$_get_descriptionPair_$ref_jme898(StrictRules_getInstance()), null).get();
@@ -2788,13 +2768,13 @@
     var tmp_11 = KProperty0;
     var tmp_12 = getPropertyCallableRef('descriptionPair', 0, tmp_11, ExtractStrictIds$_get_descriptionPair_$ref_faxu5w(ExtractStrictIds_getInstance()), null).get();
     var tmp_13 = KProperty0;
-    return tmp.of(tmp_0, mapOf_0([tmp_2, tmp_4, tmp_6, tmp_8, tmp_10, tmp_12, getPropertyCallableRef('descriptionPair', 0, tmp_13, RuleToClause$_get_descriptionPair_$ref_20povg(RuleToClause_getInstance()), null).get()]), this.d3a(), Companion_instance_10.d39());
+    return tmp.of(tmp_0, mapOf_0([tmp_2, tmp_4, tmp_6, tmp_8, tmp_10, tmp_12, getPropertyCallableRef('descriptionPair', 0, tmp_13, RuleToClause$_get_descriptionPair_$ref_20povg(RuleToClause_getInstance()), null).get()]), this.c3a(), Companion_instance_10.d39());
   };
-  protoOf(RuleParserBase).a3a = function () {
+  protoOf(RuleParserBase).z39 = function () {
     return 'parser';
   };
   protoOf(RuleParserBase).i39 = function () {
-    return this.n3g_1;
+    return this.m3g_1;
   };
   function StrictRules$computeAllSubstitutions$lambda($this_computeAllSubstitutions) {
     return function (clauses, prologScope) {
@@ -2814,7 +2794,7 @@
       var _iterator__ex2g4s_0 = destination.p();
       while (_iterator__ex2g4s_0.s()) {
         var item = _iterator__ex2g4s_0.t();
-        var tmp$ret$3 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.o3g(item, $this_computeAllSubstitutions), ensureNotNull(item.nw())]);
+        var tmp$ret$3 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.n3g(item, $this_computeAllSubstitutions), ensureNotNull(item.nw())]);
         destination_0.m(tmp$ret$3);
       }
       return listToTerm(destination_0);
@@ -2824,12 +2804,12 @@
     StrictRules_instance = this;
     WithoutSideEffects.call(this, 'prologStrictRules');
   }
-  protoOf(StrictRules).q3g = function (_this__u8e3s4, first) {
+  protoOf(StrictRules).p3g = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.r3g(_this__u8e3s4, first, VOID, StrictRules$computeAllSubstitutions$lambda(_this__u8e3s4));
+    return tmp.q3g(_this__u8e3s4, first, VOID, StrictRules$computeAllSubstitutions$lambda(_this__u8e3s4));
   };
   protoOf(StrictRules).x2g = function (_this__u8e3s4, first) {
-    return this.q3g(_this__u8e3s4, first);
+    return this.p3g(_this__u8e3s4, first);
   };
   var StrictRules_instance;
   function StrictRules_getInstance() {
@@ -2863,12 +2843,12 @@
     Axioms_instance = this;
     WithoutSideEffects.call(this, 'prologAxioms');
   }
-  protoOf(Axioms).q3g = function (_this__u8e3s4, first) {
+  protoOf(Axioms).p3g = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.r3g(_this__u8e3s4, first, VOID, Axioms$computeAllSubstitutions$lambda);
+    return tmp.q3g(_this__u8e3s4, first, VOID, Axioms$computeAllSubstitutions$lambda);
   };
   protoOf(Axioms).x2g = function (_this__u8e3s4, first) {
-    return this.q3g(_this__u8e3s4, first);
+    return this.p3g(_this__u8e3s4, first);
   };
   var Axioms_instance;
   function Axioms_getInstance() {
@@ -2900,7 +2880,7 @@
     var _iterator__ex2g4s_0 = destination.p();
     while (_iterator__ex2g4s_0.s()) {
       var item = _iterator__ex2g4s_0.t();
-      var tmp$ret$3 = Companion_getInstance().of('abstractBp', [prologScope.logicListOfIterable(ensureNotNull(item.nw()).iu())]);
+      var tmp$ret$3 = Companion_getInstance_7().of('abstractBp', [prologScope.logicListOfIterable(ensureNotNull(item.nw()).iu())]);
       destination_0.m(tmp$ret$3);
     }
     return listToTerm(destination_0);
@@ -2909,12 +2889,12 @@
     Bps_instance = this;
     WithoutSideEffects.call(this, 'bpsNew');
   }
-  protoOf(Bps).q3g = function (_this__u8e3s4, first) {
+  protoOf(Bps).p3g = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.u3g(_this__u8e3s4, first, true, Bps$computeAllSubstitutions$lambda);
+    return tmp.t3g(_this__u8e3s4, first, true, Bps$computeAllSubstitutions$lambda);
   };
   protoOf(Bps).x2g = function (_this__u8e3s4, first) {
-    return this.q3g(_this__u8e3s4, first);
+    return this.p3g(_this__u8e3s4, first);
   };
   var Bps_instance;
   function Bps_getInstance() {
@@ -2948,12 +2928,12 @@
     Premises_instance = this;
     WithoutSideEffects.call(this, 'prologPremises');
   }
-  protoOf(Premises).q3g = function (_this__u8e3s4, first) {
+  protoOf(Premises).p3g = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.r3g(_this__u8e3s4, first, VOID, Premises$computeAllSubstitutions$lambda);
+    return tmp.q3g(_this__u8e3s4, first, VOID, Premises$computeAllSubstitutions$lambda);
   };
   protoOf(Premises).x2g = function (_this__u8e3s4, first) {
-    return this.q3g(_this__u8e3s4, first);
+    return this.p3g(_this__u8e3s4, first);
   };
   var Premises_instance;
   function Premises_getInstance() {
@@ -3019,7 +2999,7 @@
         }
         // Inline function 'kotlin.let' call
         var it = tmp_3;
-        var tmp$ret$6 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.o3g(it, $this_computeAllSubstitutions), ensureNotNull(it.nw())]);
+        var tmp$ret$6 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.n3g(it, $this_computeAllSubstitutions), ensureNotNull(it.nw())]);
         destination_0.m(tmp$ret$6);
       }
       return listToTerm(destination_0);
@@ -3029,12 +3009,12 @@
     DefeasibleRules_instance = this;
     WithoutSideEffects.call(this, 'prologDefeasibleRules');
   }
-  protoOf(DefeasibleRules).q3g = function (_this__u8e3s4, first) {
+  protoOf(DefeasibleRules).p3g = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.r3g(_this__u8e3s4, first, VOID, DefeasibleRules$computeAllSubstitutions$lambda(_this__u8e3s4));
+    return tmp.q3g(_this__u8e3s4, first, VOID, DefeasibleRules$computeAllSubstitutions$lambda(_this__u8e3s4));
   };
   protoOf(DefeasibleRules).x2g = function (_this__u8e3s4, first) {
-    return this.q3g(_this__u8e3s4, first);
+    return this.p3g(_this__u8e3s4, first);
   };
   var DefeasibleRules_instance;
   function DefeasibleRules_getInstance() {
@@ -3047,7 +3027,7 @@
     WithoutSideEffects_0.call(this, 'extract_id');
   }
   protoOf(ExtractStrictIds).a2m = function (_this__u8e3s4, first, second) {
-    var tmp = Companion_getInstance_4();
+    var tmp = Companion_getInstance_3();
     var tmp_0 = ensureNotNull(second.asVar());
     var tmp_1 = Companion_instance_6;
     // Inline function 'kotlin.collections.map' call
@@ -3057,7 +3037,7 @@
     var _iterator__ex2g4s = this_0.p();
     while (_iterator__ex2g4s.s()) {
       var item = _iterator__ex2g4s.t();
-      var tmp$ret$0 = Companion_getInstance().of('strict', [ensureNotNull(item.asCons()).nw()]);
+      var tmp$ret$0 = Companion_getInstance_7().of('strict', [ensureNotNull(item.asCons()).nw()]);
       destination.m(tmp$ret$0);
     }
     return sequenceOf(tmp.of(tmp_0, tmp_1.ofList(destination)));
@@ -3076,7 +3056,7 @@
     WithoutSideEffects_0.call(this, 'rule_to_clause');
   }
   protoOf(RuleToClause).a2m = function (_this__u8e3s4, first, second) {
-    var tmp = Companion_getInstance_4();
+    var tmp = Companion_getInstance_3();
     var tmp_0 = ensureNotNull(second.asVar());
     var tmp_1 = Companion_instance_6;
     // Inline function 'kotlin.collections.map' call
@@ -3091,10 +3071,10 @@
       var tmp_2;
       switch (it.v()) {
         case 2:
-          tmp_2 = Companion_getInstance_7().pw(Companion_getInstance().of('rl', [it.w(1)]), [item]);
+          tmp_2 = Companion_getInstance_6().pw(Companion_getInstance_7().of('rl', [it.w(1)]), [item]);
           break;
         case 3:
-          tmp_2 = Companion_getInstance_7().pw(Companion_getInstance().of('rl', [it.w(2)]), [item]);
+          tmp_2 = Companion_getInstance_6().pw(Companion_getInstance_7().of('rl', [it.w(2)]), [item]);
           break;
         default:
           throw IllegalArgumentException_init_$Create$();
@@ -3115,10 +3095,10 @@
   }
   function AutoTransposition() {
   }
-  protoOf(AutoTransposition).s3d = function () {
+  protoOf(AutoTransposition).r3d = function () {
     return 'autoTransposition';
   };
-  protoOf(AutoTransposition).v3d = function () {
+  protoOf(AutoTransposition).u3d = function () {
     return false;
   };
   var AutoTransposition_instance;
@@ -3127,10 +3107,10 @@
   }
   function PrologStrictCompatibility() {
   }
-  protoOf(PrologStrictCompatibility).s3d = function () {
+  protoOf(PrologStrictCompatibility).r3d = function () {
     return 'prologStrictCompatibility';
   };
-  protoOf(PrologStrictCompatibility).v3d = function () {
+  protoOf(PrologStrictCompatibility).u3d = function () {
     return false;
   };
   var PrologStrictCompatibility_instance;
@@ -3179,10 +3159,10 @@
   }
   function ConversionUtils$commonMap$lambda($first, $force, $context, $mapper) {
     return function ($this$prolog) {
-      var tmp = Companion_getInstance_4();
+      var tmp = Companion_getInstance_3();
       var tmp_0 = $first.castToVar();
       var tmp_1;
-      if ($force || first($context.solve(parseStruct(Companion_getInstance(), 'prologStrictCompatibility'))).d1u()) {
+      if ($force || first($context.solve(parseStruct(Companion_getInstance_7(), 'prologStrictCompatibility'))).d1u()) {
         tmp_1 = $mapper($context.context.b1t().l1j(), $this$prolog);
       } else {
         tmp_1 = $this$prolog.vz();
@@ -3192,16 +3172,16 @@
   }
   function ConversionUtils() {
   }
-  protoOf(ConversionUtils).o3g = function (target, context) {
+  protoOf(ConversionUtils).n3g = function (target, context) {
     return prolog(VOID, ConversionUtils$modifiers$lambda(target, context));
   };
-  protoOf(ConversionUtils).u3g = function (context, first, force, mapper) {
+  protoOf(ConversionUtils).t3g = function (context, first, force, mapper) {
     Companion_getInstance_9().v2e(context, 0);
     return prolog(VOID, ConversionUtils$commonMap$lambda(first, force, context, mapper));
   };
-  protoOf(ConversionUtils).r3g = function (context, first, force, mapper, $super) {
+  protoOf(ConversionUtils).q3g = function (context, first, force, mapper, $super) {
     force = force === VOID ? false : force;
-    return $super === VOID ? this.u3g(context, first, force, mapper) : $super.u3g.call(this, context, first, force, mapper);
+    return $super === VOID ? this.t3g(context, first, force, mapper) : $super.t3g.call(this, context, first, force, mapper);
   };
   var ConversionUtils_instance;
   function ConversionUtils_getInstance() {
@@ -3209,27 +3189,27 @@
   }
   function StructuredModeBase() {
     LazyRawPrologContent.call(this);
-    this.a3h_1 = 'prolog.argumentation.structured';
-    this.b3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.z3g_1 = 'prolog.argumentation.structured';
+    this.a3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(StructuredModeBase).y2b = function () {
-    return this.a3h_1;
+    return this.z3g_1;
   };
-  protoOf(StructuredModeBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(StructuredModeBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(StructuredModeBase).a3a = function () {
+  protoOf(StructuredModeBase).z39 = function () {
     return 'structured';
   };
   protoOf(StructuredModeBase).i39 = function () {
-    return this.b3h_1;
+    return this.a3h_1;
   };
   function QueryMode() {
   }
-  protoOf(QueryMode).s3d = function () {
+  protoOf(QueryMode).r3d = function () {
     return 'queryMode';
   };
-  protoOf(QueryMode).v3d = function () {
+  protoOf(QueryMode).u3d = function () {
     return true;
   };
   var QueryMode_instance;
@@ -3238,61 +3218,61 @@
   }
   function AttackRelationBase() {
     LazyRawPrologContent.call(this);
-    this.d3h_1 = 'prolog.argumentation.attack';
-    this.e3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.c3h_1 = 'prolog.argumentation.attack';
+    this.d3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(AttackRelationBase).y2b = function () {
-    return this.d3h_1;
+    return this.c3h_1;
   };
-  protoOf(AttackRelationBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(AttackRelationBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(AttackRelationBase).a3a = function () {
+  protoOf(AttackRelationBase).z39 = function () {
     return 'attack';
   };
   protoOf(AttackRelationBase).i39 = function () {
-    return this.e3h_1;
+    return this.d3h_1;
   };
   function DebugBase() {
     LazyRawPrologContent.call(this);
-    this.g3h_1 = 'prolog.argumentation.debug';
-    this.h3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.f3h_1 = 'prolog.argumentation.debug';
+    this.g3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(DebugBase).y2b = function () {
-    return this.g3h_1;
+    return this.f3h_1;
   };
-  protoOf(DebugBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(DebugBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(DebugBase).a3a = function () {
+  protoOf(DebugBase).z39 = function () {
     return 'debug';
   };
   protoOf(DebugBase).i39 = function () {
-    return this.h3h_1;
+    return this.g3h_1;
   };
   function SuperiorityRelationBase() {
     LazyRawPrologContent.call(this);
-    this.j3h_1 = 'prolog.argumentation.superiority';
-    this.k3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.i3h_1 = 'prolog.argumentation.superiority';
+    this.j3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(SuperiorityRelationBase).y2b = function () {
-    return this.j3h_1;
+    return this.i3h_1;
   };
-  protoOf(SuperiorityRelationBase).z39 = function () {
-    return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
+  protoOf(SuperiorityRelationBase).y39 = function () {
+    return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
-  protoOf(SuperiorityRelationBase).a3a = function () {
+  protoOf(SuperiorityRelationBase).z39 = function () {
     return 'superiority';
   };
   protoOf(SuperiorityRelationBase).i39 = function () {
-    return this.k3h_1;
+    return this.j3h_1;
   };
   function OrderingPrinciple() {
   }
-  protoOf(OrderingPrinciple).s3d = function () {
+  protoOf(OrderingPrinciple).r3d = function () {
     return 'orderingPrinciple';
   };
-  protoOf(OrderingPrinciple).v3d = function () {
+  protoOf(OrderingPrinciple).u3d = function () {
     return 'last';
   };
   var OrderingPrinciple_instance;
@@ -3301,10 +3281,10 @@
   }
   function OrderingComparator() {
   }
-  protoOf(OrderingComparator).s3d = function () {
+  protoOf(OrderingComparator).r3d = function () {
     return 'orderingComparator';
   };
-  protoOf(OrderingComparator).v3d = function () {
+  protoOf(OrderingComparator).u3d = function () {
     return 'elitist';
   };
   var OrderingComparator_instance;
@@ -3313,35 +3293,35 @@
   }
   function UtilsBase() {
     LazyRawPrologContent.call(this);
-    this.m3h_1 = 'prolog.argumentation.utils';
-    this.n3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
+    this.l3h_1 = 'prolog.argumentation.utils';
+    this.m3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(UtilsBase).y2b = function () {
-    return this.m3h_1;
+    return this.l3h_1;
   };
-  protoOf(UtilsBase).z39 = function () {
-    var tmp0_$this = Companion_getInstance_3();
+  protoOf(UtilsBase).y39 = function () {
+    var tmp0_$this = Companion_getInstance_2();
     var tmp1_alias = this.y2b();
-    var tmp2_clauses = this.d3a();
-    var tmp = to(AppendOptimized_getInstance().o3h_1, AppendOptimized_getInstance());
-    var tmp_0 = to(AssertAll_getInstance().p3h_1, AssertAll_getInstance());
+    var tmp2_clauses = this.c3a();
+    var tmp = to(AppendOptimized_getInstance().n3h_1, AppendOptimized_getInstance());
+    var tmp_0 = to(AssertAll_getInstance().o3h_1, AssertAll_getInstance());
     // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.descriptionPair' call
     var this_0 = ArgumentHash_getInstance();
     var tmp$ret$0 = to(this_0.signature, this_0.n1s());
-    var tmp3_primitives = mapOf_0([tmp, tmp_0, tmp$ret$0, to(Contains_getInstance().q3h_1, Contains_getInstance()), to(ContainsAny_getInstance().r3h_1, ContainsAny_getInstance())]);
+    var tmp3_primitives = mapOf_0([tmp, tmp_0, tmp$ret$0, to(Contains_getInstance().p3h_1, Contains_getInstance()), to(ContainsAny_getInstance().q3h_1, ContainsAny_getInstance())]);
     return tmp0_$this.of(tmp1_alias, tmp3_primitives, tmp2_clauses);
   };
-  protoOf(UtilsBase).a3a = function () {
+  protoOf(UtilsBase).z39 = function () {
     return 'utils';
   };
   protoOf(UtilsBase).i39 = function () {
-    return this.n3h_1;
+    return this.m3h_1;
   };
   function AppendOptimized$solve$slambda($request, $res, $list1, $list2, resultContinuation) {
-    this.a3i_1 = $request;
-    this.b3i_1 = $res;
-    this.c3i_1 = $list1;
-    this.d3i_1 = $list2;
+    this.z3h_1 = $request;
+    this.a3i_1 = $res;
+    this.b3i_1 = $list1;
+    this.c3i_1 = $list2;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(AppendOptimized$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3362,7 +3342,7 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            suspendResult = this.e3i_1.pc(this.a3i_1.replyWith(Companion_getInstance_4().of(this.b3i_1, Companion_instance_6.ofList(plus(this.c3i_1.toList(), this.d3i_1.toList()))), VOID, []), this);
+            suspendResult = this.d3i_1.pc(this.z3h_1.replyWith(Companion_getInstance_3().of(this.a3i_1, Companion_instance_6.ofList(plus(this.b3i_1.toList(), this.c3i_1.toList()))), VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3385,8 +3365,8 @@
      while (true);
   };
   protoOf(AppendOptimized$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new AppendOptimized$solve$slambda(this.a3i_1, this.b3i_1, this.c3i_1, this.d3i_1, completion);
-    i.e3i_1 = $this$sequence;
+    var i = new AppendOptimized$solve$slambda(this.z3h_1, this.a3i_1, this.b3i_1, this.c3i_1, completion);
+    i.d3i_1 = $this$sequence;
     return i;
   };
   function AppendOptimized$solve$slambda_0($request, $res, $list1, $list2, resultContinuation) {
@@ -3399,7 +3379,7 @@
   }
   function AppendOptimized() {
     AppendOptimized_instance = this;
-    this.o3h_1 = new Signature('append_fast', 3);
+    this.n3h_1 = new Signature('append_fast', 3);
   }
   protoOf(AppendOptimized).g2e = function (request) {
     var list1 = request.arguments.w(0);
@@ -3437,7 +3417,7 @@
     };
   }
   function AssertAll$solve$slambda($request, resultContinuation) {
-    this.n3i_1 = $request;
+    this.m3i_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(AssertAll$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3458,7 +3438,7 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            suspendResult = this.o3i_1.pc(this.n3i_1.replyWithCondition(true, VOID, []), this);
+            suspendResult = this.n3i_1.pc(this.m3i_1.replyWithCondition(true, VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3481,8 +3461,8 @@
      while (true);
   };
   protoOf(AssertAll$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new AssertAll$solve$slambda(this.n3i_1, completion);
-    i.o3i_1 = $this$sequence;
+    var i = new AssertAll$solve$slambda(this.m3i_1, completion);
+    i.n3i_1 = $this$sequence;
     return i;
   };
   function AssertAll$solve$slambda_0($request, resultContinuation) {
@@ -3495,7 +3475,7 @@
   }
   function AssertAll() {
     AssertAll_instance = this;
-    this.p3h_1 = new Signature('assert_all', 1);
+    this.o3h_1 = new Signature('assert_all', 1);
   }
   protoOf(AssertAll).g2e = function (request) {
     var list = request.arguments.w(0);
@@ -3519,7 +3499,7 @@
     WithoutSideEffects_0.call(this, 'hash');
   }
   protoOf(ArgumentHash).a2m = function (_this__u8e3s4, first, second) {
-    return sequenceOf(Companion_getInstance_4().of(ensureNotNull(second.asVar()), Companion_getInstance_5().ofInteger(getStringHashCode(first.toString()))));
+    return sequenceOf(Companion_getInstance_3().of(ensureNotNull(second.asVar()), Companion_getInstance_4().ofInteger(getStringHashCode(first.toString()))));
   };
   protoOf(ArgumentHash).v2d = function (_this__u8e3s4, first, second) {
     return this.a2m(_this__u8e3s4, first, second);
@@ -3531,9 +3511,9 @@
     return ArgumentHash_instance;
   }
   function Contains$solve$slambda($request, $list, $elem, resultContinuation) {
-    this.y3i_1 = $request;
-    this.z3i_1 = $list;
-    this.a3j_1 = $elem;
+    this.x3i_1 = $request;
+    this.y3i_1 = $list;
+    this.z3i_1 = $elem;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(Contains$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3554,7 +3534,7 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp0 = this.z3i_1.toList();
+            var tmp0 = this.y3i_1.toList();
             var tmp$ret$0;
             l$ret$1: do {
               var tmp_0;
@@ -3570,7 +3550,7 @@
               var _iterator__ex2g4s = tmp0.p();
               while (_iterator__ex2g4s.s()) {
                 var element = _iterator__ex2g4s.t();
-                if (Companion_getInstance_2().u1i().match(element, this.a3j_1)) {
+                if (Companion_getInstance_1().u1i().match(element, this.z3i_1)) {
                   tmp$ret$0 = true;
                   break l$ret$1;
                 }
@@ -3578,7 +3558,7 @@
               tmp$ret$0 = false;
             }
              while (false);
-            suspendResult = this.b3j_1.pc(this.y3i_1.replyWithCondition(tmp$ret$0, VOID, []), this);
+            suspendResult = this.a3j_1.pc(this.x3i_1.replyWithCondition(tmp$ret$0, VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3601,8 +3581,8 @@
      while (true);
   };
   protoOf(Contains$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new Contains$solve$slambda(this.y3i_1, this.z3i_1, this.a3j_1, completion);
-    i.b3j_1 = $this$sequence;
+    var i = new Contains$solve$slambda(this.x3i_1, this.y3i_1, this.z3i_1, completion);
+    i.a3j_1 = $this$sequence;
     return i;
   };
   function Contains$solve$slambda_0($request, $list, $elem, resultContinuation) {
@@ -3615,7 +3595,7 @@
   }
   function Contains() {
     Contains_instance = this;
-    this.q3h_1 = new Signature('contains', 2);
+    this.p3h_1 = new Signature('contains', 2);
   }
   protoOf(Contains).g2e = function (request) {
     var elem = request.arguments.w(0);
@@ -3635,9 +3615,9 @@
     return Contains_instance;
   }
   function ContainsAny$solve$slambda($request, $list, $elemList, resultContinuation) {
-    this.k3j_1 = $request;
-    this.l3j_1 = $list;
-    this.m3j_1 = $elemList;
+    this.j3j_1 = $request;
+    this.k3j_1 = $list;
+    this.l3j_1 = $elemList;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(ContainsAny$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3658,19 +3638,19 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp0 = this.l3j_1.xs();
+            var tmp0 = this.k3j_1.xs();
             var tmp$ret$2;
             l$ret$3: do {
               var _iterator__ex2g4s = tmp0.p();
               while (_iterator__ex2g4s.s()) {
                 var element = _iterator__ex2g4s.t();
-                var tmp0_0 = this.m3j_1.xs();
+                var tmp0_0 = this.l3j_1.xs();
                 var tmp$ret$0;
                 l$ret$1: do {
                   var _iterator__ex2g4s_0 = tmp0_0.p();
                   while (_iterator__ex2g4s_0.s()) {
                     var element_0 = _iterator__ex2g4s_0.t();
-                    if (Companion_getInstance_2().u1i().match(element, element_0)) {
+                    if (Companion_getInstance_1().u1i().match(element, element_0)) {
                       tmp$ret$0 = true;
                       break l$ret$1;
                     }
@@ -3686,7 +3666,7 @@
               tmp$ret$2 = false;
             }
              while (false);
-            suspendResult = this.n3j_1.pc(this.k3j_1.replyWithCondition(tmp$ret$2, VOID, []), this);
+            suspendResult = this.m3j_1.pc(this.j3j_1.replyWithCondition(tmp$ret$2, VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3709,8 +3689,8 @@
      while (true);
   };
   protoOf(ContainsAny$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new ContainsAny$solve$slambda(this.k3j_1, this.l3j_1, this.m3j_1, completion);
-    i.n3j_1 = $this$sequence;
+    var i = new ContainsAny$solve$slambda(this.j3j_1, this.k3j_1, this.l3j_1, completion);
+    i.m3j_1 = $this$sequence;
     return i;
   };
   function ContainsAny$solve$slambda_0($request, $list, $elemList, resultContinuation) {
@@ -3723,7 +3703,7 @@
   }
   function ContainsAny() {
     ContainsAny_instance = this;
-    this.r3h_1 = new Signature('contains_any', 2);
+    this.q3h_1 = new Signature('contains_any', 2);
   }
   protoOf(ContainsAny).g2e = function (request) {
     var elemList = request.arguments.w(0);
@@ -3748,7 +3728,7 @@
   function mineGraph(_this__u8e3s4, context) {
     // Inline function 'kotlin.let' call
     var it = mineArguments(_this__u8e3s4, context);
-    return Companion_instance_12.o3j(mineLabels(_this__u8e3s4, context, it), mineAttacks(_this__u8e3s4, context, it), mineSupports(_this__u8e3s4, context, it));
+    return Companion_instance_12.n3j(mineLabels(_this__u8e3s4, context, it), mineAttacks(_this__u8e3s4, context, it), mineSupports(_this__u8e3s4, context, it));
   }
   function mineArguments(_this__u8e3s4, context) {
     return toList(logicProgramming(arguments$lambda(_this__u8e3s4, context)));
@@ -3779,22 +3759,22 @@
     };
   }
   function arguments$lambda$lambda_1(solution) {
-    return Companion_instance_11.p3j(solution);
+    return Companion_instance_11.o3j(solution);
   }
   function arguments$lambda$lambda_2(it) {
-    return it.z3j_1.v();
+    return it.y3j_1.v();
   }
   function arguments$lambda$lambda_3(it) {
-    return it.q3j_1.v();
+    return it.p3j_1.v();
   }
   function arguments$lambda$lambda_4(it) {
-    return it.s3j_1;
+    return it.r3j_1;
   }
   function arguments$lambda$lambda_5(it) {
-    return it.r3j_1;
+    return it.q3j_1;
   }
   function arguments$lambda$lambda_6(index, arg) {
-    arg.y3j_1 = 'A' + index;
+    arg.x3j_1 = 'A' + index;
     return arg;
   }
   function arguments$lambda($this_arguments, $context) {
@@ -3827,7 +3807,7 @@
         var _iterator__ex2g4s = tmp0.p();
         while (_iterator__ex2g4s.s()) {
           var element = _iterator__ex2g4s.t();
-          if (Companion_getInstance_2().u1i().match(element.a3k(), solution.fc_1)) {
+          if (Companion_getInstance_1().u1i().match(element.z3j(), solution.fc_1)) {
             tmp$ret$1 = element;
             break $l$block;
           }
@@ -3842,7 +3822,7 @@
         var _iterator__ex2g4s_0 = tmp0_0.p();
         while (_iterator__ex2g4s_0.s()) {
           var element_0 = _iterator__ex2g4s_0.t();
-          if (Companion_getInstance_2().u1i().match(element_0.a3k(), solution.gc_1)) {
+          if (Companion_getInstance_1().u1i().match(element_0.z3j(), solution.gc_1)) {
             tmp$ret$3 = element_0;
             break $l$block_0;
           }
@@ -3877,7 +3857,7 @@
         var _iterator__ex2g4s = tmp0.p();
         while (_iterator__ex2g4s.s()) {
           var element = _iterator__ex2g4s.t();
-          if (Companion_getInstance_2().u1i().match(element.a3k(), solution.gc_1)) {
+          if (Companion_getInstance_1().u1i().match(element.z3j(), solution.gc_1)) {
             tmp$ret$1 = element;
             break $l$block;
           }
@@ -3893,7 +3873,7 @@
         var _iterator__ex2g4s_0 = tmp0_0.p();
         while (_iterator__ex2g4s_0.s()) {
           var element_0 = _iterator__ex2g4s_0.t();
-          if (Companion_getInstance_2().u1i().match(element_0.a3k(), solution.fc_1)) {
+          if (Companion_getInstance_1().u1i().match(element_0.z3j(), solution.fc_1)) {
             tmp$ret$3 = element_0;
             break $l$block_0;
           }
@@ -3902,7 +3882,7 @@
       }
       // Inline function 'kotlin.also' call
       var this_0 = new Support(tmp$ret$3, argument);
-      argument.z3j_1.m(this_0.b3k_1);
+      argument.y3j_1.m(this_0.a3k_1);
       return this_0;
     };
   }
@@ -3955,7 +3935,7 @@
         var _iterator__ex2g4s = tmp0.p();
         while (_iterator__ex2g4s.s()) {
           var element = _iterator__ex2g4s.t();
-          if (Companion_getInstance_2().u1i().match(element.a3k(), ensureNotNull(res.v1s().h2($this_logicProgramming.d1g())))) {
+          if (Companion_getInstance_1().u1i().match(element.z3j(), ensureNotNull(res.v1s().h2($this_logicProgramming.d1g())))) {
             tmp$ret$1 = element;
             break $l$block;
           }
@@ -4018,7 +3998,7 @@
   }
   function Companion_3() {
   }
-  protoOf(Companion_3).p3j = function (term) {
+  protoOf(Companion_3).o3j = function (term) {
     // Inline function 'kotlin.let' call
     var it = of$termAsList(term);
     return new Argument(of$argRules(it), of$argTopRule(it), of$argConclusion(it), of$argGroundings(it), of$argDefeasibleRules(it), of$argDefeasiblePremises(it), of$argLastDefeasibleRules(it), term);
@@ -4033,44 +4013,44 @@
     defeasiblePremises = defeasiblePremises === VOID ? emptyList() : defeasiblePremises;
     lastDefeasibleRules = lastDefeasibleRules === VOID ? emptyList() : lastDefeasibleRules;
     term = term === VOID ? null : term;
-    this.q3j_1 = rules;
-    this.r3j_1 = topRule;
-    this.s3j_1 = conclusion;
-    this.t3j_1 = groundings;
-    this.u3j_1 = defeasibleRules;
-    this.v3j_1 = defeasiblePremises;
-    this.w3j_1 = lastDefeasibleRules;
-    this.x3j_1 = term;
-    this.y3j_1 = '';
+    this.p3j_1 = rules;
+    this.q3j_1 = topRule;
+    this.r3j_1 = conclusion;
+    this.s3j_1 = groundings;
+    this.t3j_1 = defeasibleRules;
+    this.u3j_1 = defeasiblePremises;
+    this.v3j_1 = lastDefeasibleRules;
+    this.w3j_1 = term;
+    this.x3j_1 = '';
     var tmp = this;
     // Inline function 'kotlin.collections.mutableListOf' call
-    tmp.z3j_1 = ArrayList_init_$Create$_0();
+    tmp.y3j_1 = ArrayList_init_$Create$_0();
   }
   protoOf(Argument).hashCode = function () {
     // Inline function 'kotlin.hashCode' call
-    var tmp0_safe_receiver = this.x3j_1;
+    var tmp0_safe_receiver = this.w3j_1;
     var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
     return tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
   };
-  protoOf(Argument).d3k = function () {
-    var tmp = this.y3j_1 + ' : ';
+  protoOf(Argument).c3k = function () {
+    var tmp = this.x3j_1 + ' : ';
     var tmp_0;
-    if (this.r3j_1 === 'none') {
-      var tmp0_elvis_lhs = firstOrNull_0(this.q3j_1);
+    if (this.q3j_1 === 'none') {
+      var tmp0_elvis_lhs = firstOrNull_0(this.p3j_1);
       tmp_0 = tmp0_elvis_lhs == null ? '' : tmp0_elvis_lhs;
     } else {
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.z3j_1;
+      var this_0 = this.y3j_1;
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.p();
       while (_iterator__ex2g4s.s()) {
         var item = _iterator__ex2g4s.t();
-        var tmp$ret$0 = item.y3j_1;
+        var tmp$ret$0 = item.x3j_1;
         destination.m(tmp$ret$0);
       }
       // Inline function 'kotlin.collections.reduce' call
-      var iterator = plus_1(destination, this.r3j_1).p();
+      var iterator = plus_1(destination, this.q3j_1).p();
       if (!iterator.s())
         throw UnsupportedOperationException_init_$Create$("Empty collection can't be reduced.");
       var accumulator = iterator.t();
@@ -4079,25 +4059,27 @@
       }
       tmp_0 = accumulator;
     }
-    return tmp + tmp_0 + ' : ' + this.s3j_1;
+    return tmp + tmp_0 + ' : ' + this.r3j_1;
   };
-  protoOf(Argument).a3k = function () {
-    var tmp0_elvis_lhs = this.x3j_1;
-    return tmp0_elvis_lhs == null ? parseStruct(Companion_getInstance(), '[' + toString(this.q3j_1) + ', ' + this.r3j_1 + ', [' + this.s3j_1 + '], ' + toString(this.t3j_1) + ', [' + toString(this.w3j_1) + ', ' + toString(this.u3j_1) + ', ' + toString(this.v3j_1) + ']]') : tmp0_elvis_lhs;
+  protoOf(Argument).z3j = function () {
+    var tmp0_elvis_lhs = this.w3j_1;
+    return tmp0_elvis_lhs == null ? parseStruct(Companion_getInstance_7(), '[' + toString(this.p3j_1) + ', ' + this.q3j_1 + ', [' + this.r3j_1 + '], ' + toString(this.s3j_1) + ', [' + toString(this.v3j_1) + ', ' + toString(this.t3j_1) + ', ' + toString(this.u3j_1) + ']]') : tmp0_elvis_lhs;
   };
   protoOf(Argument).toString = function () {
-    return 'argument(' + this.a3k().toString() + ')';
+    return 'argument(' + this.z3j().toString() + ')';
   };
   protoOf(Argument).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Argument))
       return false;
-    if (!equals(this.q3j_1, other.q3j_1))
+    if (!equals(this.p3j_1, other.p3j_1))
+      return false;
+    if (!(this.q3j_1 === other.q3j_1))
       return false;
     if (!(this.r3j_1 === other.r3j_1))
       return false;
-    if (!(this.s3j_1 === other.s3j_1))
+    if (!equals(this.s3j_1, other.s3j_1))
       return false;
     if (!equals(this.t3j_1, other.t3j_1))
       return false;
@@ -4107,8 +4089,6 @@
       return false;
     if (!equals(this.w3j_1, other.w3j_1))
       return false;
-    if (!equals(this.x3j_1, other.x3j_1))
-      return false;
     return true;
   };
   function toString$parse(x) {
@@ -4117,23 +4097,23 @@
   function Attack(attacker, target, type, on) {
     type = type === VOID ? null : type;
     on = on === VOID ? null : on;
-    this.e3k_1 = attacker;
-    this.f3k_1 = target;
-    this.g3k_1 = type;
-    this.h3k_1 = on;
+    this.d3k_1 = attacker;
+    this.e3k_1 = target;
+    this.f3k_1 = type;
+    this.g3k_1 = on;
   }
   protoOf(Attack).toString = function () {
-    var tmp = toString(toString$parse(this.g3k_1));
-    var tmp_0 = this.e3k_1.a3k().toString();
-    var tmp_1 = this.f3k_1.a3k().toString();
-    var tmp0_safe_receiver = this.h3k_1;
-    return 'attack(' + tmp + ', ' + tmp_0 + ', ' + tmp_1 + ', ' + toString(toString$parse(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a3k())) + ')';
+    var tmp = toString(toString$parse(this.f3k_1));
+    var tmp_0 = this.d3k_1.z3j().toString();
+    var tmp_1 = this.e3k_1.z3j().toString();
+    var tmp0_safe_receiver = this.g3k_1;
+    return 'attack(' + tmp + ', ' + tmp_0 + ', ' + tmp_1 + ', ' + toString(toString$parse(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.z3j())) + ')';
   };
   protoOf(Attack).hashCode = function () {
-    var result = this.e3k_1.hashCode();
-    result = imul(result, 31) + this.f3k_1.hashCode() | 0;
-    result = imul(result, 31) + (this.g3k_1 == null ? 0 : getStringHashCode(this.g3k_1)) | 0;
-    result = imul(result, 31) + (this.h3k_1 == null ? 0 : this.h3k_1.hashCode()) | 0;
+    var result = this.d3k_1.hashCode();
+    result = imul(result, 31) + this.e3k_1.hashCode() | 0;
+    result = imul(result, 31) + (this.f3k_1 == null ? 0 : getStringHashCode(this.f3k_1)) | 0;
+    result = imul(result, 31) + (this.g3k_1 == null ? 0 : this.g3k_1.hashCode()) | 0;
     return result;
   };
   protoOf(Attack).equals = function (other) {
@@ -4141,31 +4121,31 @@
       return true;
     if (!(other instanceof Attack))
       return false;
-    if (!this.e3k_1.equals(other.e3k_1))
+    if (!this.d3k_1.equals(other.d3k_1))
       return false;
-    if (!this.f3k_1.equals(other.f3k_1))
+    if (!this.e3k_1.equals(other.e3k_1))
       return false;
-    if (!(this.g3k_1 == other.g3k_1))
+    if (!(this.f3k_1 == other.f3k_1))
       return false;
-    if (!equals(this.h3k_1, other.h3k_1))
+    if (!equals(this.g3k_1, other.g3k_1))
       return false;
     return true;
   };
   function Companion_4() {
   }
-  protoOf(Companion_4).o3j = function (labellings, attacks, supports) {
+  protoOf(Companion_4).n3j = function (labellings, attacks, supports) {
     // Inline function 'kotlin.collections.map' call
     // Inline function 'kotlin.collections.mapTo' call
     var destination = ArrayList_init_$Create$(collectionSizeOrDefault(labellings, 10));
     var _iterator__ex2g4s = labellings.p();
     while (_iterator__ex2g4s.s()) {
       var item = _iterator__ex2g4s.t();
-      var tmp$ret$0 = item.i3k_1;
+      var tmp$ret$0 = item.h3k_1;
       destination.m(tmp$ret$0);
     }
     // Inline function 'kotlin.also' call
     var this_0 = new Graph(destination, attacks, supports);
-    this_0.n3k_1 = labellings;
+    this_0.m3k_1 = labellings;
     return this_0;
   };
   var Companion_instance_12;
@@ -4173,18 +4153,18 @@
     return Companion_instance_12;
   }
   function Graph(arguments_0, attacks, supports) {
-    this.k3k_1 = arguments_0;
-    this.l3k_1 = attacks;
-    this.m3k_1 = supports;
-    this.n3k_1 = emptyList();
+    this.j3k_1 = arguments_0;
+    this.k3k_1 = attacks;
+    this.l3k_1 = supports;
+    this.m3k_1 = emptyList();
   }
   protoOf(Graph).toString = function () {
-    return 'Graph(arguments=' + toString(this.k3k_1) + ', attacks=' + toString(this.l3k_1) + ', supports=' + toString(this.m3k_1) + ')';
+    return 'Graph(arguments=' + toString(this.j3k_1) + ', attacks=' + toString(this.k3k_1) + ', supports=' + toString(this.l3k_1) + ')';
   };
   protoOf(Graph).hashCode = function () {
-    var result = hashCode(this.k3k_1);
+    var result = hashCode(this.j3k_1);
+    result = imul(result, 31) + hashCode(this.k3k_1) | 0;
     result = imul(result, 31) + hashCode(this.l3k_1) | 0;
-    result = imul(result, 31) + hashCode(this.m3k_1) | 0;
     return result;
   };
   protoOf(Graph).equals = function (other) {
@@ -4192,24 +4172,24 @@
       return true;
     if (!(other instanceof Graph))
       return false;
+    if (!equals(this.j3k_1, other.j3k_1))
+      return false;
     if (!equals(this.k3k_1, other.k3k_1))
       return false;
     if (!equals(this.l3k_1, other.l3k_1))
       return false;
-    if (!equals(this.m3k_1, other.m3k_1))
-      return false;
     return true;
   };
   function LabelledArgument(argument, label) {
-    this.i3k_1 = argument;
-    this.j3k_1 = label;
+    this.h3k_1 = argument;
+    this.i3k_1 = label;
   }
   protoOf(LabelledArgument).toString = function () {
-    return this.j3k_1 + '(' + this.i3k_1.a3k().toString() + ')';
+    return this.i3k_1 + '(' + this.h3k_1.z3j().toString() + ')';
   };
   protoOf(LabelledArgument).hashCode = function () {
-    var result = this.i3k_1.hashCode();
-    result = imul(result, 31) + getStringHashCode(this.j3k_1) | 0;
+    var result = this.h3k_1.hashCode();
+    result = imul(result, 31) + getStringHashCode(this.i3k_1) | 0;
     return result;
   };
   protoOf(LabelledArgument).equals = function (other) {
@@ -4217,22 +4197,22 @@
       return true;
     if (!(other instanceof LabelledArgument))
       return false;
-    if (!this.i3k_1.equals(other.i3k_1))
+    if (!this.h3k_1.equals(other.h3k_1))
       return false;
-    if (!(this.j3k_1 === other.j3k_1))
+    if (!(this.i3k_1 === other.i3k_1))
       return false;
     return true;
   };
   function Support(supporter, supported) {
-    this.b3k_1 = supporter;
-    this.c3k_1 = supported;
+    this.a3k_1 = supporter;
+    this.b3k_1 = supported;
   }
   protoOf(Support).toString = function () {
-    return 'support(' + this.b3k_1.a3k().toString() + ', ' + this.c3k_1.a3k().toString() + ')';
+    return 'support(' + this.a3k_1.z3j().toString() + ', ' + this.b3k_1.z3j().toString() + ')';
   };
   protoOf(Support).hashCode = function () {
-    var result = this.b3k_1.hashCode();
-    result = imul(result, 31) + this.c3k_1.hashCode() | 0;
+    var result = this.a3k_1.hashCode();
+    result = imul(result, 31) + this.b3k_1.hashCode() | 0;
     return result;
   };
   protoOf(Support).equals = function (other) {
@@ -4240,9 +4220,9 @@
       return true;
     if (!(other instanceof Support))
       return false;
-    if (!this.b3k_1.equals(other.b3k_1))
+    if (!this.a3k_1.equals(other.a3k_1))
       return false;
-    if (!this.c3k_1.equals(other.c3k_1))
+    if (!this.b3k_1.equals(other.b3k_1))
       return false;
     return true;
   };
@@ -4250,8 +4230,8 @@
     EngineInterface_instance = this;
     EngineInterfaceBase.call(this);
   }
-  protoOf(EngineInterface).c3a = function () {
-    return ArgumentationEngineInterface_instance.r3k_1;
+  protoOf(EngineInterface).b3a = function () {
+    return ArgumentationEngineInterface_instance.q3k_1;
   };
   var EngineInterface_instance;
   function EngineInterface_getInstance() {
@@ -4263,8 +4243,8 @@
     AbstractMode_instance = this;
     AbstractModeBase.call(this);
   }
-  protoOf(AbstractMode).c3a = function () {
-    return AbstractMode_instance_0.v3k_1;
+  protoOf(AbstractMode).b3a = function () {
+    return AbstractMode_instance_0.u3k_1;
   };
   var AbstractMode_instance;
   function AbstractMode_getInstance() {
@@ -4276,8 +4256,8 @@
     ArgumentationGraphBuilder_instance = this;
     ArgumentationGraphBuilderBase.call(this);
   }
-  protoOf(ArgumentationGraphBuilder).c3a = function () {
-    return ArgumentationGraph_instance.z3k_1;
+  protoOf(ArgumentationGraphBuilder).b3a = function () {
+    return ArgumentationGraph_instance.y3k_1;
   };
   var ArgumentationGraphBuilder_instance;
   function ArgumentationGraphBuilder_getInstance() {
@@ -4289,8 +4269,8 @@
     AttackRestrictionHandler_instance = this;
     AttackRestrictionHandlerBase.call(this);
   }
-  protoOf(AttackRestrictionHandler).c3a = function () {
-    return AttackRestriction_instance.d3l_1;
+  protoOf(AttackRestrictionHandler).b3a = function () {
+    return AttackRestriction_instance.c3l_1;
   };
   var AttackRestrictionHandler_instance;
   function AttackRestrictionHandler_getInstance() {
@@ -4302,8 +4282,8 @@
     BpMetaGraphHandler_instance = this;
     BpMetaGraphHandlerBase.call(this);
   }
-  protoOf(BpMetaGraphHandler).c3a = function () {
-    return Bp_instance.h3l_1;
+  protoOf(BpMetaGraphHandler).b3a = function () {
+    return Bp_instance.g3l_1;
   };
   var BpMetaGraphHandler_instance;
   function BpMetaGraphHandler_getInstance() {
@@ -4315,8 +4295,8 @@
     DefeasiblePreferencesHandler_instance = this;
     DefeasiblePreferencesHandlerBase.call(this);
   }
-  protoOf(DefeasiblePreferencesHandler).c3a = function () {
-    return DefPreferences_instance.l3l_1;
+  protoOf(DefeasiblePreferencesHandler).b3a = function () {
+    return DefPreferences_instance.k3l_1;
   };
   var DefeasiblePreferencesHandler_instance;
   function DefeasiblePreferencesHandler_getInstance() {
@@ -4328,8 +4308,8 @@
     GenericDefeasiblePreferencesHandler_instance = this;
     GenericDefeasiblePreferencesHandlerBase.call(this);
   }
-  protoOf(GenericDefeasiblePreferencesHandler).c3a = function () {
-    return GenericDefPreferences_instance.p3l_1;
+  protoOf(GenericDefeasiblePreferencesHandler).b3a = function () {
+    return GenericDefPreferences_instance.o3l_1;
   };
   var GenericDefeasiblePreferencesHandler_instance;
   function GenericDefeasiblePreferencesHandler_getInstance() {
@@ -4341,8 +4321,8 @@
     StrictPreferencesHandler_instance = this;
     StrictPreferencesHandlerBase.call(this);
   }
-  protoOf(StrictPreferencesHandler).c3a = function () {
-    return Preferences_instance.t3l_1;
+  protoOf(StrictPreferencesHandler).b3a = function () {
+    return Preferences_instance.s3l_1;
   };
   var StrictPreferencesHandler_instance;
   function StrictPreferencesHandler_getInstance() {
@@ -4354,8 +4334,8 @@
     BpCompleteLabeller_instance = this;
     BpCompleteLabellerBase.call(this);
   }
-  protoOf(BpCompleteLabeller).c3a = function () {
-    return BpGroundedComplete_instance.x3l_1;
+  protoOf(BpCompleteLabeller).b3a = function () {
+    return BpGroundedComplete_instance.w3l_1;
   };
   var BpCompleteLabeller_instance;
   function BpCompleteLabeller_getInstance() {
@@ -4367,8 +4347,8 @@
     BpLabeller_instance = this;
     BpLabellerBase.call(this);
   }
-  protoOf(BpLabeller).c3a = function () {
-    return BpGrounded_instance.b3m_1;
+  protoOf(BpLabeller).b3a = function () {
+    return BpGrounded_instance.a3m_1;
   };
   var BpLabeller_instance;
   function BpLabeller_getInstance() {
@@ -4380,8 +4360,8 @@
     BpPartialLabeller_instance = this;
     BpPartialLabellerBase.call(this);
   }
-  protoOf(BpPartialLabeller).c3a = function () {
-    return BpGroundedPartial_instance.f3m_1;
+  protoOf(BpPartialLabeller).b3a = function () {
+    return BpGroundedPartial_instance.e3m_1;
   };
   var BpPartialLabeller_instance;
   function BpPartialLabeller_getInstance() {
@@ -4393,8 +4373,8 @@
     CompleteLabeller_instance = this;
     CompleteLabellerBase.call(this);
   }
-  protoOf(CompleteLabeller).c3a = function () {
-    return Complete_instance.j3m_1;
+  protoOf(CompleteLabeller).b3a = function () {
+    return Complete_instance.i3m_1;
   };
   var CompleteLabeller_instance;
   function CompleteLabeller_getInstance() {
@@ -4406,8 +4386,8 @@
     GroundedLabeller_instance = this;
     GroundedLabellerBase.call(this);
   }
-  protoOf(GroundedLabeller).c3a = function () {
-    return Grounded_instance.n3m_1;
+  protoOf(GroundedLabeller).b3a = function () {
+    return Grounded_instance.m3m_1;
   };
   var GroundedLabeller_instance;
   function GroundedLabeller_getInstance() {
@@ -4419,8 +4399,8 @@
     GroundedLabellerOptimized_instance = this;
     GroundedLabellerOptimizedBase.call(this);
   }
-  protoOf(GroundedLabellerOptimized).c3a = function () {
-    return GroundedOptimized_instance.r3m_1;
+  protoOf(GroundedLabellerOptimized).b3a = function () {
+    return GroundedOptimized_instance.q3m_1;
   };
   var GroundedLabellerOptimized_instance;
   function GroundedLabellerOptimized_getInstance() {
@@ -4432,8 +4412,8 @@
     StatementLabeller_instance = this;
     StatementLabellerBase.call(this);
   }
-  protoOf(StatementLabeller).c3a = function () {
-    return StatementLabelling_instance.v3m_1;
+  protoOf(StatementLabeller).b3a = function () {
+    return StatementLabelling_instance.u3m_1;
   };
   var StatementLabeller_instance;
   function StatementLabeller_getInstance() {
@@ -4445,8 +4425,8 @@
     RuleParser_instance = this;
     RuleParserBase.call(this);
   }
-  protoOf(RuleParser).c3a = function () {
-    return RuleTranslator_instance.z3m_1;
+  protoOf(RuleParser).b3a = function () {
+    return RuleTranslator_instance.y3m_1;
   };
   var RuleParser_instance;
   function RuleParser_getInstance() {
@@ -4455,147 +4435,147 @@
     return RuleParser_instance;
   }
   function AbstractMode_0() {
-    this.v3k_1 = 'computeGlobalAcceptance :-\n    buildGraph,\n    modifyGraph,\n    buildArgumentLabelling,\n    buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n    computeGlobalAcceptance,\n    utils::recoverGraph(Arguments, Attacks, Supports),\n    utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n    utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n    graphBuildMode(X),\n    X:::buildArgumentationGraph.\nmodifyGraph :-\n    findall(X, graphExtension(X), Ext),\n    modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n    modifyGraph(Ext),\n    X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n    argumentLabellingMode(X),\n    X:::argumentLabelling.\nbuildStatementLabelling :-\n    statementLabellingMode(X),\n    X:::statementLabelling.';
+    this.u3k_1 = 'computeGlobalAcceptance :-\n    buildGraph,\n    modifyGraph,\n    buildArgumentLabelling,\n    buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n    computeGlobalAcceptance,\n    utils::recoverGraph(Arguments, Attacks, Supports),\n    utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n    utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n    graphBuildMode(X),\n    X:::buildArgumentationGraph.\nmodifyGraph :-\n    findall(X, graphExtension(X), Ext),\n    modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n    modifyGraph(Ext),\n    X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n    argumentLabellingMode(X),\n    X:::argumentLabelling.\nbuildStatementLabelling :-\n    statementLabellingMode(X),\n    X:::statementLabelling.';
   }
   var AbstractMode_instance_0;
   function AbstractMode_getInstance_0() {
     return AbstractMode_instance_0;
   }
   function ArgumentationEngineInterface() {
-    this.r3k_1 = 'argTuProlog.\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n    buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n    debug::printArgumentationGraph(Arguments, Attacks, Supports),\n    debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n    debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::query(Goal, Res).\nbuildLabelSetsSilent :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance.';
+    this.q3k_1 = 'argTuProlog.\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n    buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n    debug::printArgumentationGraph(Arguments, Attacks, Supports),\n    debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n    debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::query(Goal, Res).\nbuildLabelSetsSilent :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance.';
   }
   var ArgumentationEngineInterface_instance;
   function ArgumentationEngineInterface_getInstance() {
     return ArgumentationEngineInterface_instance;
   }
   function ArgumentationGraph() {
-    this.z3k_1 = 'buildArgumentationGraph :-\n    buildArguments,\n    findall(_, buildAdditionalArgument, _),\n    buildAttacks.\nbuildAdditionalArgument :-\n    metaConflicts,\n    conf_arg(A, CArg),\n    context_check(clause(conc(A), argument([R, T, C, B, I]))),\n    \\+ filter_meta([R, T, C, B, I]),\n    saveArgument(a, A, [[mc|R], T, C, B, I]),\n    saveSupport(CArg, [[mc|R], T, C, B, I]),\n    cloneSupport([R, T, C, B, I], [[mc|R], T, C, B, I]),\n    fail.\nbuildAdditionalArgument.\ncloneSupport(Original, New) :-\n    findall(_, (\n        context_check(support(S, Original)),\n        saveSupport(S, New)\n    ), _).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _, _)]), argument(Arg))).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _)]), argument(Arg))).\nfilter_meta([Id, _, _, _, _]) :- metaConflicts, member(mc, Id).\nfilter_meta(_) :- \\+ metaConflicts.\nbuildArguments :-\n\tbuildArgumentsFromPremises,\n\tbuildArgumentsFromEmptyRules,\n\tfindall([RuleID, RuleBody, RuleHead], (\n\t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n\t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n    ), Rules),\n    findall(X, context_check(newConc(a, [X])), N),\n\tbuildArgumentsFromRules(N, b, Rules, Rules, n).\nbuildArgumentsFromPremises :-\n    findall(\n        _,\n        (\n            parser::classic_rule(PremiseID, Premise),\n            checkStrict(PremiseID, DefPrem),\n            saveArgument(a, Premise, [[PremiseID], none, Premise, [], [[], [], DefPrem]])\n        ),\n        _\n    ).\nbuildArgumentsFromEmptyRules :-\n    findall(\n        _,\n        (\n            emptyRule([RuleID, RulePrem, RuleHead]),\n            checkStrict(RuleID, DefRule),\n            saveArgument(a, RuleHead, [[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])\n        ),\n        _\n    ).\nemptyRule([RuleID, Body, RuleHead]) :-\n    parser::classic_rule(RuleID, Body, RuleHead),\n    \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n    ruleBodyIsSupported(RuleID, RuleHead, Body, Body, [[], [], [], []], _).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\nbuildArgumentsFromRules(_, _, Rules, [], n) :- !.\nbuildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\nbuildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n    utils::contains_any(Body, N),\n    findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n    R \\== [],\n    buildArgumentsFromRules(N, Tn, Rules, T, y), !.\nbuildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n    buildArgumentsFromRules(N, Tn, Rules, T, X).\nbuildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n\tsaveArgument(Tn, RuleHead, Argument).\nclean(Tn, Rules) :-\n    invert(Tn, Tx),\n    context_retract(newConc(Tx, _)),\n    findall(X, context_check(newConc(Tn, [X])), N),\n    buildArgumentsFromRules(N, Tx, Rules, Rules, n).\ninvert(a, b).\ninvert(b, a).\ndefRules(Id, Def, Def) :- parser::check_strict(Id), !.\ndefRules(Id, Def, [Id|Def]).\nlastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\nlastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\nargumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n    utils::sortDistinct(Prem, FPrem),\n    defRules(RuleId, Def, NDef),\n    utils::sortDistinct(NDef, FDef),\n    lastDefRules(RuleId, LDef, NLDef),\n    utils::sortDistinct(NLDef, FLDef).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n    utils::appendLists(TAll, All),\n    \\+ utils::contains(RuleID, All),\n    utils::appendLists(TLDef, LDef),\n    utils::appendLists(TDef, Def),\n    utils::appendLists(TPrem, Prem),\n    argumentInfo(RuleID, LDef, Def, Prem, Info),\n    utils::sort([RuleID|All], Rules),\n    Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n    \\+ context_check(clause(conc(RuleHead), argument(Argument))).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n\t(callable(Check) -> call(Check); Check),\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n    context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n\truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n\tsaveSupport([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument).\nbuildAttacks :-\n\tfindall(_, buildDirectAttack, _),\n\tbuildTransitiveAttacks.\nbuildDirectAttack :-\n    context_check(argument(A)),\n    attack::findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tfilter_meta(B),\n\tA \\== B,\n    attack::attacks(T, B, A),\n    saveAttack(T, B, A, A),\n\tfail.\nbuildDirectAttack.\nbuildTransitiveAttacks :-\n\tcontext_check(attack(T, A, B, D)),\n\tcontext_check(support(B, C)),\n\tsaveAttack(T, A, C, D),!,\n    buildTransitiveAttacks.\nbuildTransitiveAttacks.\nsaveArgument(T, Conclusion, Argument) :-\n    \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n    context_assert(newConc(T, Conclusion)),\n    utils::hash(argument(Argument), Id),\n    context_assert(argument(Argument)),\n    context_assert(conc(Conclusion) :- argument(Argument)),\n    context_assert(arg(Id) :- argument(Argument)).\nsaveAttack(T, A, C, D) :-\n    \\+ context_check(attack(T, A, C, D)),\n    context_assert(attack(T, A, C, D)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(C), IdC),\n    context_assert(att(IdA, IdC) :- attack(T, A, C, D)).\nsaveSupport(A, B) :-\n    \\+ context_check(support(A, B)),\n    context_assert(support(A, B)).\nremoveAttack(T, A, B, C) :-\n    context_retract(attack(T, A, B, C)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(B), IdB),\n    context_retract(att(IdA, IdB) :- attack(T, A, B, C)).';
+    this.y3k_1 = 'buildArgumentationGraph :-\n    buildArguments,\n    findall(_, buildAdditionalArgument, _),\n    buildAttacks.\nbuildAdditionalArgument :-\n    metaConflicts,\n    conf_arg(A, CArg),\n    context_check(clause(conc(A), argument([R, T, C, B, I]))),\n    \\+ filter_meta([R, T, C, B, I]),\n    saveArgument(a, A, [[mc|R], T, C, B, I]),\n    saveSupport(CArg, [[mc|R], T, C, B, I]),\n    cloneSupport([R, T, C, B, I], [[mc|R], T, C, B, I]),\n    fail.\nbuildAdditionalArgument.\ncloneSupport(Original, New) :-\n    findall(_, (\n        context_check(support(S, Original)),\n        saveSupport(S, New)\n    ), _).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _, _)]), argument(Arg))).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _)]), argument(Arg))).\nfilter_meta([Id, _, _, _, _]) :- metaConflicts, member(mc, Id).\nfilter_meta(_) :- \\+ metaConflicts.\nbuildArguments :-\n\tbuildArgumentsFromPremises,\n\tbuildArgumentsFromEmptyRules,\n\tfindall([RuleID, RuleBody, RuleHead], (\n\t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n\t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n    ), Rules),\n    findall(X, context_check(newConc(a, [X])), N),\n\tbuildArgumentsFromRules(N, b, Rules, Rules, n).\nbuildArgumentsFromPremises :-\n    findall(\n        _,\n        (\n            parser::classic_rule(PremiseID, Premise),\n            checkStrict(PremiseID, DefPrem),\n            saveArgument(a, Premise, [[PremiseID], none, Premise, [], [[], [], DefPrem]])\n        ),\n        _\n    ).\nbuildArgumentsFromEmptyRules :-\n    findall(\n        _,\n        (\n            emptyRule([RuleID, RulePrem, RuleHead]),\n            checkStrict(RuleID, DefRule),\n            saveArgument(a, RuleHead, [[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])\n        ),\n        _\n    ).\nemptyRule([RuleID, Body, RuleHead]) :-\n    parser::classic_rule(RuleID, Body, RuleHead),\n    \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n    ruleBodyIsSupported(RuleID, RuleHead, Body, Body, [[], [], [], []], _).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\nbuildArgumentsFromRules(_, _, Rules, [], n) :- !.\nbuildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\nbuildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n    utils::contains_any(Body, N),\n    findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n    R \\== [],\n    buildArgumentsFromRules(N, Tn, Rules, T, y), !.\nbuildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n    buildArgumentsFromRules(N, Tn, Rules, T, X).\nbuildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n\tsaveArgument(Tn, RuleHead, Argument).\nclean(Tn, Rules) :-\n    invert(Tn, Tx),\n    context_retract(newConc(Tx, _)),\n    findall(X, context_check(newConc(Tn, [X])), N),\n    buildArgumentsFromRules(N, Tx, Rules, Rules, n).\ninvert(a, b).\ninvert(b, a).\ndefRules(Id, Def, Def) :- parser::check_strict(Id), !.\ndefRules(Id, Def, [Id|Def]).\nlastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\nlastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\nargumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n    utils::sortDistinct(Prem, FPrem),\n    defRules(RuleId, Def, NDef),\n    utils::sortDistinct(NDef, FDef),\n    lastDefRules(RuleId, LDef, NLDef),\n    utils::sortDistinct(NLDef, FLDef).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n    utils::appendLists(TAll, All),\n    \\+ utils::contains(RuleID, All),\n    utils::appendLists(TLDef, LDef),\n    utils::appendLists(TDef, Def),\n    utils::appendLists(TPrem, Prem),\n    argumentInfo(RuleID, LDef, Def, Prem, Info),\n    utils::sort([RuleID|All], Rules),\n    Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n    \\+ context_check(clause(conc(RuleHead), argument(Argument))).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n\t(callable(Check) -> call(Check); Check),\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n    context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n\truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n\tsaveSupport([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument).\nbuildAttacks :-\n\tfindall(_, buildDirectAttack, _).\nbuildDirectAttack :-\n    context_check(argument(A)),\n    attack::findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tfilter_meta(B),\n\tA \\== B,\n    attack::attacks(T, B, A),\n    saveAttack(T, B, A, A),\n    findall(_, (\n        expanded_support(A, C),\n        saveAttack(T, B, C, A)\n    ),_),\n\tfail.\nbuildDirectAttack.\nexpanded_support(A, B) :-\n    context_check(support(A, B)).\nexpanded_support(A, C) :-\n    context_check(support(A, B)),\n    expanded_support(B, C).\nsaveArgument(T, Conclusion, Argument) :-\n    \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n    context_assert(newConc(T, Conclusion)),\n    utils::hash(argument(Argument), Id),\n    context_assert(argument(Argument)),\n    context_assert(conc(Conclusion) :- argument(Argument)),\n    context_assert(arg(Id) :- argument(Argument)).\nsaveAttack(T, A, C, D) :-\n    \\+ context_check(attack(T, A, C, D)),\n    context_assert(attack(T, A, C, D)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(C), IdC),\n    context_assert(att(IdA, IdC) :- attack(T, A, C, D)).\nsaveSupport(A, B) :-\n    \\+ context_check(support(A, B)),\n    context_assert(support(A, B)).\nremoveAttack(T, A, B, C) :-\n    context_retract(attack(T, A, B, C)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(B), IdB),\n    context_retract(att(IdA, IdB) :- attack(T, A, B, C)).';
   }
   var ArgumentationGraph_instance;
   function ArgumentationGraph_getInstance() {
     return ArgumentationGraph_instance;
   }
   function AttackRelation() {
-    this.a3n_1 = 'attacks(rebut, A, B) :- rebuts(A, B), !.\nattacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\nattacks(undermine, A, B) :- undermines(A, B), !.\nattacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\nattacks(undercut, A, B) :- undercuts(A, B), !.\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB, Guard),\n    (callable(Guard) -> call(Guard); Guard).\nrebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n\tRuleB \\== none,\n    Info \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleA \\== none,\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n\tInfo \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\nundercuts([_, _, NegRuleB, _, _], [_, RuleB, _, _, [[RuleB], _, _]]) :-\n    expanded_conflict(NegRuleB, [RuleB]).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n    member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID], Guard).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID]).';
+    this.z3m_1 = 'attacks(rebut, A, B) :- rebuts(A, B), !.\nattacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\nattacks(undermine, A, B) :- undermines(A, B), !.\nattacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\nattacks(undercut, A, B) :- undercuts(A, B), !.\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB, Guard),\n    (callable(Guard) -> call(Guard); Guard).\nrebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n\tRuleB \\== none,\n    Info \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleA \\== none,\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n\tInfo \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\nundercuts([_, _, NegRuleB, _, _], [_, RuleB, _, _, [[RuleB], _, _]]) :-\n    expanded_conflict(NegRuleB, [RuleB]).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n    member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID], Guard).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID]).';
   }
   var AttackRelation_instance;
   function AttackRelation_getInstance() {
     return AttackRelation_instance;
   }
   function AttackRestriction() {
-    this.d3l_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkRebutRestriction(T, A, B, C)\n    ), _).\ncheckRebutRestriction(T, A, B, C) :-\n    \\+ rebutRestriction(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nrebutRestriction(rebut, _, _, C) :- restrict(C).\nrebutRestriction(undermine, _, _, C).\nrebutRestriction(contrary_rebut, _, _, _).\nrebutRestriction(contrary_undermine, _, _, _).\nrebutRestriction(undercut, _, _, _).\nrestrict([_, TopRule, _, _, [[TopRule], _, _]]) :- TopRule \\== none.';
+    this.c3l_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkRebutRestriction(T, A, B, C)\n    ), _).\ncheckRebutRestriction(T, A, B, C) :-\n    \\+ rebutRestriction(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nrebutRestriction(rebut, _, _, C) :- restrict(C).\nrebutRestriction(undermine, _, _, C).\nrebutRestriction(contrary_rebut, _, _, _).\nrebutRestriction(contrary_undermine, _, _, _).\nrebutRestriction(undercut, _, _, _).\nrestrict([_, TopRule, _, _, [[TopRule], _, _]]) :- TopRule \\== none.';
   }
   var AttackRestriction_instance;
   function AttackRestriction_getInstance() {
     return AttackRestriction_instance;
   }
   function Bp() {
-    this.h3l_1 = 'modifyArgumentationGraph :-\n    findall(([Rules, Top, [bp(Checked)], G, I], [Z, P, [Y], GG, II]), (\n        context_check(argument([Rules, Top, [bp(Checked)], G, I])),\n        member(Y, [Checked]),\n        context_check(argument([Z, P, [Y], GG, II]))\n    ), TemplateBpPairs),\n    checkBpArguments(TemplateBpPairs).\ncheckBpArguments([]).\ncheckBpArguments(TemplateBpPairs) :-\n    createBpArguments(TemplateBpPairs, BpPairs),\n    createBpAttacks(BpPairs).\ncreateBpArguments([], []).\ncreateBpArguments([(Original, [Z, P, Y, B, I])|Others], [(Conflict, [Z, P, Y, B, I])|BpPairs]) :-\n    Conflict = [[artificial|Z], artificial, [-burdmet(Y)], [], [[artificial], [artificial], []]],\n    standard_af::saveArgument(a, [-burdmet(Y)], Conflict),\n    standard_af::saveSupport(Original, Conflict),\n    liftBpAttacks(Original, Conflict),\n    createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n    findall(_, (\n        context_check(attack(T, A, Template, O)),\n        standard_af::saveAttack(T, A, BpArg, O)\n    ), _).\ncreateBpAttacks(BpPairs) :-\n    generateBpsEvaluationChain(BpPairs, OrderedBpPairs),\n    evaluateBurdenedArgs(OrderedBpPairs).\ngenerateBpsEvaluationChain([], []).\ngenerateBpsEvaluationChain([BpPair|BpPairs], OrderedBpPairs) :-\n    generateBpsEvaluationChain(BpPairs, TempOrderedBpPairs),\n    insertBpPair(BpPair, TempOrderedBpPairs, OrderedBpPairs).\ninsertBpPair(BpPair, [], [BpPair]).\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(BpL, BurdenedL)|Return]) :-\n    bp_grounded::argumentChain(BurdenedL, Burdened),\n    insertBpPair((Bp, Burdened), Others, Return), !.\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(Bp, Burdened)|[(BpL, BurdenedL)|Others]]).\nevaluateBurdenedArgs([]).\nevaluateBurdenedArgs([(Bp, Burdened)|Others]) :-\n    context_active(X),\n    grounded:::argumentLabelling,\n    statusToAttack((Bp, Burdened), attack(T, A, B, C)),\n    context_checkout(X),\n    standard_af::saveAttack(T, A, B, C),\n    evaluateBurdenedArgs(Others).\nstatusToAttack((Bp, Burdened), attack(bprebut, Burdened, Bp, Bp)) :-\n    context_check(in(Burdened)).\nstatusToAttack((Bp, Burdened), attack(bprebut, Bp, Burdened, Burdened)) :-\n    \\+ context_check(in(Burdened)).';
+    this.g3l_1 = 'modifyArgumentationGraph :-\n    findall(([Rules, Top, [bp(Checked)], G, I], [Z, P, [Y], GG, II]), (\n        context_check(argument([Rules, Top, [bp(Checked)], G, I])),\n        member(Y, [Checked]),\n        context_check(argument([Z, P, [Y], GG, II]))\n    ), TemplateBpPairs),\n    checkBpArguments(TemplateBpPairs).\ncheckBpArguments([]).\ncheckBpArguments(TemplateBpPairs) :-\n    createBpArguments(TemplateBpPairs, BpPairs),\n    createBpAttacks(BpPairs).\ncreateBpArguments([], []).\ncreateBpArguments([(Original, [Z, P, Y, B, I])|Others], [(Conflict, [Z, P, Y, B, I])|BpPairs]) :-\n    Conflict = [[artificial|Z], artificial, [-burdmet(Y)], [], [[artificial], [artificial], []]],\n    standard_af::saveArgument(a, [-burdmet(Y)], Conflict),\n    standard_af::saveSupport(Original, Conflict),\n    liftBpAttacks(Original, Conflict),\n    createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n    findall(_, (\n        context_check(attack(T, A, Template, O)),\n        standard_af::saveAttack(T, A, BpArg, O)\n    ), _).\ncreateBpAttacks(BpPairs) :-\n    generateBpsEvaluationChain(BpPairs, OrderedBpPairs),\n    evaluateBurdenedArgs(OrderedBpPairs).\ngenerateBpsEvaluationChain([], []).\ngenerateBpsEvaluationChain([BpPair|BpPairs], OrderedBpPairs) :-\n    generateBpsEvaluationChain(BpPairs, TempOrderedBpPairs),\n    insertBpPair(BpPair, TempOrderedBpPairs, OrderedBpPairs).\ninsertBpPair(BpPair, [], [BpPair]).\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(BpL, BurdenedL)|Return]) :-\n    bp_grounded::argumentChain(BurdenedL, Burdened),\n    insertBpPair((Bp, Burdened), Others, Return), !.\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(Bp, Burdened)|[(BpL, BurdenedL)|Others]]).\nevaluateBurdenedArgs([]).\nevaluateBurdenedArgs([(Bp, Burdened)|Others]) :-\n    context_active(X),\n    grounded:::argumentLabelling,\n    statusToAttack((Bp, Burdened), attack(T, A, B, C)),\n    context_checkout(X),\n    standard_af::saveAttack(T, A, B, C),\n    evaluateBurdenedArgs(Others).\nstatusToAttack((Bp, Burdened), attack(bprebut, Burdened, Bp, Bp)) :-\n    context_check(in(Burdened)).\nstatusToAttack((Bp, Burdened), attack(bprebut, Bp, Burdened, Burdened)) :-\n    \\+ context_check(in(Burdened)).';
   }
   var Bp_instance;
   function Bp_getInstance() {
     return Bp_instance;
   }
   function BpGrounded() {
-    this.b3m_1 = 'argumentLabelling :-\n    reifyBurdenOfProofs,\n    filterBpDefeats,\n    findall(X, context_check(argument(X)), Arguments),\n    bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    grounded::allAttacksOUT(A), !,\n    context_assert(in(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    \\+ isArgumentInBurdenOfProof(A),\n    grounded::oneAttackIN(A), !,\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    context_active(Branch),\n    mostGroundedBpUnd(Arguments, A),\n    context_branch(Branch, _),\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Args) :-\n    notLabelled(Args),\n    findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n    \\+ (\n        member(A, Args),\n        (\n            context_check(in(A));\n            context_check(out(A));\n            context_check(und(A))\n        )\n    ).\nisInBurdenOfProof(Conclusion) :-\n    context_check(reifiedBp(Literals)),\n    member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n    isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        filterBpDefeat(T, A, B, C)\n    ), _).\nfilterBpDefeat(T, B, A, C) :-\n    (T = rebut; T = undermine),\n    isArgumentInBurdenOfProof(B),\n    \\+ superiority::superiorArgument(B, C),\n    context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n    member(Arg, Arguments),\n    isArgumentInBurdenOfProof(Arg),\n    \\+ (\n        member(A, Arguments), Arg \\= A,\n        isArgumentInBurdenOfProof(A),\n        argumentChain(A, Arg)\n    ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n    A \\== B,\n    context_check(attack(_, A, C, _)),\n    argumentChain(C, B).\nreifyBurdenOfProofs :-\n    findall(_, (\n        context_check(abstractBp(AbstractBp)),\n        fillTemplate(AbstractBp, R),\n        \\+ context_check(reifiedBp(R)),\n        context_assert(reifiedBp(R))\n    ), _).\n/*\n    Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n    context_check(argument([_ , _, [P], _, _])),\n    fillTemplate(T, R).';
+    this.a3m_1 = 'argumentLabelling :-\n    reifyBurdenOfProofs,\n    filterBpDefeats,\n    findall(X, context_check(argument(X)), Arguments),\n    bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    grounded::allAttacksOUT(A), !,\n    context_assert(in(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    \\+ isArgumentInBurdenOfProof(A),\n    grounded::oneAttackIN(A), !,\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    context_active(Branch),\n    mostGroundedBpUnd(Arguments, A),\n    context_branch(Branch, _),\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Args) :-\n    notLabelled(Args),\n    findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n    \\+ (\n        member(A, Args),\n        (\n            context_check(in(A));\n            context_check(out(A));\n            context_check(und(A))\n        )\n    ).\nisInBurdenOfProof(Conclusion) :-\n    context_check(reifiedBp(Literals)),\n    member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n    isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        filterBpDefeat(T, A, B, C)\n    ), _).\nfilterBpDefeat(T, B, A, C) :-\n    (T = rebut; T = undermine),\n    isArgumentInBurdenOfProof(B),\n    \\+ superiority::superiorArgument(B, C),\n    context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n    member(Arg, Arguments),\n    isArgumentInBurdenOfProof(Arg),\n    \\+ (\n        member(A, Arguments), Arg \\= A,\n        isArgumentInBurdenOfProof(A),\n        argumentChain(A, Arg)\n    ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n    A \\== B,\n    context_check(attack(_, A, C, _)),\n    argumentChain(C, B).\nreifyBurdenOfProofs :-\n    findall(_, (\n        context_check(abstractBp(AbstractBp)),\n        fillTemplate(AbstractBp, R),\n        \\+ context_check(reifiedBp(R)),\n        context_assert(reifiedBp(R))\n    ), _).\n/*\n    Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n    context_check(argument([_ , _, [P], _, _])),\n    fillTemplate(T, R).';
   }
   var BpGrounded_instance;
   function BpGrounded_getInstance() {
     return BpGrounded_instance;
   }
   function BpGroundedComplete() {
-    this.x3l_1 = 'argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n    bp_grounded_partial::partialBpLabelling(Arguments), !,\n    findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n    grounded::groundedLabelling(NewArgs),\n    findall(X, context_check(und(X)), LeftArguments),\n    stopCondition(Stop, Arguments, LeftArguments),\n    completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n    utils::sort(Args, SortedArgs),\n    utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
+    this.w3l_1 = 'argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n    bp_grounded_partial::partialBpLabelling(Arguments), !,\n    findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n    grounded::groundedLabelling(NewArgs),\n    findall(X, context_check(und(X)), LeftArguments),\n    stopCondition(Stop, Arguments, LeftArguments),\n    completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n    utils::sort(Args, SortedArgs),\n    utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
   }
   var BpGroundedComplete_instance;
   function BpGroundedComplete_getInstance() {
     return BpGroundedComplete_instance;
   }
   function BpGroundedPartial() {
-    this.f3m_1 = "argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    partialBpLabelling(Arguments), !.\npartialBpLabelling([]).\npartialBpLabelling(Arguments) :-\n    mostGroundedArgument(Arguments, A),\n    debug::writeDebug(['Evaluating ', A]),\n    demonstration(Arguments, A, [A], Evaluated),\n    utils::subtract(Arguments, [Evaluated], NewArgs),\n    partialBpLabelling(NewArgs).\n/*\n    (a.i) BP(neg(\u03C6)), and no argument B for neg(\u03C6) such that A < B is IN*, and no A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    superiorComplementArgument(A, B),\n\t    context_check(in(B))\n\t),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    context_check(support(X, A)),\n\t    context_check(out(X))\n\t),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.i)']),\n    context_assert(in(A)).\n/*\n    (a.ii) not BP(neg(\u03C6)) and every argument B for neg(\u03C6) such that B(not <)A is OUT*, and every A1,...An is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, B),\n        \\+ context_check(out(B))\n    ),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        context_check(support(X, A)),\n        \\+ context_check(in(X))\n    ),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.ii)']),\n    context_assert(in(A)).\n/*\n    (b.i.1) BP(\u03C6) and exists an argument B for neg(\u03C6) such that B(not <)A is not OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorOrEqualComplementArgument(A, B),\n\t\\+ context_check(out(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.1)']),\n    context_assert(out(A)).\n/*\n    (b.i.2) BP(\u03C6) and exist one of A1,...An is not IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    \\+ context_check(in(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.2)']),\n    context_assert(out(A)).\n/*\n    (b.ii.1) not BP(\u03C6) and an argument B for neg(\u03C6) such A < B is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorComplementArgument(A, B),\n\tcontext_check(in(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.1)']),\n    context_assert(out(A)).\n/*\n    (b.ii.2) not BP(\u03C6) and one of A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    context_check(out(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.2)']),\n    context_assert(out(A)).\n/*\n    If above definitions do not apply try to decide on the arguments on which they depend\n*/\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorComplementArgument(A, X),\n        context_check(in(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    \\+ isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, X),\n        \\+ context_check(out(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\n/*\n    (c) A is labelled UND* otherwise.\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tdebug::writeDebug(['Adding argument: ', A, ' to UND* (2.c)']),\n    context_assert(und(A)).\nisComplementInBurdenOfProof(A) :-\n    complement(A, Complement),\n    bp_grounded::isInBurdenOfProof(Complement), !.\nmostGroundedArgument([], []).\nmostGroundedArgument([X], X).\nmostGroundedArgument([[L, _, _, _, _]|T], [L2, Q2, W2, B2, I2]) :-\n    mostGroundedArgument(T, [L2, Q2, W2, B2, I2]),\n    length(L, LN1),\n    length(L2, LN2),\n    LN1 > LN2, !.\nmostGroundedArgument([A|_], A).\n/*\n    Get a conclusion complement\n*/\ncomplement([_, _, Conclusion, _, _], A) :-\n    attack::expanded_conflict(Conclusion, A).\nnotEvaluatedSubArgument(Arguments, A, Resolving, B) :-\n    context_check(support(B, A)),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B) :-\n    superiorComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B) :-\n    superiorOrEqualComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nsuperiorComplementArgument(A, [A, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    superiority::superiorArgument([R, B, CA, BB, I], A).\nsuperiorOrEqualComplementArgument(A, [R, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    \\+ superiority::superiorArgument(A, [R, B, CA, BB, I]).";
+    this.e3m_1 = "argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    partialBpLabelling(Arguments), !.\npartialBpLabelling([]).\npartialBpLabelling(Arguments) :-\n    mostGroundedArgument(Arguments, A),\n    debug::writeDebug(['Evaluating ', A]),\n    demonstration(Arguments, A, [A], Evaluated),\n    utils::subtract(Arguments, [Evaluated], NewArgs),\n    partialBpLabelling(NewArgs).\n/*\n    (a.i) BP(neg(\u03C6)), and no argument B for neg(\u03C6) such that A < B is IN*, and no A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    superiorComplementArgument(A, B),\n\t    context_check(in(B))\n\t),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    context_check(support(X, A)),\n\t    context_check(out(X))\n\t),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.i)']),\n    context_assert(in(A)).\n/*\n    (a.ii) not BP(neg(\u03C6)) and every argument B for neg(\u03C6) such that B(not <)A is OUT*, and every A1,...An is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, B),\n        \\+ context_check(out(B))\n    ),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        context_check(support(X, A)),\n        \\+ context_check(in(X))\n    ),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.ii)']),\n    context_assert(in(A)).\n/*\n    (b.i.1) BP(\u03C6) and exists an argument B for neg(\u03C6) such that B(not <)A is not OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorOrEqualComplementArgument(A, B),\n\t\\+ context_check(out(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.1)']),\n    context_assert(out(A)).\n/*\n    (b.i.2) BP(\u03C6) and exist one of A1,...An is not IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    \\+ context_check(in(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.2)']),\n    context_assert(out(A)).\n/*\n    (b.ii.1) not BP(\u03C6) and an argument B for neg(\u03C6) such A < B is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorComplementArgument(A, B),\n\tcontext_check(in(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.1)']),\n    context_assert(out(A)).\n/*\n    (b.ii.2) not BP(\u03C6) and one of A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    context_check(out(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.2)']),\n    context_assert(out(A)).\n/*\n    If above definitions do not apply try to decide on the arguments on which they depend\n*/\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorComplementArgument(A, X),\n        context_check(in(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    \\+ isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, X),\n        \\+ context_check(out(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\n/*\n    (c) A is labelled UND* otherwise.\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tdebug::writeDebug(['Adding argument: ', A, ' to UND* (2.c)']),\n    context_assert(und(A)).\nisComplementInBurdenOfProof(A) :-\n    complement(A, Complement),\n    bp_grounded::isInBurdenOfProof(Complement), !.\nmostGroundedArgument([], []).\nmostGroundedArgument([X], X).\nmostGroundedArgument([[L, _, _, _, _]|T], [L2, Q2, W2, B2, I2]) :-\n    mostGroundedArgument(T, [L2, Q2, W2, B2, I2]),\n    length(L, LN1),\n    length(L2, LN2),\n    LN1 > LN2, !.\nmostGroundedArgument([A|_], A).\n/*\n    Get a conclusion complement\n*/\ncomplement([_, _, Conclusion, _, _], A) :-\n    attack::expanded_conflict(Conclusion, A).\nnotEvaluatedSubArgument(Arguments, A, Resolving, B) :-\n    context_check(support(B, A)),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B) :-\n    superiorComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B) :-\n    superiorOrEqualComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nsuperiorComplementArgument(A, [A, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    superiority::superiorArgument([R, B, CA, BB, I], A).\nsuperiorOrEqualComplementArgument(A, [R, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    \\+ superiority::superiorArgument(A, [R, B, CA, BB, I]).";
   }
   var BpGroundedPartial_instance;
   function BpGroundedPartial_getInstance() {
     return BpGroundedPartial_instance;
   }
   function Complete() {
-    this.j3m_1 = 'argumentLabelling :-\n    cache_retract(complete(_,_,_)),\n    grounded:::argumentLabelling,\n    context_active(Branch),\n    completeLabelling(Branch).\ncompleteLabelling(_) :-\n    admissibleSet,\n    utils::recoverArgumentLabelling(In, Out, Und),\n    \\+ cache_check(complete(In, Out, Und)),\n    cache_assert(complete(In, Out, Und)).\ncompleteLabelling(Branch) :-\n    context_check(und(X)),\n    context_branch(Branch, NewBranch),\n    findall(Y, (context_check(und(Y)), Y \\= X), Arguments),\n    context_retract(und(_)),\n    context_assert(in(X)),\n    grounded::groundedLabelling(Arguments),\n    completeLabelling(NewBranch).\nadmissibleSet :-\n    \\+ (context_check(in(H)), \\+ admissible(H)).\nadmissible(H) :-\n    \\+ (\n        context_check(attack(_, Attacker, H, _)),\n        \\+ (\n            context_check(attack(_, Defendant, Attacker, _)),\n            context_check(in(Defendant))\n        )\n    ).';
+    this.i3m_1 = 'argumentLabelling :-\n    cache_retract(complete(_,_,_)),\n    grounded:::argumentLabelling,\n    context_active(Branch),\n    completeLabelling(Branch).\ncompleteLabelling(_) :-\n    admissibleSet,\n    utils::recoverArgumentLabelling(In, Out, Und),\n    \\+ cache_check(complete(In, Out, Und)),\n    cache_assert(complete(In, Out, Und)).\ncompleteLabelling(Branch) :-\n    context_check(und(X)),\n    context_branch(Branch, NewBranch),\n    findall(Y, (context_check(und(Y)), Y \\= X), Arguments),\n    context_retract(und(_)),\n    context_assert(in(X)),\n    grounded::groundedLabelling(Arguments),\n    completeLabelling(NewBranch).\nadmissibleSet :-\n    \\+ (context_check(in(H)), \\+ admissible(H)).\nadmissible(H) :-\n    \\+ (\n        context_check(attack(_, Attacker, H, _)),\n        \\+ (\n            context_check(attack(_, Defendant, Attacker, _)),\n            context_check(in(Defendant))\n        )\n    ).';
   }
   var Complete_instance;
   function Complete_getInstance() {
     return Complete_instance;
   }
   function Debug() {
-    this.b3n_1 = "printTheory(Rules) :-\n    write('HERE THE THEORY:'),nl,\n    findall(rule([Id, Body, Head]), member(rule([Id, Body, Head]), Rules), ListRules),\n    utils::writeListNl(ListRules),\n    findall(premise([A, B]), member(premise([A, B]), Rules), ListPremises),\n    utils::writeListNl(ListPremises),\n    findall(sup(A, B), member(sup(A, B), Rules), ListSups),\n    utils::writeListNl(ListSups).\nprintArgumentationGraph(Arguments, Attacks, Supports) :-\n\tfindall(\n\t    [IDPremises, '\\n',  ' TOPRULE ',  TopRule, '\\n', ' CONCLUSION ', RuleHead, '\\n', ' BODY ', Body, '\\n', ' INFO ', Info, '\\n'],\n\t    member([IDPremises, TopRule, RuleHead, Body, Info], Arguments),\n        ArgumentsToPrint\n    ),\n    findall((A1, ' SUPPORTS ', A2), member((A1, A2), Supports), SupportsToPrint),\n\tfindall((A1, ' ', T, ' ', A2, ' ON ', A3),  member((T, A1, A2, A3), Attacks),  AttacksToPrint),\n    write('HERE THE GROUNDED SEMI-ABSTRACT ARGUMENTATION GRAPH'),nl,\n\tutils::writeListNl(ArgumentsToPrint),\n\tutils::writeListNl(SupportsToPrint),\n\tutils::writeListNl(AttacksToPrint).\nprintArgumentLabelling([IN, OUT, UND]) :-\n    write('HERE THE ARGUMENTS LABELLED IN: '),nl,\n    utils::writeListNl(IN),\n    write('HERE THE ARGUMENTS LABELLED OUT: '),nl,\n    utils::writeListNl(OUT),\n    write('HERE THE ARGUMENTS LABELLED UND: '),nl,\n    utils::writeListNl(UND).\nprintStatementLabelling([In, Ni, Und]) :-\n    write('HERE THE STATEMENTS LABELLED IN: '),nl,\n    utils::writeListNl(In),\n    write('HERE THE STATEMENTS LABELLED NI: '),nl,\n    utils::writeListNl(Ni),\n    write('HERE THE STATEMENTS LABELLED UND: '),nl,\n    utils::writeListNl(Und).\ndebug.\nwriteDebug(List) :-\n    debug,\n    utils::writeList(List).\nwriteDebug(_) :- \\+ debug.";
+    this.a3n_1 = "printTheory(Rules) :-\n    write('HERE THE THEORY:'),nl,\n    findall(rule([Id, Body, Head]), member(rule([Id, Body, Head]), Rules), ListRules),\n    utils::writeListNl(ListRules),\n    findall(premise([A, B]), member(premise([A, B]), Rules), ListPremises),\n    utils::writeListNl(ListPremises),\n    findall(sup(A, B), member(sup(A, B), Rules), ListSups),\n    utils::writeListNl(ListSups).\nprintArgumentationGraph(Arguments, Attacks, Supports) :-\n\tfindall(\n\t    [IDPremises, '\\n',  ' TOPRULE ',  TopRule, '\\n', ' CONCLUSION ', RuleHead, '\\n', ' BODY ', Body, '\\n', ' INFO ', Info, '\\n'],\n\t    member([IDPremises, TopRule, RuleHead, Body, Info], Arguments),\n        ArgumentsToPrint\n    ),\n    findall((A1, ' SUPPORTS ', A2), member((A1, A2), Supports), SupportsToPrint),\n\tfindall((A1, ' ', T, ' ', A2, ' ON ', A3),  member((T, A1, A2, A3), Attacks),  AttacksToPrint),\n    write('HERE THE GROUNDED SEMI-ABSTRACT ARGUMENTATION GRAPH'),nl,\n\tutils::writeListNl(ArgumentsToPrint),\n\tutils::writeListNl(SupportsToPrint),\n\tutils::writeListNl(AttacksToPrint).\nprintArgumentLabelling([IN, OUT, UND]) :-\n    write('HERE THE ARGUMENTS LABELLED IN: '),nl,\n    utils::writeListNl(IN),\n    write('HERE THE ARGUMENTS LABELLED OUT: '),nl,\n    utils::writeListNl(OUT),\n    write('HERE THE ARGUMENTS LABELLED UND: '),nl,\n    utils::writeListNl(UND).\nprintStatementLabelling([In, Ni, Und]) :-\n    write('HERE THE STATEMENTS LABELLED IN: '),nl,\n    utils::writeListNl(In),\n    write('HERE THE STATEMENTS LABELLED NI: '),nl,\n    utils::writeListNl(Ni),\n    write('HERE THE STATEMENTS LABELLED UND: '),nl,\n    utils::writeListNl(Und).\ndebug.\nwriteDebug(List) :-\n    debug,\n    utils::writeList(List).\nwriteDebug(_) :- \\+ debug.";
   }
   var Debug_instance;
   function Debug_getInstance() {
     return Debug_instance;
   }
   function DefPreferences() {
-    this.l3l_1 = 'modifyArgumentationGraph :-\n    assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    convertAttacks(InvalidAttacks),\n    buildPrefAttacks.\nassertAllSup :-\n    context_retract(sup(_, _)),\n    findall(_,\n        (\n            context_check(argument([_, _, [sup(RuleOne, RuleTwo)], _, _])),\n            \\+ context_check(sup(RuleOne, RuleTwo)),\n            context_assert(sup(RuleOne, RuleTwo))\n        ),\n    _).\nfilterSupRelatedAttacks([], []).\nfilterSupRelatedAttacks([(T, A, B, C)|Attacks], [(T, A, B, C)|Invalid]) :-\n    invalid(T, A, B, C, _),\n    filterSupRelatedAttacks(Attacks, Invalid), !.\nfilterSupRelatedAttacks([_|Attacks], Invalid) :-\n    filterSupRelatedAttacks(Attacks, Invalid).\ninvalid(rebut, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\ninvalid(undermine, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\n/*\n*   Translates the attack relations identified during the building phase.\n*   Attack from A to B -> Argument [[], attack, Attack]\n*                         support(A, Argument)\n*                         attack(Argument, B)\n*   If an Argument A built in this way attacks the argument B, and this one also attacks a third argument C\n*   through the argument B1 we have to consider an attack from A to B1 (transitive attack)\n*/\nconvertAttacks(Attacks) :-\n    conversion(Attacks),\n    standard_af::buildTransitiveAttacks.\nconversion(List) :-\n    member((T, A, B, B), List),\n    generateDirectAttackArgument(T, A, B, B),\n    fail.\nconversion(List) :-\n    member((T, A, B, C), List),\n    C \\= B,\n    generateTransitiveAttackArgument(T, A, B, C),\n    fail.\nconversion(_).\ngenerateTransitiveAttackArgument(T, A, B, C) :-\n    context_check(argument([Id, attack, [attack(T, A, C, C)], G, I])),\n    standard_af::saveAttack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C),\n    standard_af::removeAttack(T, A, B, C).\ngenerateDirectAttackArgument(T, A, B, B) :-\n    RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n    standard_af::saveArgument(a, [attack(T, A, B, B)], RArgument),\n    standard_af::saveSupport(A, RArgument),\n    standard_af::saveAttack(T, RArgument, B, B),\n    standard_af::removeAttack(T, A, B, B).\n/*\n*   Computes the pref attack. If an Argument A has a conclusion in the form sup(a, b), we verify if\n*   the attacks involving arguments built on the rules a or b are compatible with this preference.\n*   If there are some contradictions we add an attack from the argument A towards the incompatible attack\n*/\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    invalid(T, A, B, C, SupSet),\n    member(X, SupSet),\n    context_check(argument([IdA, TRA, [X], GG, II])),\n    standard_af::saveAttack(pref, [IdA, TRA, [X], GG, II], [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.';
+    this.k3l_1 = 'modifyArgumentationGraph :-\n    assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    convertAttacks(InvalidAttacks),\n    buildPrefAttacks.\nassertAllSup :-\n    context_retract(sup(_, _)),\n    findall(_,\n        (\n            context_check(argument([_, _, [sup(RuleOne, RuleTwo)], _, _])),\n            \\+ context_check(sup(RuleOne, RuleTwo)),\n            context_assert(sup(RuleOne, RuleTwo))\n        ),\n    _).\nfilterSupRelatedAttacks([], []).\nfilterSupRelatedAttacks([(T, A, B, C)|Attacks], [(T, A, B, C)|Invalid]) :-\n    invalid(T, A, B, C, _),\n    filterSupRelatedAttacks(Attacks, Invalid), !.\nfilterSupRelatedAttacks([_|Attacks], Invalid) :-\n    filterSupRelatedAttacks(Attacks, Invalid).\ninvalid(rebut, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\ninvalid(undermine, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\n/*\n*   Translates the attack relations identified during the building phase.\n*   Attack from A to B -> Argument [[], attack, Attack]\n*                         support(A, Argument)\n*                         attack(Argument, B)\n*   If an Argument A built in this way attacks the argument B, and this one also attacks a third argument C\n*   through the argument B1 we have to consider an attack from A to B1 (transitive attack)\n*/\nconvertAttacks(Attacks) :-\n    conversion(Attacks),\n    standard_af::buildTransitiveAttacks.\nconversion(List) :-\n    member((T, A, B, B), List),\n    generateDirectAttackArgument(T, A, B, B),\n    fail.\nconversion(List) :-\n    member((T, A, B, C), List),\n    C \\= B,\n    generateTransitiveAttackArgument(T, A, B, C),\n    fail.\nconversion(_).\ngenerateTransitiveAttackArgument(T, A, B, C) :-\n    context_check(argument([Id, attack, [attack(T, A, C, C)], G, I])),\n    standard_af::saveAttack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C),\n    standard_af::removeAttack(T, A, B, C).\ngenerateDirectAttackArgument(T, A, B, B) :-\n    RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n    standard_af::saveArgument(a, [attack(T, A, B, B)], RArgument),\n    standard_af::saveSupport(A, RArgument),\n    standard_af::saveAttack(T, RArgument, B, B),\n    standard_af::removeAttack(T, A, B, B).\n/*\n*   Computes the pref attack. If an Argument A has a conclusion in the form sup(a, b), we verify if\n*   the attacks involving arguments built on the rules a or b are compatible with this preference.\n*   If there are some contradictions we add an attack from the argument A towards the incompatible attack\n*/\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    invalid(T, A, B, C, SupSet),\n    member(X, SupSet),\n    context_check(argument([IdA, TRA, [X], GG, II])),\n    standard_af::saveAttack(pref, [IdA, TRA, [X], GG, II], [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.';
   }
   var DefPreferences_instance;
   function DefPreferences_getInstance() {
     return DefPreferences_instance;
   }
   function GenericDefPreferences() {
-    this.p3l_1 = 'modifyArgumentationGraph :-\n    defeasiblePref::assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    defeasiblePref::filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    defeasiblePref::convertAttacks(InvalidAttacks),\n    buildPrefAttacks,\n    standard_af::buildTransitiveAttacks.\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    defeasiblePref::invalid(T, A, B, C, SupSet),\n    createSuperiorityArgument(SupSet, Arg),\n    standard_af::saveAttack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.\ncreateSuperiorityArgument(SupSet, Argument) :-\n    findall([Id, TR, [X], G, I], (\n        member(X, SupSet),\n        context_check(argument([Id, TR, [X], G, I]))\n    ), SupportArguments),\n    mergeIds(SupportArguments, MergedId),\n    Argument = [MergedId, pref, [preference(SupSet)], [], [[pref], MergedId, []]],\n    standard_af::saveArgument(a, [preference(SupSet)], Argument),\n    findall(_, (\n        member(A, SupportArguments),\n        standard_af::saveSupport(A, Argument)\n    ), _).\nmergeIds([], [pref]).\nmergeIds(Arguments, [pref|MergedId]) :-\n    findall(Id, member([Id, _, _, _, _], Arguments), Res),\n    utils::appendLists(Res, MergedId).';
+    this.o3l_1 = 'modifyArgumentationGraph :-\n    defeasiblePref::assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    defeasiblePref::filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    defeasiblePref::convertAttacks(InvalidAttacks),\n    buildPrefAttacks,\n    standard_af::buildTransitiveAttacks.\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    defeasiblePref::invalid(T, A, B, C, SupSet),\n    createSuperiorityArgument(SupSet, Arg),\n    standard_af::saveAttack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.\ncreateSuperiorityArgument(SupSet, Argument) :-\n    findall([Id, TR, [X], G, I], (\n        member(X, SupSet),\n        context_check(argument([Id, TR, [X], G, I]))\n    ), SupportArguments),\n    mergeIds(SupportArguments, MergedId),\n    Argument = [MergedId, pref, [preference(SupSet)], [], [[pref], MergedId, []]],\n    standard_af::saveArgument(a, [preference(SupSet)], Argument),\n    findall(_, (\n        member(A, SupportArguments),\n        standard_af::saveSupport(A, Argument)\n    ), _).\nmergeIds([], [pref]).\nmergeIds(Arguments, [pref|MergedId]) :-\n    findall(Id, member([Id, _, _, _, _], Arguments), Res),\n    utils::appendLists(Res, MergedId).';
   }
   var GenericDefPreferences_instance;
   function GenericDefPreferences_getInstance() {
     return GenericDefPreferences_instance;
   }
   function Grounded() {
-    this.n3m_1 = 'argumentLabelling :-\n    findall(X, context_check(argument(X)), Arguments),\n    groundedLabelling(Arguments).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    allAttacksOUT(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(in(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    oneAttackIN(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(out(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\nallAttacksOUT(A) :-\n    \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\noneAttackIN(A) :-\n    context_check(attack(_, B, A, _)),\n    context_check(in(B)), !.\noneAttackIN(A) :-\n    context_check(attack(_, A, B, _)),\n    context_check(in(B)), !.';
+    this.m3m_1 = 'argumentLabelling :-\n    findall(X, context_check(argument(X)), Arguments),\n    groundedLabelling(Arguments).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    allAttacksOUT(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(in(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    oneAttackIN(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(out(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\nallAttacksOUT(A) :-\n    \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\noneAttackIN(A) :-\n    context_check(attack(_, B, A, _)),\n    context_check(in(B)), !.\noneAttackIN(A) :-\n    context_check(attack(_, A, B, _)),\n    context_check(in(B)), !.';
   }
   var Grounded_instance;
   function Grounded_getInstance() {
     return Grounded_instance;
   }
   function GroundedOptimized() {
-    this.r3m_1 = 'argumentLabelling :-\n    groundedLabelling.\ngroundedLabelling :-\n    findall(t, evaluateIn, I),\n    findall(t, evaluateOut, O),\n    finalize(I, O).\nevaluateIn :-\n    argument_to_evaluate(A, IdA),\n    allAttacksOUT(IdA),\n    context_assert(in(A)),\n    context_assert(inId(IdA)).\nevaluateOut :-\n    argument_to_evaluate(A, IdA),\n    oneAttackIN(IdA),\n    context_assert(out(A)),\n    context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n    argument_to_evaluate(A, _),\n    context_assert(und(A)),\n    fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n    context_check(clause(arg(IdX), argument(X))),\n    \\+ context_check(outId(IdX)),\n    \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n    \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n    context_check(clause(att(B, A), _)),\n    context_check(inId(B)), !.\noneAttackIN(A) :-\n    context_check(clause(att(A, B), _)),\n    context_check(inId(B)), !.';
+    this.q3m_1 = 'argumentLabelling :-\n    groundedLabelling.\ngroundedLabelling :-\n    findall(t, evaluateIn, I),\n    findall(t, evaluateOut, O),\n    finalize(I, O).\nevaluateIn :-\n    argument_to_evaluate(A, IdA),\n    allAttacksOUT(IdA),\n    context_assert(in(A)),\n    context_assert(inId(IdA)).\nevaluateOut :-\n    argument_to_evaluate(A, IdA),\n    oneAttackIN(IdA),\n    context_assert(out(A)),\n    context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n    argument_to_evaluate(A, _),\n    context_assert(und(A)),\n    fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n    context_check(clause(arg(IdX), argument(X))),\n    \\+ context_check(outId(IdX)),\n    \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n    \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n    context_check(clause(att(B, A), _)),\n    context_check(inId(B)), !.\noneAttackIN(A) :-\n    context_check(clause(att(A, B), _)),\n    context_check(inId(B)), !.';
   }
   var GroundedOptimized_instance;
   function GroundedOptimized_getInstance() {
     return GroundedOptimized_instance;
   }
   function Preferences() {
-    this.t3l_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkStandardPreference(T, A, B, C)\n    ), _).\ncheckStandardPreference(T, A, B, C) :-\n    \\+ standardPreferences(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).';
+    this.s3l_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkStandardPreference(T, A, B, C)\n    ), _).\ncheckStandardPreference(T, A, B, C) :-\n    \\+ standardPreferences(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).';
   }
   var Preferences_instance;
   function Preferences_getInstance() {
     return Preferences_instance;
   }
   function QueryMode_0() {
-    this.c3n_1 = 'computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    \\+ queryMode,\n    abstract:::computeGlobalAcceptance,\n    mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    queryMode,\n    argumentLabellingMode(grounded),\n    findall(_, query(Goal, _), _),\n    (ambiguityBlocking ->\n        statement_binary:::statementLabelling;\n        statementLabellingMode(Y),\n        Y:::statementLabelling\n    ),\n    mineResults(Goal, YesResult, NoResult, UndResult).\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n    findall(Goal, context_check(statIn([Goal])), In),\n    findall(Goal, context_check(statOut([Goal])), Out),\n    findall(Goal, context_check(statUnd([Goal])), Und),\n    utils::sort(In, YesResult),\n    utils::sort(Out, NoResult),\n    utils::sort(Und, UndResult).\nquery(Query, Res) :-\n    buildArgument(Query, Argument),\n    once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == yes,\n    bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == und,\n    ambiguityCheck(Argument, Attacker, Res),\n    bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n    attack::expanded_conflict(ConclusionA, ConclusionB).\nambiguityCheck(A, B, no) :- ambiguityBlocking,\n    \\+ complementary(A, B),\n    context_check(attack(direct, B, A, _)), !.\nambiguityCheck(_, _, und).\ndefend(Argument, QueryChain, und) :-\n    findAttacker(Argument, QueryChain, Attacker, no),\n    bufferResult(Argument, und), !.\ndefend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\nbufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\nbufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\nbufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\nbufferResult(_, _).\nfindAttacker(Target, QueryChain, Attacker, IsValid) :-\n    attacker(Target, Attacker, Type),\n    bufferAttacker(Attacker, Target, Type),\n    detectCycle(Attacker, QueryChain, IsValid).\nbufferAttacker(Attacker, Target, Type) :-\n    \\+ context_check(attack(Type, Attacker, Target, none)),\n    context_assert(attack(Type, Attacker, Target, none)), !.\nbufferAttacker(_, _, _).\ndetectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\ndetectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Rules),\n    \\+ parser::strict(X),\n    attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Groundings),\n    attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattackerOnRule(Rule, _, Argument, undercut) :-\n    parser::undercut(Undercut, Rule),\n    buildArgument(Undercut, Argument).\nattackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n    \\+ parser::contrary(Term, _),\n    \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n    (graphExtension(rebutRestriction) ->\n        (\n            getSubArgument(Term, TargetRules, SubArgument),\n            rebutRestriction(SubArgument)\n        );\n        true\n    ),\n    attack::expanded_conflict(Term, [X]),\n    buildArgument(X, Attacker),\n    (graphExtension(standardPref) ->\n        (\n            once(getSubArgument(Term, TargetRules, SubArgument)),\n            \\+ superiorArgument(SubArgument, Attacker)\n        );\n        true\n    ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n    parser::contrary(Unless, X),\n    buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction),\n    TopRule \\= none,\n    rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n    superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n    context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n    contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n    \\+ context_check(explored(Query)),\n    findall(_, (\n        buildSingleArgument([Query], Argument),\n        context_assert(argument(Argument))\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n    build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::rule(Id, Premises, Conclusion),\n    \\+ member(Id, Ids),\n    buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n    build([H], Ids, HConclusions, HRules),\n    buildPremises(T, Ids, TConclusions, TRules),\n    utils::appendLists([HConclusions, TConclusions], Conclusions),\n    mergeRules(HRules, TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n    [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n    [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n   utils::appendLists([HAR, TAR], AR),\n   utils::appendLists([HLDR, TLDR], LDR),\n   utils::appendLists([HDR, TDR], DR),\n   utils::appendLists([HDP, TDP], DP).';
+    this.b3n_1 = 'computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    \\+ queryMode,\n    abstract:::computeGlobalAcceptance,\n    mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    queryMode,\n    argumentLabellingMode(grounded),\n    findall(_, query(Goal, _), _),\n    (ambiguityBlocking ->\n        statement_binary:::statementLabelling;\n        statementLabellingMode(Y),\n        Y:::statementLabelling\n    ),\n    mineResults(Goal, YesResult, NoResult, UndResult).\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n    findall(Goal, context_check(statIn([Goal])), In),\n    findall(Goal, context_check(statOut([Goal])), Out),\n    findall(Goal, context_check(statUnd([Goal])), Und),\n    utils::sort(In, YesResult),\n    utils::sort(Out, NoResult),\n    utils::sort(Und, UndResult).\nquery(Query, Res) :-\n    buildArgument(Query, Argument),\n    once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == yes,\n    bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == und,\n    ambiguityCheck(Argument, Attacker, Res),\n    bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n    attack::expanded_conflict(ConclusionA, ConclusionB).\nambiguityCheck(A, B, no) :- ambiguityBlocking,\n    \\+ complementary(A, B),\n    context_check(attack(direct, B, A, _)), !.\nambiguityCheck(_, _, und).\ndefend(Argument, QueryChain, und) :-\n    findAttacker(Argument, QueryChain, Attacker, no),\n    bufferResult(Argument, und), !.\ndefend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\nbufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\nbufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\nbufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\nbufferResult(_, _).\nfindAttacker(Target, QueryChain, Attacker, IsValid) :-\n    attacker(Target, Attacker, Type),\n    bufferAttacker(Attacker, Target, Type),\n    detectCycle(Attacker, QueryChain, IsValid).\nbufferAttacker(Attacker, Target, Type) :-\n    \\+ context_check(attack(Type, Attacker, Target, none)),\n    context_assert(attack(Type, Attacker, Target, none)), !.\nbufferAttacker(_, _, _).\ndetectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\ndetectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Rules),\n    \\+ parser::strict(X),\n    attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Groundings),\n    attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattackerOnRule(Rule, _, Argument, undercut) :-\n    parser::undercut(Undercut, Rule),\n    buildArgument(Undercut, Argument).\nattackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n    \\+ parser::contrary(Term, _),\n    \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n    (graphExtension(rebutRestriction) ->\n        (\n            getSubArgument(Term, TargetRules, SubArgument),\n            rebutRestriction(SubArgument)\n        );\n        true\n    ),\n    attack::expanded_conflict(Term, [X]),\n    buildArgument(X, Attacker),\n    (graphExtension(standardPref) ->\n        (\n            once(getSubArgument(Term, TargetRules, SubArgument)),\n            \\+ superiorArgument(SubArgument, Attacker)\n        );\n        true\n    ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n    parser::contrary(Unless, X),\n    buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction),\n    TopRule \\= none,\n    rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n    superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n    context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n    contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n    \\+ context_check(explored(Query)),\n    findall(_, (\n        buildSingleArgument([Query], Argument),\n        context_assert(argument(Argument))\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n    build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::rule(Id, Premises, Conclusion),\n    \\+ member(Id, Ids),\n    buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n    build([H], Ids, HConclusions, HRules),\n    buildPremises(T, Ids, TConclusions, TRules),\n    utils::appendLists([HConclusions, TConclusions], Conclusions),\n    mergeRules(HRules, TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n    [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n    [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n   utils::appendLists([HAR, TAR], AR),\n   utils::appendLists([HLDR, TLDR], LDR),\n   utils::appendLists([HDR, TDR], DR),\n   utils::appendLists([HDP, TDP], DP).';
   }
   var QueryMode_instance_0;
   function QueryMode_getInstance_0() {
     return QueryMode_instance_0;
   }
   function RuleTranslator() {
-    this.z3m_1 = "/*\n *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n *  or (Name : Effects) and then if:\n *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n *  - It is a bp rule, translate it to (abstractBp([Effects]))\n *  During the process, clean them from the unallowed symbols (-, o, p).\n */\nconvertAllRules(ArgRules) :-\n    defeasibleRules(DefeasibleRules),\n    strictRules(StrictRules, RulesIds),\n    ordinaryPremises(Premises),\n    axiomPremises(Axioms, AxiomsIds),\n    specialRules(SpecialRules),\n    utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms], Rules),\n    rule_to_clause(Rules, Clauses),\n    findall(sup(X, Y), sup(X, Y), Sup),\n    utils::appendLists([Clauses, AxiomsIds, RulesIds, Sup, SpecialRules], ArgRules),\n    utils::assert_all(ArgRules), !.\ndefeasibleRules(DefeasibleRules) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n    prologDefeasibleRules(DefeasibleRulesNew),\n    utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\nstrictRules(CtrRules, Ids) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n    prologStrictRules(StrictRulesNew),\n    utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n    transpose(StrictRules, StrictRules, CtrRules),\n    extract_id(CtrRules, Ids).\nordinaryPremises(Premises) :-\n    findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n    prologPremises(PremisesNew),\n    utils::append_fast(PremisesOld, PremisesNew, Premises).\naxiomPremises(Axioms, Ids) :-\n    findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n    prologAxioms(AxiomsNew),\n    utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n    extract_id(Axioms, Ids).\nspecialRules(SpecialRules) :-\n    bpsNew(SpecialRules).\ntranspose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\ntranspose([], CtrRules, CtrRules).\ntranspose([H|T], TempCtrRules, CtrRules) :-\n    transpose(T, TempCtrRules, CR),\n    findall(TrH, transposition(H, TrH), Tran),\n    mergeCtrRules(CR, Tran, CtrRules).\nmergeCtrRules(All, ToMerge, X) :-\n    utils::append_fast(All, ToMerge, XT),\n    deduplicate(XT, X).\ndeduplicate([], []).\ndeduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \ntransposition([Id, Prec, Effect], [Id, Prec, Effect]).\ntransposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n    compound(Prec),\n    tuple_to_list(Prec, LPrec),!,\n    transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\ntransposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n    \\+ compound(Prec),\n    Prec \\== [],\n    prologEscape(Prec),\n    negate(Prec, XNegated),\n    negate(Effect, EffectNegated),\n    atom_concat(Id, '_i', NewId).\ntransposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\ntransposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    prologEscape(X),\n    utils::append_fast(Skipped, T, CleanedPrec),\n    negate(X, XNegated),\n    negate(Effect, EffectNegated),\n    list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n    newIdentifier(Skipped, Id, NewId).\nnewIdentifier(List, OldId, NewId) :-\n    modifier(List, Mod),\n    atom_concat(OldId, Mod, NewId).\nmodifier([], '_i').\nmodifier([_|Tail], Index):-\n    modifier(Tail, Index1),\n    atom_concat(Index1, 'i', Index).\nnegate(X, Arg) :-\n    functor(X, '-', _) -> (\n        arg(1, X, Arg));\n    functor(X, 'p', _) -> (\n        arg(1, X, PX),\n        (functor(PX, '-', _) -> (\n            arg(1, PX, PNX),\n            Arg = o(PNX)\n        );\n        Arg = o(-(PX))));\n    Arg = -(X).\nprologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n/*\n *   Standard rules (RuleName : Preconditions => Effects)\n *   Special rules (RuleName : Effects)\n */\nconvertAllRules([], []).\nconvertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\nconvertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n/*\n *   Convert the given rule to the standard format\n *   Example:\n *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n */\nconvertRule(RuleName, Preconditions, Effects, rule(List)) :-\n    tuple_to_list(Preconditions, Lprecond),\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n    List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n/*\n *   Convert the given special rule\n *   Example:\n *   bp(-liable(X)).\n *   abastractBp([[neg, liable(X_e4149)]]).\n */\nconvertRule(bps, Effects, abstractBp(Checked)) :-\n    functor(Effects, 'bp', _),\n    Effects =.. L,\n    removehead(L, LC),\n    check_modifiers_in_list(effects, LC, Checked), !.\nconvertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n/*\n *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n *   raplace them with the assigned literal (neg, obl, perm)\n */\ncheck_modifiers_in_list(MODE, [], []) :- !.\ncheck_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\ncheck_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n                            check_modifiers_once(H, LH),\n                            check_modifiers_in_list(MODE, T, LT),\n                            utils::append_fast([LH], LT, L),\n                            R = L.\ncheck_modifiers_once(H, List) :- once(check_modifiers(H, List)).\ncheck_modifiers([], []).\ncheck_modifiers(H, List) :-\n    functor(H, '-', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        utils::append_fast([neg], Lobl, Lf),\n        List = Lf);\n    functor(H, 'o', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        List = [obl|[Lobl]]);\n    functor(H, 'p', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [perm|[Lper]]);\n    functor(H, '~', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [unless|[Lper]]);\n    functor(H, 'bp', _) -> (\n        H =.. [_|Arg],\n        check_modifiers_in_list(effects, Arg, Lper),\n        List = [bp|[Lper]]);\n    List = [H].\nlist_to_tuple([H], (H)) :- !.\nlist_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n/*\n *   Replace all the occurences of a given element with the given argument\n */\nreplace(_, _, [],[]) :- !.\nreplace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\nreplace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\nflatten_first_level([X], X) :- !.\nflatten_first_level.\nremovehead([_|Tail], Tail).\nin(A, A) :- nonvar(A), A \\= (_ , _), !.\nin(A, (A, _)) :- !.\nin(A, (_ , Cs)) :- in(A, Cs).\ncheck_admissibility(preconditions, H, LH) :-\n    \\+ defeasible_admissible(LH),\n    throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(effects, H, LH) :-\n    \\+ admissible(LH),\n    throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(_, _, _).\ndefeasible_admissible([unless, Term]) :- admissible(Term).\ndefeasible_admissible(Term) :- admissible(Term).\nadmissible([neg, bp, Term]) :- admissible_terms_complete(Term).\nadmissible([bp, Term]) :- admissible_terms_complete(Term).\nadmissible([neg, Term]) :- admissible_term(Term).\nadmissible([obl, [Term]]) :- admissible_term(Term).\nadmissible([obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([perm, [Term]]) :- admissible_term(Term).\nadmissible([perm, [neg, Term]]) :- admissible_term(Term).\nadmissible([Term]) :- admissible_term(Term).\nadmissible_term(Term) :-\n    atomic(Term),\n    Term \\== neg,\n    Term \\== obl,\n    Term \\== perm,\n    Term \\== unless,\n    Term \\== bp.\nadmissible_term(Term) :- var(Term).\nadmissible_term(Term) :-\n    compound(Term),\n    \\+ functor(Term, 'o', _),\n    \\+ functor(Term, 'p', _),\n    \\+ functor(Term, '-', _),\n    \\+ functor(Term, '~', _),\n    \\+ functor(Term, 'bp', _),\n    Term =.. [_|Args],\n    admissible_terms(Args).\nadmissible_terms([]).\nadmissible_terms([H|T]) :-\n    admissible_term(H),\n    admissible_terms(T).\nadmissible_terms_complete([]).\nadmissible_terms_complete([H|T]) :-\n    admissible(H),\n    admissible_terms_complete(T).\nrule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\npremise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\ncheck_strict(Id) :- context_check(strict(Id)).\nprolog([prolog(Term)], Term).\ncontrary([~(Term)], Term).\nundercut(undercut(Rule), Rule).\nsuperiority(sup(Id1, Id2), Id1, Id2).\n/*\n *   Convert the given tuple to list\n */\ntuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\ntuple_to_list((A,B),L) :-\n    tuple_to_list(A, La),\n    tuple_to_list(B, Lb),\n    utils::append_fast(La, Lb,L).\nff([[]], []) :- !.\nff([[X]], [X]) :- !.\nff(X, X).\nclassic_rule(X, [applicable(X)|Y], Z) :- metaRules, !, rule(X, Y, Z).\nclassic_rule(X, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).\nclassic_conflict([A], [B], C) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B, C)]), _)).\nclassic_conflict([A], [B]) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B)]), _)).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    member(conflict(A, B, C), [\n        conflict([Atom], [-Atom], (Atom \\= -_)),\n        conflict([-Atom], [Atom], true),\n        conflict([o(Atom)], [o(-Atom)], (Atom \\= -_)),                   % O(x) <-> O(-x)\n        conflict([o(-Atom)], [o(Atom)], true),\n        conflict([p(Atom)], [o(-Atom)], (Atom \\= -_)),                   % P(x) <-> O(-x)\n        conflict([o(-Atom)], [p(Atom)], true),\n        conflict([o(Atom)], [p(-Atom)], (Atom \\= -_)),                   % O(x) <-> P(-x)\n        conflict([p(-Atom)], [o(Atom)], true),\n        conflict([o(Atom)], [-p(Atom)], true),                           % O(x) <-> O(-x) (-P(x))\n        conflict([-p(Atom)], [o(Atom)], true),\n        conflict([sup(X, Y)], [sup(Y, X)], true)\n    ]).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    conflict(A, B, C).\nclassic_conflict(A, B) :-\n    \\+ metaConflicts,\n    conflict(A, B).";
+    this.y3m_1 = "/*\n *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n *  or (Name : Effects) and then if:\n *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n *  - It is a bp rule, translate it to (abstractBp([Effects]))\n *  During the process, clean them from the unallowed symbols (-, o, p).\n */\nconvertAllRules(ArgRules) :-\n    defeasibleRules(DefeasibleRules),\n    strictRules(StrictRules, RulesIds),\n    ordinaryPremises(Premises),\n    axiomPremises(Axioms, AxiomsIds),\n    specialRules(SpecialRules),\n    utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms], Rules),\n    rule_to_clause(Rules, Clauses),\n    findall(sup(X, Y), sup(X, Y), Sup),\n    utils::appendLists([Clauses, AxiomsIds, RulesIds, Sup, SpecialRules], ArgRules),\n    utils::assert_all(ArgRules), !.\ndefeasibleRules(DefeasibleRules) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n    prologDefeasibleRules(DefeasibleRulesNew),\n    utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\nstrictRules(CtrRules, Ids) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n    prologStrictRules(StrictRulesNew),\n    utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n    transpose(StrictRules, StrictRules, CtrRules),\n    extract_id(CtrRules, Ids).\nordinaryPremises(Premises) :-\n    findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n    prologPremises(PremisesNew),\n    utils::append_fast(PremisesOld, PremisesNew, Premises).\naxiomPremises(Axioms, Ids) :-\n    findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n    prologAxioms(AxiomsNew),\n    utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n    extract_id(Axioms, Ids).\nspecialRules(SpecialRules) :-\n    bpsNew(SpecialRules).\ntranspose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\ntranspose([], CtrRules, CtrRules).\ntranspose([H|T], TempCtrRules, CtrRules) :-\n    transpose(T, TempCtrRules, CR),\n    findall(TrH, transposition(H, TrH), Tran),\n    mergeCtrRules(CR, Tran, CtrRules).\nmergeCtrRules(All, ToMerge, X) :-\n    utils::append_fast(All, ToMerge, XT),\n    deduplicate(XT, X).\ndeduplicate([], []).\ndeduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \ntransposition([Id, Prec, Effect], [Id, Prec, Effect]).\ntransposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n    compound(Prec),\n    tuple_to_list(Prec, LPrec),!,\n    transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\ntransposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n    \\+ compound(Prec),\n    Prec \\== [],\n    prologEscape(Prec),\n    negate(Prec, XNegated),\n    negate(Effect, EffectNegated),\n    atom_concat(Id, '_i', NewId).\ntransposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\ntransposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    prologEscape(X),\n    utils::append_fast(Skipped, T, CleanedPrec),\n    negate(X, XNegated),\n    negate(Effect, EffectNegated),\n    list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n    newIdentifier(Skipped, Id, NewId).\nnewIdentifier(List, OldId, NewId) :-\n    modifier(List, Mod),\n    atom_concat(OldId, Mod, NewId).\nmodifier([], '_i').\nmodifier([_|Tail], Index):-\n    modifier(Tail, Index1),\n    atom_concat(Index1, 'i', Index).\nnegate(X, Arg) :-\n    functor(X, '-', _) -> (\n        arg(1, X, Arg));\n    functor(X, 'p', _) -> (\n        arg(1, X, PX),\n        (functor(PX, '-', _) -> (\n            arg(1, PX, PNX),\n            Arg = o(PNX)\n        );\n        Arg = o(-(PX))));\n    Arg = -(X).\nprologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n/*\n *   Standard rules (RuleName : Preconditions => Effects)\n *   Special rules (RuleName : Effects)\n */\nconvertAllRules([], []).\nconvertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\nconvertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n/*\n *   Convert the given rule to the standard format\n *   Example:\n *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n */\nconvertRule(RuleName, Preconditions, Effects, rule(List)) :-\n    tuple_to_list(Preconditions, Lprecond),\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n    List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n/*\n *   Convert the given special rule\n *   Example:\n *   bp(-liable(X)).\n *   abastractBp([[neg, liable(X_e4149)]]).\n */\nconvertRule(bps, Effects, abstractBp(Checked)) :-\n    functor(Effects, 'bp', _),\n    Effects =.. L,\n    removehead(L, LC),\n    check_modifiers_in_list(effects, LC, Checked), !.\nconvertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n/*\n *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n *   raplace them with the assigned literal (neg, obl, perm)\n */\ncheck_modifiers_in_list(MODE, [], []) :- !.\ncheck_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\ncheck_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n                            check_modifiers_once(H, LH),\n                            check_modifiers_in_list(MODE, T, LT),\n                            utils::append_fast([LH], LT, L),\n                            R = L.\ncheck_modifiers_once(H, List) :- once(check_modifiers(H, List)).\ncheck_modifiers([], []).\ncheck_modifiers(H, List) :-\n    functor(H, '-', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        utils::append_fast([neg], Lobl, Lf),\n        List = Lf);\n    functor(H, 'o', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        List = [obl|[Lobl]]);\n    functor(H, 'p', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [perm|[Lper]]);\n    functor(H, '~', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [unless|[Lper]]);\n    functor(H, 'bp', _) -> (\n        H =.. [_|Arg],\n        check_modifiers_in_list(effects, Arg, Lper),\n        List = [bp|[Lper]]);\n    List = [H].\nlist_to_tuple([H], (H)) :- !.\nlist_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n/*\n *   Replace all the occurences of a given element with the given argument\n */\nreplace(_, _, [],[]) :- !.\nreplace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\nreplace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\nflatten_first_level([X], X) :- !.\nflatten_first_level.\nremovehead([_|Tail], Tail).\nin(A, A) :- nonvar(A), A \\= (_ , _), !.\nin(A, (A, _)) :- !.\nin(A, (_ , Cs)) :- in(A, Cs).\ncheck_admissibility(preconditions, H, LH) :-\n    \\+ defeasible_admissible(LH),\n    throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(effects, H, LH) :-\n    \\+ admissible(LH),\n    throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(_, _, _).\ndefeasible_admissible([unless, Term]) :- admissible(Term).\ndefeasible_admissible(Term) :- admissible(Term).\nadmissible([neg, bp, Term]) :- admissible_terms_complete(Term).\nadmissible([bp, Term]) :- admissible_terms_complete(Term).\nadmissible([neg, Term]) :- admissible_term(Term).\nadmissible([obl, [Term]]) :- admissible_term(Term).\nadmissible([obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([perm, [Term]]) :- admissible_term(Term).\nadmissible([perm, [neg, Term]]) :- admissible_term(Term).\nadmissible([Term]) :- admissible_term(Term).\nadmissible_term(Term) :-\n    atomic(Term),\n    Term \\== neg,\n    Term \\== obl,\n    Term \\== perm,\n    Term \\== unless,\n    Term \\== bp.\nadmissible_term(Term) :- var(Term).\nadmissible_term(Term) :-\n    compound(Term),\n    \\+ functor(Term, 'o', _),\n    \\+ functor(Term, 'p', _),\n    \\+ functor(Term, '-', _),\n    \\+ functor(Term, '~', _),\n    \\+ functor(Term, 'bp', _),\n    Term =.. [_|Args],\n    admissible_terms(Args).\nadmissible_terms([]).\nadmissible_terms([H|T]) :-\n    admissible_term(H),\n    admissible_terms(T).\nadmissible_terms_complete([]).\nadmissible_terms_complete([H|T]) :-\n    admissible(H),\n    admissible_terms_complete(T).\nrule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\npremise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\ncheck_strict(Id) :- context_check(strict(Id)).\nprolog([prolog(Term)], Term).\ncontrary([~(Term)], Term).\nundercut(undercut(Rule), Rule).\nsuperiority(sup(Id1, Id2), Id1, Id2).\n/*\n *   Convert the given tuple to list\n */\ntuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\ntuple_to_list((A,B),L) :-\n    tuple_to_list(A, La),\n    tuple_to_list(B, Lb),\n    utils::append_fast(La, Lb,L).\nff([[]], []) :- !.\nff([[X]], [X]) :- !.\nff(X, X).\nclassic_rule(X, [applicable(X)|Y], Z) :- metaRules, !, rule(X, Y, Z).\nclassic_rule(X, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).\nclassic_conflict([A], [B], C) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B, C)]), _)).\nclassic_conflict([A], [B]) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B)]), _)).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    member(conflict(A, B, C), [\n        conflict([Atom], [-Atom], (Atom \\= -_)),\n        conflict([-Atom], [Atom], true),\n        conflict([o(Atom)], [o(-Atom)], (Atom \\= -_)),                   % O(x) <-> O(-x)\n        conflict([o(-Atom)], [o(Atom)], true),\n        conflict([p(Atom)], [o(-Atom)], (Atom \\= -_)),                   % P(x) <-> O(-x)\n        conflict([o(-Atom)], [p(Atom)], true),\n        conflict([o(Atom)], [p(-Atom)], (Atom \\= -_)),                   % O(x) <-> P(-x)\n        conflict([p(-Atom)], [o(Atom)], true),\n        conflict([o(Atom)], [-p(Atom)], true),                           % O(x) <-> O(-x) (-P(x))\n        conflict([-p(Atom)], [o(Atom)], true),\n        conflict([sup(X, Y)], [sup(Y, X)], true)\n    ]).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    conflict(A, B, C).\nclassic_conflict(A, B) :-\n    \\+ metaConflicts,\n    conflict(A, B).";
   }
   var RuleTranslator_instance;
   function RuleTranslator_getInstance() {
     return RuleTranslator_instance;
   }
   function StatementLabelling() {
-    this.v3m_1 = 'statementLabelling :-\n    findall(_, (\n        context_check(in([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        context_assert(statIn(Conc))\n    ), _),\n    findall(_, (\n        context_check(out([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        context_assert(statOut(Conc))\n    ), _),\n    findall(_, (\n        context_check(und([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        \\+ context_check(statUnd(Conc)),\n        context_assert(statUnd(Conc))\n    ), _).';
+    this.u3m_1 = 'statementLabelling :-\n    findall(_, (\n        context_check(in([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        context_assert(statIn(Conc))\n    ), _),\n    findall(_, (\n        context_check(out([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        context_assert(statOut(Conc))\n    ), _),\n    findall(_, (\n        context_check(und([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        \\+ context_check(statUnd(Conc)),\n        context_assert(statUnd(Conc))\n    ), _).';
   }
   var StatementLabelling_instance;
   function StatementLabelling_getInstance() {
     return StatementLabelling_instance;
   }
   function SuperiorityRelation() {
-    this.d3n_1 = 'superiorArgument(A, B) :- superiorArgumentSupportBuffered(A, B, _).\nsuperiorArgument(A, B, SupSet) :- superiorArgumentSupportBuffered(A, B, SupSet).\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, false)),\n    fail, !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ context_check(superior(A, B, _, _)),\n    superiorArgumentSupport(A, B, SupSet),\n    context_assert(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ cache_check(superior(A, B, _, _)),\n    context_assert(superior(A, B, [], false)),\n    fail, !.\nsuperiorArgumentSupport([_, _, _, _, [LastDefRulesA, DefRulesA, DefPremisesA]], [_, _, _, _, [LastDefRulesB, DefRulesB, DefPremisesB]], SupSet) :-\n\tsuperiorArgumentSupport(LastDefRulesA, DefRulesA, DefPremisesA, LastDefRulesB, DefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(LastDefRulesA, _, DefPremisesA, LastDefRulesB, _, DefPremisesB, SupSet) :-\n    orderingPrinciple(last),\n\tsuperior(LastDefRulesA, DefPremisesA, LastDefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(_, DefRulesA, DefPremisesA, _, DefRulesB, DefPremisesB, SupSet) :-\n    orderingPrinciple(weakest),\n\tsuperior(DefRulesA, DefPremisesA, DefRulesB, DefPremisesB, SupSet).\nsuperior([], PremisesA, [], PremisesB, SupSet) :-\n\tweaker(PremisesB, PremisesA, SupSet).\nsuperior(DefRulesA, _, DefRulesB, _, SupSet) :-\n\torderingPrinciple(last),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, [], DefRulesB, [], SupSet) :-\n\torderingPrinciple(weakest),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, PremisesA, DefRulesB, PremisesB, SupSet) :-\n\torderingPrinciple(weakest),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\t(PremisesA \\== []; PremisesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSetA),\n\tweaker(PremisesB, PremisesA, SupSetB),\n\tutils::appendLists([SupSetA, SupSetB], SupSet).\nweaker(RulesA, [], []) :-\n\tRulesA \\== [].\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(elitist),\n\tmember(Rule, RulesA),\n\tallStronger(Rule, RulesB, SupSet), !.\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(democrat),\n\tweakerDemo(RulesA, RulesB, SupSet).\nweaker(RulesA, RulesB, [sup(X, W)]) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(normal),\n\tmember(W, RulesA),\n\tmember(X, RulesB),\n\tcontext_check(sup(X, W)), !.\nweakerDemo([], _, []).\nweakerDemo([H|T], Rules, [Sup|SupSet]) :-\n\tsingleStronger(H, Rules, Sup),\n\tweakerDemo(T, Rules, SupSet).\nsingleStronger(Target, Rules, sup(Rule, Target)) :-\n\tmember(Rule, Rules),\n\tcontext_check(sup(Rule, Target)), !.\nallStronger(_, [], []).\nallStronger(Target, [Rule|Rules], [sup(Rule, Target)|SupSet]) :-\n\tcontext_check(sup(Rule, Target)),\n\tallStronger(Target, Rules, SupSet).';
+    this.c3n_1 = 'superiorArgument(A, B) :- superiorArgumentSupportBuffered(A, B, _).\nsuperiorArgument(A, B, SupSet) :- superiorArgumentSupportBuffered(A, B, SupSet).\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, false)),\n    fail, !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ context_check(superior(A, B, _, _)),\n    superiorArgumentSupport(A, B, SupSet),\n    context_assert(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ cache_check(superior(A, B, _, _)),\n    context_assert(superior(A, B, [], false)),\n    fail, !.\nsuperiorArgumentSupport([_, _, _, _, [LastDefRulesA, DefRulesA, DefPremisesA]], [_, _, _, _, [LastDefRulesB, DefRulesB, DefPremisesB]], SupSet) :-\n\tsuperiorArgumentSupport(LastDefRulesA, DefRulesA, DefPremisesA, LastDefRulesB, DefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(LastDefRulesA, _, DefPremisesA, LastDefRulesB, _, DefPremisesB, SupSet) :-\n    orderingPrinciple(last),\n\tsuperior(LastDefRulesA, DefPremisesA, LastDefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(_, DefRulesA, DefPremisesA, _, DefRulesB, DefPremisesB, SupSet) :-\n    orderingPrinciple(weakest),\n\tsuperior(DefRulesA, DefPremisesA, DefRulesB, DefPremisesB, SupSet).\nsuperior([], PremisesA, [], PremisesB, SupSet) :-\n\tweaker(PremisesB, PremisesA, SupSet).\nsuperior(DefRulesA, _, DefRulesB, _, SupSet) :-\n\torderingPrinciple(last),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, [], DefRulesB, [], SupSet) :-\n\torderingPrinciple(weakest),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, PremisesA, DefRulesB, PremisesB, SupSet) :-\n\torderingPrinciple(weakest),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\t(PremisesA \\== []; PremisesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSetA),\n\tweaker(PremisesB, PremisesA, SupSetB),\n\tutils::appendLists([SupSetA, SupSetB], SupSet).\nweaker(RulesA, [], []) :-\n\tRulesA \\== [].\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(elitist),\n\tmember(Rule, RulesA),\n\tallStronger(Rule, RulesB, SupSet), !.\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(democrat),\n\tweakerDemo(RulesA, RulesB, SupSet).\nweaker(RulesA, RulesB, [sup(X, W)]) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(normal),\n\tmember(W, RulesA),\n\tmember(X, RulesB),\n\tcontext_check(sup(X, W)), !.\nweakerDemo([], _, []).\nweakerDemo([H|T], Rules, [Sup|SupSet]) :-\n\tsingleStronger(H, Rules, Sup),\n\tweakerDemo(T, Rules, SupSet).\nsingleStronger(Target, Rules, sup(Rule, Target)) :-\n\tmember(Rule, Rules),\n\tcontext_check(sup(Rule, Target)), !.\nallStronger(_, [], []).\nallStronger(Target, [Rule|Rules], [sup(Rule, Target)|SupSet]) :-\n\tcontext_check(sup(Rule, Target)),\n\tallStronger(Target, Rules, SupSet).';
   }
   var SuperiorityRelation_instance;
   function SuperiorityRelation_getInstance() {
     return SuperiorityRelation_instance;
   }
   function Utils() {
-    this.e3n_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nsortDistinct(List, Sorted) :-\n    deduplicate(List, Deduplicated),\n    sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n    List \\== [],\n    setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n    H @>= X,\n    pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n    X @> H,\n    pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n        member(Head, L2), !,\n        subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n        subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n    appendLists(T, AT),\n    append_fast(H, AT, R).\nsearch(F, L, S) :-\n   between(1, L, N),\n   functor(S, F, N),\n   call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n        findall(X, context_check(argument(X)), TempArgs),\n        findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n        findall((A, B), context_check(support(A, B)), TempSupports),\n        utils::sort(TempArgs, Args),\n        utils::sort(TempAttacks, Attacks),\n        utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(in(X)), TempArgsIn),\n        findall(X, context_check(out(X)), TempArgsOut),\n        findall(X, context_check(und(X)), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n        findall(X, context_check(statIn(X)), TempIn),\n        findall(X, context_check(statOut(X)), TempOut),\n        findall(X, context_check(statUnd(X)), TempUnd),\n        utils::sort(TempIn, In),\n        utils::sort(TempOut, Out),\n        utils::sort(TempUnd, Und).';
+    this.d3n_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nsortDistinct(List, Sorted) :-\n    deduplicate(List, Deduplicated),\n    sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n    List \\== [],\n    setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n    H @>= X,\n    pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n    X @> H,\n    pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n        member(Head, L2), !,\n        subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n        subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n    appendLists(T, AT),\n    append_fast(H, AT, R).\nsearch(F, L, S) :-\n   between(1, L, N),\n   functor(S, F, N),\n   call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n        findall(X, context_check(argument(X)), TempArgs),\n        findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n        findall((A, B), context_check(support(A, B)), TempSupports),\n        utils::sort(TempArgs, Args),\n        utils::sort(TempAttacks, Attacks),\n        utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(in(X)), TempArgsIn),\n        findall(X, context_check(out(X)), TempArgsOut),\n        findall(X, context_check(und(X)), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n        findall(X, context_check(statIn(X)), TempIn),\n        findall(X, context_check(statOut(X)), TempOut),\n        findall(X, context_check(statUnd(X)), TempUnd),\n        utils::sort(TempIn, In),\n        utils::sort(TempOut, Out),\n        utils::sort(TempUnd, Und).';
   }
   var Utils_instance;
   function Utils_getInstance() {
@@ -4605,8 +4585,8 @@
     StructuredMode_instance = this;
     StructuredModeBase.call(this);
   }
-  protoOf(StructuredMode).c3a = function () {
-    return QueryMode_instance_0.c3n_1;
+  protoOf(StructuredMode).b3a = function () {
+    return QueryMode_instance_0.b3n_1;
   };
   var StructuredMode_instance;
   function StructuredMode_getInstance() {
@@ -4618,8 +4598,8 @@
     AttackRelation_instance_0 = this;
     AttackRelationBase.call(this);
   }
-  protoOf(AttackRelation_0).c3a = function () {
-    return AttackRelation_instance.a3n_1;
+  protoOf(AttackRelation_0).b3a = function () {
+    return AttackRelation_instance.z3m_1;
   };
   var AttackRelation_instance_0;
   function AttackRelation_getInstance_0() {
@@ -4631,8 +4611,8 @@
     Debug_instance_0 = this;
     DebugBase.call(this);
   }
-  protoOf(Debug_0).c3a = function () {
-    return Debug_instance.b3n_1;
+  protoOf(Debug_0).b3a = function () {
+    return Debug_instance.a3n_1;
   };
   var Debug_instance_0;
   function Debug_getInstance_0() {
@@ -4644,8 +4624,8 @@
     SuperiorityRelation_instance_0 = this;
     SuperiorityRelationBase.call(this);
   }
-  protoOf(SuperiorityRelation_0).c3a = function () {
-    return SuperiorityRelation_instance.d3n_1;
+  protoOf(SuperiorityRelation_0).b3a = function () {
+    return SuperiorityRelation_instance.c3n_1;
   };
   var SuperiorityRelation_instance_0;
   function SuperiorityRelation_getInstance_0() {
@@ -4657,8 +4637,8 @@
     Utils_instance_0 = this;
     UtilsBase.call(this);
   }
-  protoOf(Utils_0).c3a = function () {
-    return Utils_instance.e3n_1;
+  protoOf(Utils_0).b3a = function () {
+    return Utils_instance.d3n_1;
   };
   var Utils_instance_0;
   function Utils_getInstance_0() {
@@ -4750,7 +4730,8 @@
   _.$_$.h = ArgLibrary;
   _.$_$.i = Loadable;
   _.$_$.j = mineGraph;
-  _.$_$.k = Graph;
+  _.$_$.k = mineActiveGraph;
+  _.$_$.l = Graph;
   //endregion
   return _;
 }));