@tuprolog/arg2p-core 0.6.3 → 0.6.6

package/kotlin/arg2p-core.js

@@ -28,6 +28,7 @@
   }
 }(this, function (_, Kotlin, $module$_2p_solve, $module$_2p_dsl_theory, $module$_2p_dsl_core, $module$_2p_unify, $module$_2p_core, $module$_2p_theory, $module$_2p_parser_theory, $module$_2p_solve_classic, $module$_2p_parser_core) {
   'use strict';
+  var $$importsForInline$$ = _.$$importsForInline$$ || (_.$$importsForInline$$ = {});
   var Libraries = $module$_2p_solve.it.unibo.tuprolog.solve.library.Libraries;
   var listOf = Kotlin.kotlin.collections.listOf_i5x0yv$;
   var plus = Kotlin.kotlin.collections.plus_mydzjv$;
@@ -61,9 +62,11 @@
   var mapCapacity = Kotlin.kotlin.collections.mapCapacity_za3lpa$;
   var coerceAtLeast = Kotlin.kotlin.ranges.coerceAtLeast_dqglrj$;
   var LinkedHashMap_init = Kotlin.kotlin.collections.LinkedHashMap_init_bwtc7$;
+  var classicWithDefaultBuiltins = $module$_2p_solve_classic.it.unibo.tuprolog.solve.classic.classicMutableSolverWithDefaultBuiltins;
   var Substitution = $module$_2p_core.it.unibo.tuprolog.core.Substitution;
   var Numeric = $module$_2p_core.it.unibo.tuprolog.core.Numeric;
   var ensureNotNull = Kotlin.ensureNotNull;
+  var first = Kotlin.kotlin.sequences.first_veqyi0$;
   var to = Kotlin.kotlin.to_ujzrz7$;
   var mutableMapOf = Kotlin.kotlin.collections.mutableMapOf_qfcya0$;
   var Atom = $module$_2p_core.it.unibo.tuprolog.core.Atom;
@@ -74,9 +77,10 @@
   var equals = Kotlin.equals;
   var DomainError = $module$_2p_solve.it.unibo.tuprolog.solve.exception.error.DomainError;
   var DomainError$Expected = $module$_2p_solve.it.unibo.tuprolog.solve.exception.error.DomainError.Expected;
+  var SolveOptions = $module$_2p_solve.it.unibo.tuprolog.solve.SolveOptions;
+  var Long$Companion$MAX_VALUE = Kotlin.Long.MAX_VALUE;
   var Unit = Kotlin.kotlin.Unit;
   var filter = Kotlin.kotlin.sequences.filter_euau3h$;
-  var first = Kotlin.kotlin.sequences.first_veqyi0$;
   var prolog = $module$_2p_dsl_core.it.unibo.tuprolog.dsl.prolog;
   var Specifier = $module$_2p_core.it.unibo.tuprolog.core.operators.Specifier;
   var Operator = $module$_2p_core.it.unibo.tuprolog.core.operators.Operator;
@@ -109,7 +113,10 @@
   var toTerm = $module$_2p_core.it.unibo.tuprolog.core.listToTerm;
   var UnaryPredicate$WithoutSideEffects = $module$_2p_solve.it.unibo.tuprolog.solve.primitive.UnaryPredicate.WithoutSideEffects;
   var BinaryRelation$WithoutSideEffects = $module$_2p_solve.it.unibo.tuprolog.solve.primitive.BinaryRelation.WithoutSideEffects;
+  var IllegalArgumentException_init = Kotlin.kotlin.IllegalArgumentException_init;
   var copyToArray = Kotlin.kotlin.collections.copyToArray;
+  var hashCode = Kotlin.hashCode;
+  var Collection = Kotlin.kotlin.collections.Collection;
   var AliasedLibrary = $module$_2p_solve.it.unibo.tuprolog.solve.library.AliasedLibrary;
   var compareBy = Kotlin.kotlin.comparisons.compareBy_bvgy4j$;
   var sortedWith = Kotlin.kotlin.sequences.sortedWith_vjgqpk$;
@@ -152,6 +159,8 @@
   CompleteLabellerBase.prototype.constructor = CompleteLabellerBase;
   GroundedLabellerBase.prototype = Object.create(LazyRawPrologContent.prototype);
   GroundedLabellerBase.prototype.constructor = GroundedLabellerBase;
+  GroundedLabellerOptimizedBase.prototype = Object.create(LazyRawPrologContent.prototype);
+  GroundedLabellerOptimizedBase.prototype.constructor = GroundedLabellerOptimizedBase;
   Labelling.prototype = Object.create(RuleWrapper.prototype);
   Labelling.prototype.constructor = Labelling;
   StatementLabellerBase.prototype = Object.create(LazyRawPrologContent.prototype);
@@ -170,6 +179,8 @@
   Bps.prototype.constructor = Bps;
   ExtractStrictIds.prototype = Object.create(BinaryRelation$WithoutSideEffects.prototype);
   ExtractStrictIds.prototype.constructor = ExtractStrictIds;
+  RuleToClause.prototype = Object.create(BinaryRelation$WithoutSideEffects.prototype);
+  RuleToClause.prototype.constructor = RuleToClause;
   StructuredModeBase.prototype = Object.create(LazyRawPrologContent.prototype);
   StructuredModeBase.prototype.constructor = StructuredModeBase;
   DebugBase.prototype = Object.create(LazyRawPrologContent.prototype);
@@ -178,6 +189,8 @@
   SuperiorityRelationBase.prototype.constructor = SuperiorityRelationBase;
   UtilsBase.prototype = Object.create(LazyRawPrologContent.prototype);
   UtilsBase.prototype.constructor = UtilsBase;
+  ArgumentHash.prototype = Object.create(BinaryRelation$WithoutSideEffects.prototype);
+  ArgumentHash.prototype.constructor = ArgumentHash;
   EngineInterface.prototype = Object.create(EngineInterfaceBase.prototype);
   EngineInterface.prototype.constructor = EngineInterface;
   AbstractMode.prototype = Object.create(AbstractModeBase.prototype);
@@ -204,6 +217,8 @@
   CompleteLabeller.prototype.constructor = CompleteLabeller;
   GroundedLabeller.prototype = Object.create(GroundedLabellerBase.prototype);
   GroundedLabeller.prototype.constructor = GroundedLabeller;
+  GroundedLabellerOptimized.prototype = Object.create(GroundedLabellerOptimizedBase.prototype);
+  GroundedLabellerOptimized.prototype.constructor = GroundedLabellerOptimized;
   StatementLabeller.prototype = Object.create(StatementLabellerBase.prototype);
   StatementLabeller.prototype.constructor = StatementLabeller;
   RuleParser.prototype = Object.create(RuleParserBase.prototype);
@@ -288,7 +303,7 @@
       staticLibs = emptyList();
     if (dynamicLibs === void 0)
       dynamicLibs = emptyList();
-    return this.of_gdqvf0$(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_getInstance(), ModuleCalls_getInstance(), ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance()]), dynamicLibs));
+    return this.of_gdqvf0$(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_getInstance(), ModuleCalls_getInstance(), ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance(), GroundedLabellerOptimized_getInstance()]), dynamicLibs));
   };
   Arg2pSolver$Companion.$metadata$ = {
     kind: Kind_OBJECT,
@@ -914,36 +929,18 @@
   PrologWithArgumentationImpl.prototype.write1 = function (term) {
     return this.$delegate_38xz9p$_0.write1(term);
   };
-  PrologWithArgumentationImpl.prototype.neq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.neq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.nid2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.nid2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.power = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.power($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.eq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.eq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.arithNeq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.arithNeq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.id2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.id2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.arithEq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.arithEq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.pow = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.pow($receiver, right);
-  };
   PrologWithArgumentationImpl.prototype.anyAnd = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyAnd($receiver, other);
   };
   PrologWithArgumentationImpl.prototype.append = function ($receiver, item, items) {
     return this.$delegate_38xz9p$_0.append($receiver, item, items);
   };
+  PrologWithArgumentationImpl.prototype.arithEq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.arithEq2($receiver, right);
+  };
+  PrologWithArgumentationImpl.prototype.arithNeq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.arithNeq2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.concat = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.concat($receiver, other);
   };
@@ -959,6 +956,9 @@
   PrologWithArgumentationImpl.prototype.anyDiv = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyDiv($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.eq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.eq2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyEqualsTo = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyEqualsTo($receiver, other);
   };
@@ -971,6 +971,9 @@
   PrologWithArgumentationImpl.prototype.anyGreaterThanOrEqualsTo = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyGreaterThanOrEqualsTo($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.id2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.id2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyIf = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyIf($receiver, other);
   };
@@ -1001,6 +1004,12 @@
   PrologWithArgumentationImpl.prototype.anyMinus = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyMinus($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.neq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.neq2($receiver, right);
+  };
+  PrologWithArgumentationImpl.prototype.nid2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.nid2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyNonGreaterThan = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyNonGreaterThan($receiver, other);
   };
@@ -1334,7 +1343,7 @@
   function Context() {
     this.nextSolver_0 = 1;
     this.selectedSolver_0 = 0;
-    var $receiver = classic(MutableSolver.Companion, void 0, void 0, Theory.Companion.empty(), MutableTheory.Companion.empty());
+    var $receiver = classicWithDefaultBuiltins(MutableSolver.Companion, void 0, void 0, Theory.Companion.empty(), MutableTheory.Companion.empty());
     $receiver.setFlag(flags.Unknown.name, flags.Unknown.FAIL);
     this.dynamicSolver_0 = mutableMapOf([to(0, $receiver)]);
     this.alias_476cz2$_0 = 'prolog.argumentation.context';
@@ -1354,7 +1363,7 @@
     this.$outer.nextSolver_0 = 1;
     this.$outer.dynamicSolver_0.clear();
     var tmp$ = this.$outer.dynamicSolver_0;
-    var $receiver = classic(MutableSolver.Companion, void 0, void 0, Theory.Companion.empty(), MutableTheory.Companion.empty());
+    var $receiver = classicWithDefaultBuiltins(MutableSolver.Companion, void 0, void 0, Theory.Companion.empty(), MutableTheory.Companion.empty());
     $receiver.setFlag(flags.Unknown.name, flags.Unknown.FAIL);
     tmp$.put_xwzc9p$(0, $receiver);
     return sequenceOf([request.replyWithCondition(true, void 0, [])]);
@@ -1420,7 +1429,7 @@
     var result = request.arguments.get_za3lpa$(1);
     var tmp$_1 = this.$outer.dynamicSolver_0;
     var tmp$_2 = this.$outer.nextSolver_0;
-    var $receiver = classic(MutableSolver.Companion, void 0, void 0, Theory.Companion.empty(), MutableTheory.Companion.ofIterable(ensureNotNull(this.$outer.dynamicSolver_0.get_11rb$(target)).dynamicKb));
+    var $receiver = classicWithDefaultBuiltins(MutableSolver.Companion, void 0, void 0, Theory.Companion.empty(), MutableTheory.Companion.ofIterable(ensureNotNull(this.$outer.dynamicSolver_0.get_11rb$(target)).dynamicKb));
     $receiver.setFlag(flags.Unknown.name, flags.Unknown.FAIL);
     tmp$_1.put_xwzc9p$(tmp$_2, $receiver);
     tmp$_0 = this.$outer;
@@ -1446,9 +1455,14 @@
       return this.signature_t5avxd$_0;
     }
   });
+  function Context$DynamicCacheAssert$solve$lambda(this$Context, closure$term) {
+    return function ($receiver) {
+      return ensureNotNull(this$Context.dynamicSolver_0.get_11rb$(this$Context.selectedSolver_0)).solve($receiver.stringInvoke('asserta', closure$term, []));
+    };
+  }
   Context$DynamicCacheAssert.prototype.solve = function (request) {
     var term = request.arguments.get_za3lpa$(0);
-    ensureNotNull(this.$outer.dynamicSolver_0.get_11rb$(this.$outer.selectedSolver_0)).assertAFact(term.castToStruct());
+    first(arg2pScope(Context$DynamicCacheAssert$solve$lambda(this.$outer, term)));
     return sequenceOf([request.replyWithCondition(true, void 0, [])]);
   };
   Context$DynamicCacheAssert.$metadata$ = {
@@ -1466,9 +1480,14 @@
       return this.signature_5o25xi$_0;
     }
   });
+  function Context$DynamicCacheRetract$solve$lambda(this$Context, closure$term) {
+    return function ($receiver) {
+      return ensureNotNull(this$Context.dynamicSolver_0.get_11rb$(this$Context.selectedSolver_0)).solve($receiver.stringInvoke('retractall', closure$term, []));
+    };
+  }
   Context$DynamicCacheRetract.prototype.solve = function (request) {
     var term = request.arguments.get_za3lpa$(0);
-    ensureNotNull(this.$outer.dynamicSolver_0.get_11rb$(this.$outer.selectedSolver_0)).retractAllBeHead(term.castToStruct());
+    first(arg2pScope(Context$DynamicCacheRetract$solve$lambda(this.$outer, term)));
     return sequenceOf([request.replyWithCondition(true, void 0, [])]);
   };
   Context$DynamicCacheRetract.$metadata$ = {
@@ -1702,7 +1721,7 @@
         switch (this.state_0) {
           case 0:
             this.state_0 = 2;
-            this.result_0 = this.local$$receiver.yieldAll_swo9gw$(map(this.local$closure$solver.solve(this.local$closure$goal), DynamicLoader$AbstractWithLib$solve$lambda$lambda(this.local$closure$request)), this);
+            this.result_0 = this.local$$receiver.yieldAll_swo9gw$(map(this.local$closure$solver.solveWithOptions(this.local$closure$goal, SolveOptions.Companion.someEagerlyWithTimeout(1000, Long$Companion$MAX_VALUE)), DynamicLoader$AbstractWithLib$solve$lambda$lambda(this.local$closure$request)), this);
             if (this.result_0 === COROUTINE_SUSPENDED)
               return COROUTINE_SUSPENDED;
             continue;
@@ -2424,7 +2443,7 @@
     return 'grounded';
   };
   ArgumentLabellingMode.prototype.values = function () {
-    return listOf(['grounded', 'complete', 'bp_grounded', 'bp_grounded_partial', 'bp_grounded_complete']);
+    return listOf(['grounded', 'grounded_hash', 'complete', 'bp_grounded', 'bp_grounded_partial', 'bp_grounded_complete']);
   };
   ArgumentLabellingMode.$metadata$ = {
     kind: Kind_OBJECT,
@@ -2954,6 +2973,43 @@
     simpleName: 'GroundedLabellerBase',
     interfaces: [Loadable, LazyRawPrologContent, ArgLibrary]
   };
+  function GroundedLabellerOptimizedBase() {
+    LazyRawPrologContent.call(this);
+    this.alias_9fhn2g$_0 = 'prolog.argumentation.graph.labelling.grounded.optimized';
+    this.theoryOperators_8xcsny$_0 = DynamicLoader$Companion_getInstance().operators().plusOperatorSet(OperatorSet.Companion.DEFAULT);
+  }
+  Object.defineProperty(GroundedLabellerOptimizedBase.prototype, 'alias', {
+    configurable: true,
+    get: function () {
+      return this.alias_9fhn2g$_0;
+    }
+  });
+  Object.defineProperty(GroundedLabellerOptimizedBase.prototype, 'baseContent', {
+    configurable: true,
+    get: function () {
+      return Library.Companion.aliased(this.alias, void 0, this.prologTheory);
+    }
+  });
+  Object.defineProperty(GroundedLabellerOptimizedBase.prototype, 'baseFlags', {
+    configurable: true,
+    get: function () {
+      return emptyList();
+    }
+  });
+  GroundedLabellerOptimizedBase.prototype.identifier = function () {
+    return 'grounded_hash';
+  };
+  Object.defineProperty(GroundedLabellerOptimizedBase.prototype, 'theoryOperators', {
+    configurable: true,
+    get: function () {
+      return this.theoryOperators_8xcsny$_0;
+    }
+  });
+  GroundedLabellerOptimizedBase.$metadata$ = {
+    kind: Kind_CLASS,
+    simpleName: 'GroundedLabellerOptimizedBase',
+    interfaces: [Loadable, LazyRawPrologContent, ArgLibrary]
+  };
   function PassThroughStatementLabeller() {
     PassThroughStatementLabeller_instance = this;
     this.alias_as0zmd$_0 = 'prolog.argumentation.graph.labelling.statement.pt';
@@ -3082,7 +3138,9 @@
         return $receiver.descriptionPair;
       }.bind(null, DefeasibleRules_getInstance())).get(), getPropertyCallableRef('descriptionPair', 0, function ($receiver) {
         return $receiver.descriptionPair;
-      }.bind(null, ExtractStrictIds_getInstance())).get()]), this.prologTheory, RuleParserBase$Companion_getInstance().operators());
+      }.bind(null, ExtractStrictIds_getInstance())).get(), getPropertyCallableRef('descriptionPair', 0, function ($receiver) {
+        return $receiver.descriptionPair;
+      }.bind(null, RuleToClause_getInstance())).get()]), this.prologTheory, RuleParserBase$Companion_getInstance().operators());
     }
   });
   Object.defineProperty(RuleParserBase.prototype, 'baseFlags', {
@@ -3401,7 +3459,7 @@
     tmp$_1 = destination.iterator();
     while (tmp$_1.hasNext()) {
       var item = tmp$_1.next();
-      destination_0.add_11rb$(prologScope.listOfAny(['bps', ensureNotNull(item.head)]));
+      destination_0.add_11rb$(Struct.Companion.of('abstractBp', [prologScope.listOfIterable(ensureNotNull(item.head).argsList)]));
     }
     return toTerm(destination_0);
   }
@@ -3448,6 +3506,50 @@
       new ExtractStrictIds();
     }return ExtractStrictIds_instance;
   }
+  function RuleToClause() {
+    RuleToClause_instance = this;
+    BinaryRelation$WithoutSideEffects.call(this, 'rule_to_clause');
+  }
+  RuleToClause.prototype.computeAllSubstitutions_2j1e5m$ = function ($receiver, first, second) {
+    var tmp$ = Substitution.Companion;
+    var tmp$_0 = ensureNotNull(second.asVar());
+    var tmp$_1 = List.Companion;
+    var $receiver_0 = ensureNotNull(first.asList()).toList();
+    var destination = ArrayList_init(collectionSizeOrDefault($receiver_0, 10));
+    var tmp$_2;
+    tmp$_2 = $receiver_0.iterator();
+    loop_label: while (tmp$_2.hasNext()) {
+      var item = tmp$_2.next();
+      var tmp$_3 = destination.add_11rb$;
+      var it = ensureNotNull(item.asList()).toList();
+      var block$result;
+      block$break: do {
+        switch (it.size) {
+          case 2:
+            block$result = Clause.Companion.of(Struct.Companion.of('rl', [it.get_za3lpa$(1)]), [item]);
+            break block$break;
+          case 3:
+            block$result = Clause.Companion.of(Struct.Companion.of('rl', [it.get_za3lpa$(2)]), [item]);
+            break block$break;
+          default:throw IllegalArgumentException_init();
+        }
+      }
+       while (false);
+      tmp$_3.call(destination, block$result);
+    }
+    return sequenceOf([tmp$.of(tmp$_0, tmp$_1.ofList(destination))]);
+  };
+  RuleToClause.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'RuleToClause',
+    interfaces: [BinaryRelation$WithoutSideEffects]
+  };
+  var RuleToClause_instance = null;
+  function RuleToClause_getInstance() {
+    if (RuleToClause_instance === null) {
+      new RuleToClause();
+    }return RuleToClause_instance;
+  }
   function StructuredModeBase() {
     LazyRawPrologContent.call(this);
     this.alias_k0m5up$_0 = 'prolog.argumentation.structured';
@@ -3669,7 +3771,10 @@
       tmp$_1 = Library.Companion;
       tmp$ = this.alias;
       tmp$_0 = this.prologTheory;
-      return tmp$_1.aliased(tmp$, mapOf_0([to(AppendOptimized_getInstance().signature, AppendOptimized_getInstance()), to(AssertAll_getInstance().signature, AssertAll_getInstance())]), tmp$_0);
+      var tmp$_2 = to(AppendOptimized_getInstance().signature, AppendOptimized_getInstance());
+      var tmp$_3 = to(AssertAll_getInstance().signature, AssertAll_getInstance());
+      var $this = ArgumentHash_getInstance();
+      return tmp$_1.aliased(tmp$, mapOf_0([tmp$_2, tmp$_3, to($this.signature, $this.wrappedImplementation), to(Contains_getInstance().signature, Contains_getInstance()), to(ContainsAny_getInstance().signature, ContainsAny_getInstance())]), tmp$_0);
     }
   });
   Object.defineProperty(UtilsBase.prototype, 'baseFlags', {
@@ -3779,7 +3884,7 @@
   }
   function AssertAll$solve$lambda(closure$list, closure$request) {
     return function ($receiver) {
-      var $receiver_0 = closure$list.toSequence();
+      var $receiver_0 = closure$list.toList();
       var tmp$;
       tmp$ = $receiver_0.iterator();
       while (tmp$.hasNext()) {
@@ -3858,6 +3963,224 @@
       new AssertAll();
     }return AssertAll_instance;
   }
+  function ArgumentHash() {
+    ArgumentHash_instance = this;
+    BinaryRelation$WithoutSideEffects.call(this, 'hash');
+  }
+  ArgumentHash.prototype.computeAllSubstitutions_2j1e5m$ = function ($receiver, first, second) {
+    return sequenceOf([Substitution.Companion.of(ensureNotNull(second.asVar()), Numeric.Companion.ofInteger(hashCode(first.toString())))]);
+  };
+  ArgumentHash.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'ArgumentHash',
+    interfaces: [BinaryRelation$WithoutSideEffects]
+  };
+  var ArgumentHash_instance = null;
+  function ArgumentHash_getInstance() {
+    if (ArgumentHash_instance === null) {
+      new ArgumentHash();
+    }return ArgumentHash_instance;
+  }
+  function Contains() {
+    Contains_instance = this;
+    this.signature = new Signature('contains', 2);
+  }
+  function Coroutine$Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$closure$list = closure$list_0;
+    this.local$closure$elem = closure$elem_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$Contains$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$Contains$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$Contains$solve$lambda.prototype.constructor = Coroutine$Contains$solve$lambda;
+  Coroutine$Contains$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            var tmp$ = this.local$closure$request;
+            var $receiver = this.local$closure$list.toList();
+            var any$result;
+            any$break: do {
+              var tmp$_0;
+              if (Kotlin.isType($receiver, Collection) && $receiver.isEmpty()) {
+                any$result = false;
+                break any$break;
+              }tmp$_0 = $receiver.iterator();
+              while (tmp$_0.hasNext()) {
+                var element = tmp$_0.next();
+                var closure$elem = this.local$closure$elem;
+                if (Unificator.Companion.default.match(element, closure$elem)) {
+                  any$result = true;
+                  break any$break;
+                }}
+              any$result = false;
+            }
+             while (false);
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(tmp$.replyWithCondition(any$result, void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  Contains.prototype.solve = function (request) {
+    var elem = request.arguments.get_za3lpa$(0);
+    var list = request.arguments.get_za3lpa$(1);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }return sequence(Contains$solve$lambda(request, list, elem));
+  };
+  Contains.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'Contains',
+    interfaces: [Primitive]
+  };
+  var Contains_instance = null;
+  function Contains_getInstance() {
+    if (Contains_instance === null) {
+      new Contains();
+    }return Contains_instance;
+  }
+  function ContainsAny() {
+    ContainsAny_instance = this;
+    this.signature = new Signature('contains_any', 2);
+  }
+  function Coroutine$ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$closure$list = closure$list_0;
+    this.local$closure$elemList = closure$elemList_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$ContainsAny$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$ContainsAny$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$ContainsAny$solve$lambda.prototype.constructor = Coroutine$ContainsAny$solve$lambda;
+  Coroutine$ContainsAny$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            var tmp$ = this.local$closure$request;
+            var $receiver = this.local$closure$list.toSequence();
+            var any$result;
+            any$break: do {
+              var tmp$_0;
+              tmp$_0 = $receiver.iterator();
+              loop_label: while (tmp$_0.hasNext()) {
+                var element = tmp$_0.next();
+                var $receiver_0 = this.local$closure$elemList.toSequence();
+                var any$result_0;
+                any$break_0: do {
+                  var tmp$_1;
+                  tmp$_1 = $receiver_0.iterator();
+                  while (tmp$_1.hasNext()) {
+                    var element_0 = tmp$_1.next();
+                    if (Unificator.Companion.default.match(element, element_0)) {
+                      any$result_0 = true;
+                      break any$break_0;
+                    }}
+                  any$result_0 = false;
+                }
+                 while (false);
+                if (any$result_0) {
+                  any$result = true;
+                  break any$break;
+                }}
+              any$result = false;
+            }
+             while (false);
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(tmp$.replyWithCondition(any$result, void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  ContainsAny.prototype.solve = function (request) {
+    var elemList = request.arguments.get_za3lpa$(0);
+    var list = request.arguments.get_za3lpa$(1);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }if (!Kotlin.isType(elemList, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }return sequence(ContainsAny$solve$lambda(request, list, elemList));
+  };
+  ContainsAny.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'ContainsAny',
+    interfaces: [Primitive]
+  };
+  var ContainsAny_instance = null;
+  function ContainsAny_getInstance() {
+    if (ContainsAny_instance === null) {
+      new ContainsAny();
+    }return ContainsAny_instance;
+  }
   function MetaInterpreterLib() {
     MetaInterpreterLib_instance = this;
     this.$delegate_3wovwi$_0 = Library.Companion.aliased('prolog.argumentation.meta', void 0, parse_2(Theory.Companion, trimIndent('\n        % with_facts_and_length/3\n        with_facts_and_length(X, Y, L) :-\n            solve(X, R),\n            recover_facts(R, Y),\n            length(Y, L).\n\n        % lenght/2\n\n        length([], 0).\n        length([_|T], X) :- length(T, Y), X is Y + 1.\n\n        % recover_facts/2\n\n        recover_facts([], []) :- !.\n        recover_facts([H|T], C) :-\n            is_list(H), !,\n            recover_facts(T, TC),\n            recover_facts(H, HC),\n            append(TC, HC, C).\n        recover_facts([H|T], C) :-\n            \\+ is_list(H),\n            recover_facts(T, TC),\n            evaluate(H, HC),\n            append(TC, HC, C).\n\n        evaluate(user_fact(X), [X]) :- !.\n        evaluate(_, []) :- !.\n\n        % solve/2\n\n        solve((A,B), Result) :- !,\n            solve(A, ARes),\n            solve(B, BRes),\n            append(ARes, BRes, Result).\n\n        solve((A;B), Result) :- !,\n            solve(A, Result);\n            solve(B, Result).\n\n        solve(member(A, B), [system_predicate]) :- !,\n            call(member(A, B)).\n\n        solve(\\+(A), [not(A)]) :- !,\n            call(\\+(A)).\n\n        solve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n            call((A)\\=(B)).\n\n        solve(A, [system_predicate]) :-\n            catch(clause(A, _), B, true),\n            \\+ var(B), !,\n            call(A).\n\n        solve(A, [A]) :-\n            \\+ clause(A, B), !,\n            call(A).\n\n        solve(A, [A|[Res]]) :-\n            clause(A, B),\n            solve(B, Res).\n\n        % is_list/1\n\n        is_list(X) :- var(X), !, fail.\n        is_list([]).\n        is_list([_|T]) :- is_list(T).\n        \n        % fetch_argument_facts/2\n        \n        fetch_argument_facts(Conclusion, Facts) :-\n            argument([R, TR, [Conclusion]]),\n            findall(user_fact(Fact), \n                support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n            Facts).\n        ')));
@@ -4127,7 +4450,7 @@
     }
   });
   Argument.prototype.termRepresentation = function () {
-    return parse_1(Struct.Companion, '[' + this.rules + ', ' + this.topRule + ', ' + this.conclusion + ', ' + this.groundings + ', [' + this.lastDefeasibleRules + ', ' + this.defeasibleRules + ', ' + this.defeasiblePremises + ']]');
+    return parse_1(Struct.Companion, '[' + this.rules + ', ' + this.topRule + ', [' + this.conclusion + '], ' + this.groundings + ', [' + this.lastDefeasibleRules + ', ' + this.defeasibleRules + ', ' + this.defeasiblePremises + ']]');
   };
   Argument.prototype.toString = function () {
     return 'argument(' + this.termRepresentation() + ')';
@@ -4163,7 +4486,7 @@
     return argument.get_za3lpa$(1).toString();
   }
   function Argument$Companion$of$argConclusion(argument) {
-    return argument.get_za3lpa$(2).toString();
+    return ensureNotNull(argument.get_za3lpa$(2).asList()).get(0).toString();
   }
   function Argument$Companion$of$argGroundings(closure$toStringList) {
     return function (argument) {
@@ -4424,7 +4747,7 @@
     }
   });
   Premise.prototype.toString = function () {
-    return 'premise([' + this.identifier + ', ' + this.conclusion + '])';
+    return 'rl(' + this.conclusion + ') :- ([' + this.identifier + ', ' + this.conclusion + '])';
   };
   Premise.$metadata$ = {
     kind: Kind_CLASS,
@@ -4472,7 +4795,7 @@
     }
   });
   Rule.prototype.toString = function () {
-    return 'rule([' + this.identifier + ', ' + this.premises + ', ' + this.conclusion + '])';
+    return 'rl(' + this.conclusion + ') :- [' + this.identifier + ', ' + this.premises + ', ' + this.conclusion + ']';
   };
   Rule.$metadata$ = {
     kind: Kind_CLASS,
@@ -4811,6 +5134,27 @@
       new GroundedLabeller();
     }return GroundedLabeller_instance;
   }
+  function GroundedLabellerOptimized() {
+    GroundedLabellerOptimized_instance = this;
+    GroundedLabellerOptimizedBase.call(this);
+  }
+  Object.defineProperty(GroundedLabellerOptimized.prototype, 'prologRawTheory', {
+    configurable: true,
+    get: function () {
+      return GroundedOptimized_getInstance().theoryCode;
+    }
+  });
+  GroundedLabellerOptimized.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'GroundedLabellerOptimized',
+    interfaces: [GroundedLabellerOptimizedBase]
+  };
+  var GroundedLabellerOptimized_instance = null;
+  function GroundedLabellerOptimized_getInstance() {
+    if (GroundedLabellerOptimized_instance === null) {
+      new GroundedLabellerOptimized();
+    }return GroundedLabellerOptimized_instance;
+  }
   function StatementLabeller() {
     StatementLabeller_instance = this;
     StatementLabellerBase.call(this);
@@ -4870,7 +5214,7 @@
   }
   function ArgumentationEngineInterface() {
     ArgumentationEngineInterface_instance = this;
-    this.theoryCode = trimIndent('\n    argTuProlog.\n    buildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n        context_reset,\n        parser:::convertAllRules(_),\n        abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\n    buildLabelSets(StatIn, StatOut, StatUnd) :-\n        buildLabelSets([StatIn, StatOut, StatUnd], _).\n    buildLabelSets :-\n        context_reset,\n        parser:::convertAllRules(ArgRules),\n        debug::printTheory(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]).\n    answerQuery(Goal, Yes, No, Und) :-\n        context_reset,\n        parser:::convertAllRules(_),\n        structured:::computeStatementAcceptance(Goal, Yes, No, Und).\n        ');
+    this.theoryCode = trimIndent('\n    argTuProlog.\n    buildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n        context_reset,\n        parser:::convertAllRules(_),\n        abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\n    buildLabelSets(StatIn, StatOut, StatUnd) :-\n        buildLabelSets([StatIn, StatOut, StatUnd], _).\n    buildLabelSets :-\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]).\n    answerQuery(Goal, Yes, No, Und) :-\n        context_reset,\n        parser:::convertAllRules(_),\n        structured:::computeStatementAcceptance(Goal, Yes, No, Und).\n    answerQuery(Goal, Res) :-\n        context_reset,\n        parser:::convertAllRules(_),\n        structured:::query(Goal, Res).\n    buildLabelSetsSilent :-\n        context_reset,\n        parser:::convertAllRules(ArgRules),\n        abstract::computeGlobalAcceptance.\n        ');
   }
   ArgumentationEngineInterface.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4885,7 +5229,7 @@
   }
   function ArgumentationGraph() {
     ArgumentationGraph_instance = this;
-    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tbuildArgumentsFromEmptyRules,\n    \tfindall([RuleID, RuleBody, RuleHead], (\n    \t    context_check(rule([RuleID, RuleBody, RuleHead])),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n    \tbuildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                context_check(premise([PremiseID, Premise])),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromEmptyRules :-\n        findall(\n            _,\n            (\n                emptyRule([RuleID, RulePrem, RuleHead]),\n                checkStrict(RuleID, DefRule),\n                ground(RuleHead),\n                context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, [], RuleHead]) :-\n        context_check(rule([RuleID, [], RuleHead])).\n    emptyRule([RuleID, [[unless, X]], RuleHead]) :-\n        context_check(rule([RuleID, [[unless, X]], RuleHead])).\n    emptyRule([RuleID, [[prolog(Check)]], RuleHead]) :-\n        context_check(rule([RuleID, [[prolog(Check)]], RuleHead])),\n        (callable(Check) -> call(Check); Check).\n    buildArgumentsFromRules(Rules, [], n).\n    buildArgumentsFromRules(Rules, [], y) :- buildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromRules(Rules, [H|T], _) :-\n        copy_term(H, HH),\n        buildArgumentsFromRule(HH),\n        buildArgumentsFromRules(Rules, T, y), !.\n    buildArgumentsFromRules(Rules, [_|T], X) :-\n        buildArgumentsFromRules(Rules, T, X).\n    buildArgumentsFromRule([RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleBody, [], [], SupportRules, ArgSupports),\n    \t\\+ member(RuleID, SupportRules),\n    \tground(RuleHead),\n    \tutils::sort([RuleID|SupportRules], SortedPremises),\n    \t\\+ context_check(argument([SortedPremises, RuleID, RuleHead, RuleBody, _])),\n    \tbuildArgumentInfo(ArgSupports, RuleID, Info),\n        NewArgument = [SortedPremises, RuleID, RuleHead, RuleBody, Info],\n    \tcontext_assert(argument(NewArgument)),\n    \tsupports(NewArgument, ArgSupports).\n    supports(Argument, Supports) :-\n        findall(_, (\n            member(S, Supports),\n            context_assert(support(S, Argument))\n        ), _).\n    checkStrict(Id, [Id]) :- \\+ context_check(strict(Id)).\n    checkStrict(Id, []) :- context_check(strict(Id)).\n    buildArgumentInfo(Supports, RuleId, [LastDefRules, DefRules, DefPrem]) :-\n        defeasibleRules(RuleId, Supports, DefRules),\n        ordinaryPremises(Supports, DefPrem),\n        lastDefeasibleRules(Supports, RuleId, LastDefRules).\n    ordinaryPremises(Supports, DefPrem) :-\n        findall(Def, member([_, _, _, _, [_, _, Def]], Supports), Prem),\n        utils::appendLists(Prem, TempPrem),\n        utils::sortDistinct(TempPrem, DefPrem).\n    defeasibleRules(RuleId, Supports, DefRules) :-\n    \tfindall(Def, member([_, _, _, _, [_, Def, _]], Supports), UnsortedRules),\n    \tcheckStrict(RuleId, DefRule),\n    \tutils::appendLists([DefRule|UnsortedRules], TempRules),\n    \tutils::sortDistinct(TempRules, DefRules).\n    lastDefeasibleRules(_, TopRule, [TopRule]) :-\n        TopRule \\== none, \\+ context_check(strict(TopRule)).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tcontext_check(strict(TopRule)),\n    \tfindall(Def, member([_, _, _, _, [Def, _, _]], Supports), Res),\n    \tutils::appendLists(Res, TempLastRules),\n    \tutils::sortDistinct(TempLastRules, LastRules).\n    ruleBodyIsSupported([], ResultPremises, ResultSupports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [unless, _] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [prolog(Check)] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([Statement|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n        context_check(argument([ArgumentID, RuleID, Statement, Body, Info])),\n    \tappend(ArgumentID, Premises, NewPremises),\n    \truleBodyIsSupported(Others, NewPremises, [[ArgumentID, RuleID, Statement, Body, Info]|Supports], ResultPremises, ResultSupports).\n    findPossibleAttackers([_, _, Head, _, _], [_, _, Conf, _, _]) :-\n        conflict(Head, Conf).\n    findPossibleAttackers([_, _, _, Prem, _], [_, _, Conf, _, _]) :-\n        member([unless, Conf], Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [_, _, [undercut(RuleID)], _, _]).\n    buildAttacks :-\n        findall(X, context_check(argument(X)), Args),\n    \tbuildDirectAttacks(Args),\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks([]).\n    buildDirectAttacks([H|T]) :-\n        findall(_, buildDirectAttack(H), _),\n        buildDirectAttacks(T).\n    buildDirectAttack(A) :-\n    \tcontext_check(argument(B)),\n    \tA \\== B,\n        attacks(T, B, A),\n    \t\\+ context_check(attack(T, B, A, A)),\n    \tcontext_assert(attack(T, B, A, A)).\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    conflict( [Atom], [neg, Atom]).\n    conflict( [neg, Atom], [Atom]).\n    conflict( [obl, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, Lit],  [neg, obl, Lit]).\n    conflict( [neg, obl, Lit],  [obl, Lit]).\n    conflict( [perm, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [perm, [Atom]]).\n    conflict( [perm, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, [Atom]],  [perm, [neg, Atom]]).\n    conflict([bp, Atom], [neg, bp, Atom]).\n    conflict([neg, bp, Atom], [bp, Atom]).\n    conflict([sup(X, Y)],  [sup(Y, X)]).\n        ');
+    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\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).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                parser::classic_rule(PremiseID, Premise),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(conc(Premise) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]), Id),\n                context_assert(arg(Id) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromEmptyRules :-\n        findall(\n            _,\n            (\n                emptyRule([RuleID, RulePrem, RuleHead]),\n                checkStrict(RuleID, DefRule),\n                ground(RuleHead),\n                context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(conc(RuleHead) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(newConc(a, RuleHead)),\n                utils::hash(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]), Id),\n                context_assert(arg(Id) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, Body, RuleHead]) :-\n        parser::classic_rule(RuleID, Body, RuleHead),\n        \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n        checkPrologClauses(Body).\n    checkPrologClauses([]) :- !.\n    checkPrologClauses([~(_)|T]) :- checkPrologClauses(T), !.\n    checkPrologClauses([prolog(Check)|T]) :-\n        (callable(Check) -> call(Check); Check),\n        checkPrologClauses(T).\n    clean(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).\n    invert(a, b).\n    invert(b, a).\n    buildArgumentsFromRules(_, _, Rules, [], n) :- !.\n    buildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\n    buildArgumentsFromRules(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), !.\n    buildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n        buildArgumentsFromRules(N, Tn, Rules, T, X).\n    buildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n        context_assert(newConc(Tn, RuleHead)).\n    checkStrict(Id, []) :- parser::check_strict(Id), !.\n    checkStrict(Id, [Id]).\n    defRules(Id, Def, Def) :- parser::check_strict(Id), !.\n    defRules(Id, Def, [Id|Def]).\n    lastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\n    lastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\n    argumentInfo(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).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n        ground(RuleHead),\n        \\+ context_check(clause(conc(RuleHead), argument([_, RuleID, RuleHead, RuleBody, _]))),\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_assert(conc(RuleHead) :- argument(Argument)),\n        context_assert(argument(Argument)),\n        utils::hash(argument(Argument), Id),\n        context_assert(arg(Id) :- argument(Argument)).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\n    ruleBodyIsSupported(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    \tcontext_assert(support([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument)).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head, Guard).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head).\n    findPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n        member(~(Conf), Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\n    buildAttacks :-\n    \tbuildDirectAttacks,\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks :-\n        findall(_, buildDirectAttack, _).\n    buildDirectAttack :-\n        context_check(argument(A)),\n        findPossibleAttackers(A, BB),\n    \tcontext_check(clause(conc(BB), argument(B))),\n    \tA \\== B,\n        attacks(T, B, A),\n    \t\\+ context_check(attack(T, B, A, A)),\n    \tcontext_assert(attack(T, B, A, A)),\n    \tutils::hash(argument(A), IdA),\n    \tutils::hash(argument(B), IdB),\n    \tcontext_assert(att(IdB, IdA) :- attack(T, B, A, A)),\n    \tfail.\n    buildDirectAttack.\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_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, B, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB).\n    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB, Guard),\n        (callable(Guard) -> call(Guard); Guard).\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tutils::contains(~(RuleHeadA), Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tutils::contains(~(RuleHeadA), Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    check(-Atom).\n    conflict([Atom], [-Atom]) :- \\+ check(Atom).\n    conflict([-Atom], [Atom]).\n    conflict([o(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [o(Atom)]).\n    conflict([p(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [p(Atom)]).\n    conflict([p(-Atom)], [o(Atom)]).\n    conflict([o(Atom)], [p(-Atom)]) :- \\+ check(Atom).\n    conflict([sup(X, Y)], [sup(Y, X)]).\n        ');
   }
   ArgumentationGraph.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4930,7 +5274,7 @@
   }
   function BpGrounded() {
     BpGrounded_instance = this;
-    this.theoryCode = trimIndent('\n    argumentLabelling :-\n        reifyBurdenOfProofs,\n        filterBpDefeats,\n        findall(X, context_check(argument(X)), Arguments),\n        bpLabelling(Arguments).\n    bpLabelling(Arguments) :-\n        member(A, Arguments),\n        grounded::allAttacksOUT(A), !,\n        context_assert(in(A)),\n        utils::subtract(Arguments, [A], NewArguments),\n        bpLabelling(NewArguments).\n    bpLabelling(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).\n    bpLabelling(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).\n    bpLabelling(Args) :-\n        notLabelled(Args),\n        findall(_, (member(A, Args), context_assert(und(A))), _).\n    notLabelled(Args) :-\n        \\+ (\n            member(A, Args),\n            (\n                context_check(in(A));\n                context_check(out(A));\n                context_check(und(A))\n            )\n        ).\n    isInBurdenOfProof(Conclusion) :-\n        context_check(reifiedBp(Literals)),\n        member(Conclusion, Literals), !.\n    isArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n        isInBurdenOfProof(Conclusion).\n    filterBpDefeats :-\n        findall(_, (\n            context_check(attack(T, A, B, C)),\n            filterBpDefeat(T, A, B, C)\n        ), _).\n    filterBpDefeat(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)).\n    mostGroundedBpUnd(Arguments, Arg) :-\n        member(Arg, Arguments),\n        isArgumentInBurdenOfProof(Arg),\n        \\+ (\n            member(A, Arguments), Arg \\= A,\n            isArgumentInBurdenOfProof(A),\n            argumentChain(A, Arg)\n        ).\n    argumentChain(A, A) :- !.\n    argumentChain(A, B) :-\n        A \\== B,\n        context_check(attack(_, A, C, _)),\n        argumentChain(C, B).\n    reifyBurdenOfProofs :-\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    */\n    fillTemplate([], []).\n    fillTemplate([H|T], [H|R]) :-\n        context_check(argument([_, _, Conclusion, _, _])),\n        fillTemplate(T, R).\n        ');
+    this.theoryCode = trimIndent('\n    argumentLabelling :-\n        reifyBurdenOfProofs,\n        filterBpDefeats,\n        findall(X, context_check(argument(X)), Arguments),\n        bpLabelling(Arguments).\n    bpLabelling(Arguments) :-\n        member(A, Arguments),\n        grounded::allAttacksOUT(A), !,\n        context_assert(in(A)),\n        utils::subtract(Arguments, [A], NewArguments),\n        bpLabelling(NewArguments).\n    bpLabelling(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).\n    bpLabelling(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).\n    bpLabelling(Args) :-\n        notLabelled(Args),\n        findall(_, (member(A, Args), context_assert(und(A))), _).\n    notLabelled(Args) :-\n        \\+ (\n            member(A, Args),\n            (\n                context_check(in(A));\n                context_check(out(A));\n                context_check(und(A))\n            )\n        ).\n    isInBurdenOfProof(Conclusion) :-\n        context_check(reifiedBp(Literals)),\n        member(Conclusion, Literals), !.\n    isArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n        isInBurdenOfProof(Conclusion).\n    filterBpDefeats :-\n        findall(_, (\n            context_check(attack(T, A, B, C)),\n            filterBpDefeat(T, A, B, C)\n        ), _).\n    filterBpDefeat(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)).\n    mostGroundedBpUnd(Arguments, Arg) :-\n        member(Arg, Arguments),\n        isArgumentInBurdenOfProof(Arg),\n        \\+ (\n            member(A, Arguments), Arg \\= A,\n            isArgumentInBurdenOfProof(A),\n            argumentChain(A, Arg)\n        ).\n    argumentChain(A, A) :- !.\n    argumentChain(A, B) :-\n        A \\== B,\n        context_check(attack(_, A, C, _)),\n        argumentChain(C, B).\n    reifyBurdenOfProofs :-\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    */\n    fillTemplate([], []).\n    fillTemplate([H|T], [[H]|R]) :-\n        context_check(argument([_ , _, [P], _, _])),\n        fillTemplate(T, R).\n        ');
   }
   BpGrounded.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5035,7 +5379,7 @@
   }
   function Grounded() {
     Grounded_instance = this;
-    this.theoryCode = trimIndent('\n    argumentLabelling :-\n        findall(X, context_check(argument(X)), Arguments),\n        groundedLabelling(Arguments).\n    groundedLabelling(UND) :-\n        member(A, UND), \n        allAttacksOUT(A), !,\n        utils::subtract(UND, [A], NewUND),\n        context_assert(in(A)),\n        groundedLabelling(NewUND).\n    groundedLabelling(UND) :-\n        member(A, UND),\n        oneAttackIN(A), !,\n        utils::subtract(UND, [A], NewUND),\n        context_assert(out(A)),\n        groundedLabelling(NewUND).\n    groundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\n    allAttacksOUT(A) :-\n        \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\n    oneAttackIN(A) :-\n        context_check(attack(_, B, A, _)),\n        context_check(in(B)), !.\n    oneAttackIN(A) :-\n        context_check(attack(_, A, B, _)),\n        context_check(in(B)), !.\n        ');
+    this.theoryCode = trimIndent('\n    argumentLabelling :-\n        findall(X, context_check(argument(X)), Arguments),\n        groundedLabelling(Arguments).\n    groundedLabelling(UND) :-\n        member(A, UND),\n        allAttacksOUT(A), !,\n        utils::subtract(UND, [A], NewUND),\n        context_assert(in(A)),\n        groundedLabelling(NewUND).\n    groundedLabelling(UND) :-\n        member(A, UND),\n        oneAttackIN(A), !,\n        utils::subtract(UND, [A], NewUND),\n        context_assert(out(A)),\n        groundedLabelling(NewUND).\n    groundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\n    allAttacksOUT(A) :-\n        \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\n    oneAttackIN(A) :-\n        context_check(attack(_, B, A, _)),\n        context_check(in(B)), !.\n    oneAttackIN(A) :-\n        context_check(attack(_, A, B, _)),\n        context_check(in(B)), !.\n        ');
   }
   Grounded.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5048,9 +5392,24 @@
       new Grounded();
     }return Grounded_instance;
   }
+  function GroundedOptimized() {
+    GroundedOptimized_instance = this;
+    this.theoryCode = trimIndent('\n    argumentLabelling :-\n        groundedLabelling.\n    groundedLabelling :-\n        findall(t, evaluateIn, I),\n        findall(t, evaluateOut, O),\n        finalize(I, O).\n    evaluateIn :-\n        argument_to_evaluate(A, IdA),\n        allAttacksOUT(IdA),\n        context_assert(in(A)),\n        context_assert(inId(IdA)).\n    evaluateOut :-\n        argument_to_evaluate(A, IdA),\n        oneAttackIN(IdA),\n        context_assert(out(A)),\n        context_assert(outId(IdA)).\n    finalize(I, O) :- I \\= [], !, groundedLabelling.\n    finalize(I, O) :- O \\= [], !, groundedLabelling.\n    finalize([], []) :-\n        argument_to_evaluate(A, _),\n        context_assert(und(A)),\n        fail.\n    finalize(_, _).\n    argument_to_evaluate(X, IdX) :-\n        context_check(clause(arg(IdX), argument(X))),\n        \\+ context_check(outId(IdX)),\n        \\+ context_check(inId(IdX)).\n    allAttacksOUT(A) :-\n        \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\n    oneAttackIN(A) :-\n        context_check(clause(att(B, A), _)),\n        context_check(inId(B)), !.\n    oneAttackIN(A) :-\n        context_check(clause(att(A, B), _)),\n        context_check(inId(B)), !.\n        ');
+  }
+  GroundedOptimized.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'GroundedOptimized',
+    interfaces: []
+  };
+  var GroundedOptimized_instance = null;
+  function GroundedOptimized_getInstance() {
+    if (GroundedOptimized_instance === null) {
+      new GroundedOptimized();
+    }return GroundedOptimized_instance;
+  }
   function Preferences() {
     Preferences_instance = this;
-    this.theoryCode = trimIndent('\n    modifyArgumentationGraph :-\n        findall(_, (\n            context_check(attack(T, A, B, C)),\n            checkStandardPreference(T, A, B, C)\n        ), _).\n    checkStandardPreference(T, A, B, C) :-\n        \\+ standardPreferences(T, A, B, C),\n        context_retract(attack(T, A, B, C)).\n    standardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\n    standardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\n    standardPreferences(contrary_rebut, _, _, _).\n    standardPreferences(contrary_undermine, _, _, _).\n    standardPreferences(undercut, _, _, _).\n        ');
+    this.theoryCode = trimIndent('\n    modifyArgumentationGraph :-\n        findall(_, (\n            context_check(attack(T, A, B, C)),\n            checkStandardPreference(T, A, B, C)\n        ), _).\n    checkStandardPreference(T, A, B, C) :-\n        \\+ standardPreferences(T, A, B, C),\n        context_retract(attack(T, A, B, C)),\n        hashed_attack(attack(T, A, B, C), Y),\n        context_retract(Y).\n    standardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\n    standardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\n    standardPreferences(contrary_rebut, _, _, _).\n    standardPreferences(contrary_undermine, _, _, _).\n    standardPreferences(undercut, _, _, _).\n    hashed_attack(attack(T, A, B, C), att(IdA, IdB) :- attack(T, A, B, C)) :-\n        utils::hash(argument(A), IdA),\n        utils::hash(argument(B), IdB).\n        ');
   }
   Preferences.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5065,7 +5424,7 @@
   }
   function QueryMode_0() {
     QueryMode_instance_0 = this;
-    this.theoryCode = trimIndent('\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        \\+ queryMode,\n        abstract:::computeGlobalAcceptance,\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        queryMode,\n        argumentLabellingMode(grounded),\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(_, query(X, _), _),\n        (ambiguityBlocking ->\n            statement_binary:::statementLabelling;\n            statementLabellingMode(Y),\n            Y:::statementLabelling\n        ),\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    mineResults(Goal, YesResult, NoResult, UndResult) :-\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(Goal, context_check(statIn(X)), In),\n        findall(Goal, context_check(statOut(X)), Out),\n        findall(Goal, context_check(statUnd(X)), Und),\n        utils::sort(In, YesResult),\n        utils::sort(Out, NoResult),\n        utils::sort(Und, UndResult).\n    query(Query, Res) :-\n        buildArgument(Query, Argument),\n        once(defend(Argument, [], Res)).\n    query(Query, und) :- \\+ buildArgument(Query, _).\n    defend(Argument, _, no) :- context_check(out(Argument)).\n    defend(Argument, _, und) :- context_check(und(Argument)).\n    defend(Argument, _, yes) :- context_check(in(Argument)).\n    defend(Argument, QueryChain, no) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == yes,\n        bufferResult(Argument, no), !.\n    defend(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), !.\n    complementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n        standard_af::conflict(ConclusionA, ConclusionB).\n    ambiguityCheck(A, B, no) :- ambiguityBlocking,\n        \\+ complementary(A, B),\n        context_check(attack(direct, B, A, _)), !.\n    ambiguityCheck(_, _, und).\n    defend(Argument, QueryChain, und) :-\n        findAttacker(Argument, QueryChain, Attacker, no),\n        bufferResult(Argument, und), !.\n    defend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\n    bufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\n    bufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\n    bufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\n    bufferResult(_, _).\n    findAttacker(Target, QueryChain, Attacker, IsValid) :-\n        attacker(Target, Attacker, Type),\n        bufferAttacker(Attacker, Target, Type),\n        detectCycle(Attacker, QueryChain, IsValid).\n    bufferAttacker(Attacker, Target, Type) :-\n        \\+ context_check(attack(Type, Attacker, Target, none)),\n        context_assert(attack(Type, Attacker, Target, none)), !.\n    bufferAttacker(_, _, _).\n    detectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\n    detectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Rules),\n        \\+ context_check(strict(X)),\n        attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Groundings),\n        attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attackerOnRule(Rule, _, Argument, undercut) :-\n        buildArgument([undercut(Rule)], Argument).\n    attackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n        Term \\= [unless, _],\n        \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n        (graphExtension(rebutRestriction) ->\n            (\n                buildSubArgument(Term, TargetRules, SubArgument),\n                rebutRestriction(SubArgument)\n            );\n            true\n        ),\n        standard_af::conflict(Term, X),\n        buildArgument(X, Attacker),\n        (graphExtension(standardPref) ->\n            (ground(SubArgument) ->\n                true;\n                buildSubArgument(Term, TargetRules, SubArgument)\n            ),\n            \\+ superiorArgument(SubArgument, Attacker);\n            true\n        ).\n    attackerOnTerm([unless, X], _, Attacker, contrary) :-\n        buildArgument(X, Attacker).\n    strict([_, _, _, _, [_, [], []]]).\n    rebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction).\n    rebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction),\n        TopRule \\= none,\n        rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\n    rebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\n    superiorArgument(SubArgument, Attacker) :-\n        superiority::superiorArgument(SubArgument, Attacker).\n    buildSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n        buildArgument(Term, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]),\n        contained(SubRules, Rules).\n    contained([], _).\n    contained([H|T], Target) :- member(H, Target), contained(T, Target).\n    buildArgument(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.\n    buildArgument(Query, [R, T, Query, B, I]) :- context_check(argument([R, T, Query, B, I])).\n    buildSingleArgument(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]].\n    build(Conclusion, _, [Conclusion], Rules) :-\n        context_check(premise([Id, Conclusion])),\n        premiseRules(Id, Rules).\n    build(Conclusion, Ids, [Conclusion|Conclusions], Rules) :-\n        context_check(rule([Id, Premises, Conclusion])),\n        \\+ member(Id, Ids),\n        buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n        ruleRules(Id, ResRules, Rules).\n    build([prolog(Check)], _, [], []) :- (callable(Check) -> call(Check); Check).\n    build([unless, Atom], _, [[unless, Atom]], []).\n    buildPremises([], _, [], [[], [], [], []]).\n    buildPremises([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).\n    premiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ context_check(strict(Id)).\n    premiseRules(Id, [[Id], none, [], [], []]) :- context_check(strict(Id)).\n    ruleRules(Id, [AllRules, _, DefRules, DefPremises], \n        [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ context_check(strict(Id)).\n    ruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises], \n        [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- context_check(strict(Id)).\n    mergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]).\n    mergeRules([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).\n        ');
+    this.theoryCode = trimIndent('\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        \\+ queryMode,\n        abstract:::computeGlobalAcceptance,\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    computeStatementAcceptance(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).\n    mineResults(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).\n    query(Query, Res) :-\n        buildArgument(Query, Argument),\n        once(defend(Argument, [], Res)).\n    query(Query, und) :- \\+ buildArgument(Query, _).\n    defend(Argument, _, no) :- context_check(out(Argument)).\n    defend(Argument, _, und) :- context_check(und(Argument)).\n    defend(Argument, _, yes) :- context_check(in(Argument)).\n    defend(Argument, QueryChain, no) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == yes,\n        bufferResult(Argument, no), !.\n    defend(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), !.\n    complementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n        standard_af::conflict(ConclusionA, ConclusionB).\n    ambiguityCheck(A, B, no) :- ambiguityBlocking,\n        \\+ complementary(A, B),\n        context_check(attack(direct, B, A, _)), !.\n    ambiguityCheck(_, _, und).\n    defend(Argument, QueryChain, und) :-\n        findAttacker(Argument, QueryChain, Attacker, no),\n        bufferResult(Argument, und), !.\n    defend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\n    bufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\n    bufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\n    bufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\n    bufferResult(_, _).\n    findAttacker(Target, QueryChain, Attacker, IsValid) :-\n        attacker(Target, Attacker, Type),\n        bufferAttacker(Attacker, Target, Type),\n        detectCycle(Attacker, QueryChain, IsValid).\n    bufferAttacker(Attacker, Target, Type) :-\n        \\+ context_check(attack(Type, Attacker, Target, none)),\n        context_assert(attack(Type, Attacker, Target, none)), !.\n    bufferAttacker(_, _, _).\n    detectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\n    detectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\n    attacker([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).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Groundings),\n        attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attackerOnRule(Rule, _, Argument, undercut) :-\n        parser::undercut(Undercut, Rule),\n        buildArgument(Undercut, Argument).\n    attackerOnTerm(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        standard_af::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        ).\n    attackerOnTerm(Unless, _, Attacker, contrary) :-\n        parser::contrary(Unless, X),\n        buildArgument(X, Attacker).\n    strict([_, _, _, _, [_, [], []]]).\n    rebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction).\n    rebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction),\n        TopRule \\= none,\n        rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\n    rebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\n    superiorArgument(SubArgument, Attacker) :-\n        superiority::superiorArgument(SubArgument, Attacker).\n    getSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n        context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n        contained(SubRules, Rules).\n    contained([], _).\n    contained([H|T], Target) :- member(H, Target), contained(T, Target).\n    buildArgument(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.\n    buildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\n    buildSingleArgument(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]].\n    build(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\n    build(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\n    build(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]])).\n    build(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]])).\n    buildPremises([], _, [], [[], [], [], []]).\n    buildPremises([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).\n    premiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\n    premiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\n    ruleRules(Id, [AllRules, _, DefRules, DefPremises],\n        [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\n    ruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n        [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\n    mergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\n    mergeRules([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).\n        ');
   }
   QueryMode_0.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5080,7 +5439,7 @@
   }
   function RuleTranslator() {
     RuleTranslator_instance = this;
-    this.theoryCode = trimIndent("\n    /*\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     */\n    convertAllRules(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, SpecialRules], L),\n        convertAllRules(L, Rules),\n        findall(sup(X, Y), sup(X, Y), Sup),\n        utils::appendLists([Rules, AxiomsIds, RulesIds, Sup], ArgRules),\n        utils::assert_all(ArgRules), !.\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(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).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        utils::append_fast(PremisesOld, PremisesNew, Premises).\n    axiomPremises(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).\n    specialRules(SpecialRules) :-\n        bpsNew(SpecialRules).\n    transpose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\n    transpose([], CtrRules, CtrRules).\n    transpose([H|T], TempCtrRules, CtrRules) :-\n        transpose(T, TempCtrRules, CR),\n        findall(TrH, transposition(H, TrH), Tran),\n        mergeCtrRules(CR, Tran, CtrRules).\n    mergeCtrRules(All, ToMerge, X) :-\n        utils::append_fast(All, ToMerge, XT),\n        deduplicate(XT, X).\n    deduplicate([], []).\n    deduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \n    transposition([Id, Prec, Effect], [Id, Prec, Effect]).\n    transposition([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).\n    transposition([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).\n    transposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\n    transposition_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).\n    newIdentifier(List, OldId, NewId) :-\n        modifier(List, Mod),\n        atom_concat(OldId, Mod, NewId).\n    modifier([], '_i').\n    modifier([_|Tail], Index):-\n        modifier(Tail, Index1),\n        atom_concat(Index1, 'i', Index).\n    negate(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).\n    prologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n    /*\n     *   Standard rules (RuleName : Preconditions => Effects)\n     *   Special rules (RuleName : Effects)\n     */\n    convertAllRules([], []).\n    convertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\n    convertAllRules([[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     */\n    convertRule(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     */\n    convertRule(bps, Effects, abstractBp(Checked)) :-\n        functor(Effects, 'bp', _),\n        Effects =.. L,\n        removehead(L, LC),\n        check_modifiers_in_list(effects, LC, Checked), !.\n    convertRule(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     */\n    check_modifiers_in_list(MODE, [], []) :- !.\n    check_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\n    check_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.\n    check_modifiers_once(H, List) :- once(check_modifiers(H, List)).\n    check_modifiers([], []).\n    check_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].\n    /*\n     *   Convert the given tuple to list\n     */\n    tuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\n    tuple_to_list((A,B),L) :-\n        tuple_to_list(A, La),\n        tuple_to_list(B, Lb),\n        utils::append_fast(La, Lb,L).\n    list_to_tuple([H], (H)) :- !.\n    list_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     */\n    replace(_, _, [],[]) :- !.\n    replace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\n    replace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\n    flatten_first_level([X], X) :- !.\n    flatten_first_level.\n    removehead([_|Tail], Tail).\n    in(A, A) :- nonvar(A), A \\= (_ , _), !.\n    in(A, (A, _)) :- !.\n    in(A, (_ , Cs)) :- in(A, Cs).\n    check_admissibility(preconditions, H, LH) :-\n        \\+ defeasible_admissible(LH),\n        throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(effects, H, LH) :-\n        \\+ admissible(LH),\n        throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(_, _, _).\n    defeasible_admissible([unless, Term]) :- admissible(Term).\n    defeasible_admissible(Term) :- admissible(Term).\n    admissible([neg, bp, Term]) :- admissible_terms_complete(Term).\n    admissible([bp, Term]) :- admissible_terms_complete(Term).\n    admissible([neg, Term]) :- admissible_term(Term).\n    admissible([obl, [Term]]) :- admissible_term(Term).\n    admissible([obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([perm, [Term]]) :- admissible_term(Term).\n    admissible([perm, [neg, Term]]) :- admissible_term(Term).\n    admissible([Term]) :- admissible_term(Term).\n    admissible_term(Term) :-\n        atomic(Term),\n        Term \\== neg,\n        Term \\== obl,\n        Term \\== perm,\n        Term \\== unless,\n        Term \\== bp.\n    admissible_term(Term) :- var(Term).\n    admissible_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).\n    admissible_terms([]).\n    admissible_terms([H|T]) :-\n        admissible_term(H),\n        admissible_terms(T).\n    admissible_terms_complete([]).\n    admissible_terms_complete([H|T]) :-\n        admissible(H),\n        admissible_terms_complete(T).\n        ");
+    this.theoryCode = trimIndent("\n    /*\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     */\n    convertAllRules(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), !.\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(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).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        utils::append_fast(PremisesOld, PremisesNew, Premises).\n    axiomPremises(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).\n    specialRules(SpecialRules) :-\n        bpsNew(SpecialRules).\n    transpose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\n    transpose([], CtrRules, CtrRules).\n    transpose([H|T], TempCtrRules, CtrRules) :-\n        transpose(T, TempCtrRules, CR),\n        findall(TrH, transposition(H, TrH), Tran),\n        mergeCtrRules(CR, Tran, CtrRules).\n    mergeCtrRules(All, ToMerge, X) :-\n        utils::append_fast(All, ToMerge, XT),\n        deduplicate(XT, X).\n    deduplicate([], []).\n    deduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \n    transposition([Id, Prec, Effect], [Id, Prec, Effect]).\n    transposition([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).\n    transposition([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).\n    transposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\n    transposition_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).\n    newIdentifier(List, OldId, NewId) :-\n        modifier(List, Mod),\n        atom_concat(OldId, Mod, NewId).\n    modifier([], '_i').\n    modifier([_|Tail], Index):-\n        modifier(Tail, Index1),\n        atom_concat(Index1, 'i', Index).\n    negate(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).\n    prologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n    /*\n     *   Standard rules (RuleName : Preconditions => Effects)\n     *   Special rules (RuleName : Effects)\n     */\n    convertAllRules([], []).\n    convertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\n    convertAllRules([[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     */\n    convertRule(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     */\n    convertRule(bps, Effects, abstractBp(Checked)) :-\n        functor(Effects, 'bp', _),\n        Effects =.. L,\n        removehead(L, LC),\n        check_modifiers_in_list(effects, LC, Checked), !.\n    convertRule(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     */\n    check_modifiers_in_list(MODE, [], []) :- !.\n    check_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\n    check_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.\n    check_modifiers_once(H, List) :- once(check_modifiers(H, List)).\n    check_modifiers([], []).\n    check_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].\n    list_to_tuple([H], (H)) :- !.\n    list_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     */\n    replace(_, _, [],[]) :- !.\n    replace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\n    replace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\n    flatten_first_level([X], X) :- !.\n    flatten_first_level.\n    removehead([_|Tail], Tail).\n    in(A, A) :- nonvar(A), A \\= (_ , _), !.\n    in(A, (A, _)) :- !.\n    in(A, (_ , Cs)) :- in(A, Cs).\n    check_admissibility(preconditions, H, LH) :-\n        \\+ defeasible_admissible(LH),\n        throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(effects, H, LH) :-\n        \\+ admissible(LH),\n        throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(_, _, _).\n    defeasible_admissible([unless, Term]) :- admissible(Term).\n    defeasible_admissible(Term) :- admissible(Term).\n    admissible([neg, bp, Term]) :- admissible_terms_complete(Term).\n    admissible([bp, Term]) :- admissible_terms_complete(Term).\n    admissible([neg, Term]) :- admissible_term(Term).\n    admissible([obl, [Term]]) :- admissible_term(Term).\n    admissible([obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([perm, [Term]]) :- admissible_term(Term).\n    admissible([perm, [neg, Term]]) :- admissible_term(Term).\n    admissible([Term]) :- admissible_term(Term).\n    admissible_term(Term) :-\n        atomic(Term),\n        Term \\== neg,\n        Term \\== obl,\n        Term \\== perm,\n        Term \\== unless,\n        Term \\== bp.\n    admissible_term(Term) :- var(Term).\n    admissible_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).\n    admissible_terms([]).\n    admissible_terms([H|T]) :-\n        admissible_term(H),\n        admissible_terms(T).\n    admissible_terms_complete([]).\n    admissible_terms_complete([H|T]) :-\n        admissible(H),\n        admissible_terms_complete(T).\n    rule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\n    premise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\n    check_strict(Id) :- context_check(strict(Id)).\n    prolog([prolog(Term)], Term).\n    contrary([~(Term)], Term).\n    undercut(undercut(Rule), Rule).\n    superiority(sup(Id1, Id2), Id1, Id2).\n    /*\n     *   Convert the given tuple to list\n     */\n    tuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\n    tuple_to_list((A,B),L) :-\n        tuple_to_list(A, La),\n        tuple_to_list(B, Lb),\n        utils::append_fast(La, Lb,L).\n    ff([[]], []) :- !.\n    ff([[X]], [X]) :- !.\n    ff(X, X).\n    classic_rule(X, Y, Z) :- rule(X, Y, Z).\n    classic_rule(X, Y) :- premise(X, Y).\n        ");
   }
   RuleTranslator.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5315,6 +5674,7 @@
   package$labelling.BpPartialLabellerBase = BpPartialLabellerBase;
   package$labelling.CompleteLabellerBase = CompleteLabellerBase;
   package$labelling.GroundedLabellerBase = GroundedLabellerBase;
+  package$labelling.GroundedLabellerOptimizedBase = GroundedLabellerOptimizedBase;
   Object.defineProperty(package$labelling, 'PassThroughStatementLabeller', {
     get: PassThroughStatementLabeller_getInstance
   });
@@ -5351,6 +5711,9 @@
   Object.defineProperty(package$language, 'ExtractStrictIds', {
     get: ExtractStrictIds_getInstance
   });
+  Object.defineProperty(package$language, 'RuleToClause', {
+    get: RuleToClause_getInstance
+  });
   var package$structured = package$libs.structured || (package$libs.structured = {});
   package$structured.StructuredModeBase = StructuredModeBase;
   Object.defineProperty(package$structured, 'QueryMode', {
@@ -5368,6 +5731,7 @@
   Object.defineProperty(package$utils, 'OrderingComparator', {
     get: OrderingComparator_getInstance
   });
+  $$importsForInline$$['@tuprolog/2p-solve'] = $module$_2p_solve;
   package$utils.UtilsBase = UtilsBase;
   Object.defineProperty(package$utils, 'AppendOptimized', {
     get: AppendOptimized_getInstance
@@ -5375,6 +5739,15 @@
   Object.defineProperty(package$utils, 'AssertAll', {
     get: AssertAll_getInstance
   });
+  Object.defineProperty(package$utils, 'ArgumentHash', {
+    get: ArgumentHash_getInstance
+  });
+  Object.defineProperty(package$utils, 'Contains', {
+    get: Contains_getInstance
+  });
+  Object.defineProperty(package$utils, 'ContainsAny', {
+    get: ContainsAny_getInstance
+  });
   var package$meta = package$core.meta || (package$core.meta = {});
   Object.defineProperty(package$meta, 'MetaInterpreterLib', {
     get: MetaInterpreterLib_getInstance
@@ -5439,6 +5812,9 @@
   Object.defineProperty(package$labelling, 'GroundedLabeller', {
     get: GroundedLabeller_getInstance
   });
+  Object.defineProperty(package$labelling, 'GroundedLabellerOptimized', {
+    get: GroundedLabellerOptimized_getInstance
+  });
   Object.defineProperty(package$labelling, 'StatementLabeller', {
     get: StatementLabeller_getInstance
   });
@@ -5485,6 +5861,9 @@
   Object.defineProperty(package$sources, 'Grounded', {
     get: Grounded_getInstance
   });
+  Object.defineProperty(package$sources, 'GroundedOptimized', {
+    get: GroundedOptimized_getInstance
+  });
   Object.defineProperty(package$sources, 'Preferences', {
     get: Preferences_getInstance
   });
@@ -5632,21 +6011,17 @@
   PrologWithArgumentation.prototype.unifyWithOccurCheck = PrologScopeWithTheories.prototype.unifyWithOccurCheck;
   PrologWithArgumentation.prototype.var1 = PrologScopeWithTheories.prototype.var1;
   PrologWithArgumentation.prototype.write1 = PrologScopeWithTheories.prototype.write1;
-  PrologWithArgumentation.prototype.neq2 = PrologScopeWithTheories.prototype.neq2;
-  PrologWithArgumentation.prototype.nid2 = PrologScopeWithTheories.prototype.nid2;
-  PrologWithArgumentation.prototype.power = PrologScopeWithTheories.prototype.power;
-  PrologWithArgumentation.prototype.eq2 = PrologScopeWithTheories.prototype.eq2;
-  PrologWithArgumentation.prototype.arithNeq2 = PrologScopeWithTheories.prototype.arithNeq2;
-  PrologWithArgumentation.prototype.id2 = PrologScopeWithTheories.prototype.id2;
-  PrologWithArgumentation.prototype.arithEq2 = PrologScopeWithTheories.prototype.arithEq2;
-  PrologWithArgumentation.prototype.pow = PrologScopeWithTheories.prototype.pow;
   PrologWithArgumentation.prototype.anyAnd = PrologScopeWithTheories.prototype.anyAnd;
+  PrologWithArgumentation.prototype.arithEq2 = PrologScopeWithTheories.prototype.arithEq2;
+  PrologWithArgumentation.prototype.arithNeq2 = PrologScopeWithTheories.prototype.arithNeq2;
   PrologWithArgumentation.prototype.substitutionContainsKey = PrologScopeWithTheories.prototype.substitutionContainsKey;
   PrologWithArgumentation.prototype.substitutionContainsValue = PrologScopeWithTheories.prototype.substitutionContainsValue;
   PrologWithArgumentation.prototype.anyDiv = PrologScopeWithTheories.prototype.anyDiv;
+  PrologWithArgumentation.prototype.eq2 = PrologScopeWithTheories.prototype.eq2;
   PrologWithArgumentation.prototype.anyEqualsTo = PrologScopeWithTheories.prototype.anyEqualsTo;
   PrologWithArgumentation.prototype.anyGreaterThan = PrologScopeWithTheories.prototype.anyGreaterThan;
   PrologWithArgumentation.prototype.anyGreaterThanOrEqualsTo = PrologScopeWithTheories.prototype.anyGreaterThanOrEqualsTo;
+  PrologWithArgumentation.prototype.id2 = PrologScopeWithTheories.prototype.id2;
   PrologWithArgumentation.prototype.anyIf = PrologScopeWithTheories.prototype.anyIf;
   PrologWithArgumentation.prototype.anyIfVararg = PrologScopeWithTheories.prototype.anyIfVararg;
   PrologWithArgumentation.prototype.anyImpliedBy = PrologScopeWithTheories.prototype.anyImpliedBy;
@@ -5659,6 +6034,8 @@
   PrologWithArgumentation.prototype.anyMatches = PrologScopeWithTheories.prototype.anyMatches;
   PrologWithArgumentation.prototype.anyMguWith = PrologScopeWithTheories.prototype.anyMguWith;
   PrologWithArgumentation.prototype.anyMinus = PrologScopeWithTheories.prototype.anyMinus;
+  PrologWithArgumentation.prototype.neq2 = PrologScopeWithTheories.prototype.neq2;
+  PrologWithArgumentation.prototype.nid2 = PrologScopeWithTheories.prototype.nid2;
   PrologWithArgumentation.prototype.anyNonGreaterThan = PrologScopeWithTheories.prototype.anyNonGreaterThan;
   PrologWithArgumentation.prototype.anyNonLowerThan = PrologScopeWithTheories.prototype.anyNonLowerThan;
   PrologWithArgumentation.prototype.anyNotEqualsTo = PrologScopeWithTheories.prototype.anyNotEqualsTo;
@@ -5693,9 +6070,9 @@
   PrologWithArgumentationImpl.prototype.anyMguWith = PrologWithArgumentation.prototype.anyMguWith;
   PrologWithArgumentationImpl.prototype.anyUnifyWith = PrologWithArgumentation.prototype.anyUnifyWith;
   PrologWithArgumentationImpl.prototype.list = PrologWithArgumentation.prototype.list;
-  PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
   PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
   PrologWithArgumentationImpl.prototype.listFromIterable = PrologWithArgumentation.prototype.listFromIterable;
+  PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
   PrologWithArgumentationImpl.prototype.matchAny = PrologWithArgumentation.prototype.matchAny;
   PrologWithArgumentationImpl.prototype.mguWithOccurCheck = PrologWithArgumentation.prototype.mguWithOccurCheck;
   PrologWithArgumentationImpl.prototype.mguAny = PrologWithArgumentation.prototype.mguAny;
@@ -5755,6 +6132,8 @@
   CompleteLabellerBase.prototype.content = ArgLibrary.prototype.content;
   GroundedLabellerBase.prototype.flags = ArgLibrary.prototype.flags;
   GroundedLabellerBase.prototype.content = ArgLibrary.prototype.content;
+  GroundedLabellerOptimizedBase.prototype.flags = ArgLibrary.prototype.flags;
+  GroundedLabellerOptimizedBase.prototype.content = ArgLibrary.prototype.content;
   PassThroughStatementLabeller.prototype.flags = ArgLibrary.prototype.flags;
   PassThroughStatementLabeller.prototype.content = ArgLibrary.prototype.content;
   StatementLabellerBase.prototype.flags = ArgLibrary.prototype.flags;