@tuprolog/arg2p 0.12.0 → 0.13.0

package/arg2p-core.js

@@ -80,14 +80,14 @@
   var matchAny = kotlin_it_unibo_tuprolog_dsl_unify.$_$.a;
   var unifyAny = kotlin_it_unibo_tuprolog_dsl_unify.$_$.c;
   var solverOf = kotlin_it_unibo_tuprolog_dsl_solve.$_$.a;
-  var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var BaseLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.e;
+  var LogicProgrammingScopeWithTheories = kotlin_it_unibo_tuprolog_dsl_theory.$_$.h;
   var LogicProgrammingScopeWithPrologStandardLibrary = kotlin_it_unibo_tuprolog_dsl_core.$_$.h4;
-  var MinimalLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.c5;
+  var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var LogicProgrammingScopeWithResolution = kotlin_it_unibo_tuprolog_dsl_solve.$_$.c;
   var LogicProgrammingScopeWithUnification = kotlin_it_unibo_tuprolog_dsl_unify.$_$.j;
-  var LogicProgrammingScopeWithTheories = kotlin_it_unibo_tuprolog_dsl_theory.$_$.h;
-  var BaseLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.e;
   var LogicProgrammingScopeWithOperators = kotlin_it_unibo_tuprolog_dsl_core.$_$.w1;
-  var LogicProgrammingScopeWithResolution = kotlin_it_unibo_tuprolog_dsl_solve.$_$.c;
+  var MinimalLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.c5;
   var LogicProgrammingScopeWithSubstitutions = kotlin_it_unibo_tuprolog_dsl_core.$_$.o4;
   var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.i;
   var lazy = kotlin_kotlin.$_$.ra;
@@ -220,7 +220,7 @@
   initMetadataForClass(Arg2pSolver$Companion$of$1, VOID, VOID, VOID, [Arg2pSolver]);
   initMetadataForCompanion(Companion);
   initMetadataForObject(Arg2pSolverFactory, 'Arg2pSolverFactory');
-  initMetadataForClass(PrologWithArgumentationImpl, 'PrologWithArgumentationImpl', PrologWithArgumentationImpl, VOID, [Scope, LogicProgrammingScopeWithPrologStandardLibrary, MinimalLogicProgrammingScope, LogicProgrammingScopeWithUnification, LogicProgrammingScopeWithTheories, BaseLogicProgrammingScope, LogicProgrammingScopeWithOperators, LogicProgrammingScopeWithResolution, LogicProgrammingScopeWithSubstitutions]);
+  initMetadataForClass(PrologWithArgumentationImpl, 'PrologWithArgumentationImpl', PrologWithArgumentationImpl, VOID, [BaseLogicProgrammingScope, LogicProgrammingScopeWithTheories, LogicProgrammingScopeWithPrologStandardLibrary, Scope, LogicProgrammingScopeWithResolution, LogicProgrammingScopeWithUnification, LogicProgrammingScopeWithOperators, MinimalLogicProgrammingScope, LogicProgrammingScopeWithSubstitutions]);
   function get_theoryOperators() {
     return Companion_getInstance_0().DEFAULT;
   }
@@ -250,6 +250,7 @@
   initMetadataForClass(AbstractWithLib, 'AbstractWithLib', VOID, VOID, [Primitive]);
   initMetadataForClass(WithLib, 'WithLib', VOID, AbstractWithLib);
   initMetadataForClass(WithLibInNewContext, 'WithLibInNewContext', VOID, AbstractWithLib);
+  initMetadataForClass(ResetLoader, 'ResetLoader', VOID, VOID, [Primitive]);
   initMetadataForCompanion(Companion_0);
   initMetadataForClass(DynamicLoader, 'DynamicLoader', VOID, VOID, [ArgLibrary]);
   initMetadataForClass(EngineInterfaceBase, 'EngineInterfaceBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
@@ -272,17 +273,29 @@
   initMetadataForClass(DefeasiblePreferencesHandlerBase, 'DefeasiblePreferencesHandlerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(GenericDefeasiblePreferencesHandlerBase, 'GenericDefeasiblePreferencesHandlerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(StrictPreferencesHandlerBase, 'StrictPreferencesHandlerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(AdmissibleLabeller, 'AdmissibleLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForObject(BinaryStatementLabeller, 'BinaryStatementLabeller', VOID, VOID, [ArgLibrary, Loadable]);
   initMetadataForObject(BinaryLabelling, 'BinaryLabelling', VOID, RuleWrapper);
   initMetadataForClass(BpCompleteLabellerBase, 'BpCompleteLabellerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(BpLabellerBase, 'BpLabellerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(BpPartialLabellerBase, 'BpPartialLabellerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(Cf2Labeller, 'Cf2Labeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(CompleteLabellerBase, 'CompleteLabellerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(ConflictFreeLabeller, 'ConflictFreeLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(EagerLabeller, 'EagerLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(GroundedLabellerBase, 'GroundedLabellerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(GroundedLabellerOptimizedBase, 'GroundedLabellerOptimizedBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(IdealLabeller, 'IdealLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(NaiveLabeller, 'NaiveLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForObject(PassThroughStatementLabeller, 'PassThroughStatementLabeller', VOID, VOID, [ArgLibrary, Loadable]);
   initMetadataForObject(Labelling, 'Labelling', VOID, RuleWrapper);
+  initMetadataForObject(PreferredLabeller, 'PreferredLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(SemistableLabeller, 'SemistableLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(StableLabeller, 'StableLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(Stage2Labeller, 'Stage2Labeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(StageLabeller, 'StageLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForClass(StatementLabellerBase, 'StatementLabellerBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
+  initMetadataForObject(StronglyAdmissibleLabeller, 'StronglyAdmissibleLabeller', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForCompanion(Companion_2);
   initMetadataForClass(RuleParserBase, 'RuleParserBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
   initMetadataForObject(StrictRules, 'StrictRules', VOID, WithoutSideEffects);
@@ -386,7 +399,7 @@
     return new Arg2pSolver$Companion$of$1(staticLibs, dynamicLibs);
   };
   protoOf(Companion).f39 = function (staticLibs, dynamicLibs) {
-    return this.e39(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([EngineInterface_getInstance(), Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_instance, ModuleCalls_instance, ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), AttackRelation_getInstance_0(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance(), GroundedLabellerOptimized_getInstance()]), dynamicLibs));
+    return this.e39(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([EngineInterface_getInstance(), Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_instance, ModuleCalls_instance, ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), PreferredLabeller_getInstance(), SemistableLabeller_getInstance(), StableLabeller_getInstance(), IdealLabeller_getInstance(), EagerLabeller_getInstance(), NaiveLabeller_getInstance(), StageLabeller_getInstance(), Cf2Labeller_getInstance(), Stage2Labeller_getInstance(), ConflictFreeLabeller_getInstance(), AdmissibleLabeller_getInstance(), StronglyAdmissibleLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), AttackRelation_getInstance_0(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance(), GroundedLabellerOptimized_getInstance()]), dynamicLibs));
   };
   protoOf(Companion).g39 = function (staticLibs, dynamicLibs, $super) {
     staticLibs = staticLibs === VOID ? emptyList() : staticLibs;
@@ -1915,6 +1928,20 @@
   protoOf(WithLibInNewContext).d3d = function (module_0, solver) {
     return logicProgramming(DynamicLoader$WithLibInNewContext$execute$lambda(solver));
   };
+  function ResetLoader($outer) {
+    this.q3d_1 = $outer;
+    this.p3d_1 = new Signature('loader_reset', 0);
+  }
+  protoOf(ResetLoader).m1s = function () {
+    return this.p3d_1;
+  };
+  protoOf(ResetLoader).g2e = function (request) {
+    this.q3d_1.f3d_1.d3();
+    return sequenceOf(request.replyWithCondition(true, VOID, []));
+  };
+  protoOf(ResetLoader).solve = function (request) {
+    return this.g2e(request);
+  };
   function Companion_0() {
   }
   protoOf(Companion_0).d39 = function () {
@@ -2000,7 +2027,7 @@
   };
   protoOf(DynamicLoader).y39 = function () {
     // Inline function 'kotlin.let' call
-    var it = listOf([new WithLib(this), new WithLibInNewContext(this)]);
+    var it = listOf([new WithLib(this), new WithLibInNewContext(this), new ResetLoader(this)]);
     var tmp = Companion_getInstance_2();
     // Inline function 'kotlin.collections.associateBy' call
     var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(it, 10)), 16);
@@ -2019,24 +2046,24 @@
   };
   function EngineInterfaceBase() {
     LazyRawPrologContent.call(this);
-    this.q3d_1 = 'prolog.argumentation.interface';
-    this.r3d_1 = Companion_instance_10.d39().plusOperatorSet(Companion_instance_8.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.s3d_1 = 'prolog.argumentation.interface';
+    this.t3d_1 = Companion_instance_10.d39().plusOperatorSet(Companion_instance_8.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(EngineInterfaceBase).y2b = function () {
-    return this.q3d_1;
+    return this.s3d_1;
   };
   protoOf(EngineInterfaceBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a(), Companion_instance_10.d39());
   };
   protoOf(EngineInterfaceBase).i39 = function () {
-    return this.r3d_1;
+    return this.t3d_1;
   };
   protoOf(EngineInterfaceBase).z39 = function () {
     return 'arg2p';
   };
   function Companion_1() {
   }
-  protoOf(Companion_1).s3d = function (target) {
+  protoOf(Companion_1).u3d = function (target) {
     // Inline function 'kotlin.also' call
     var this_0 = Companion_instance_2.empty(Companion_getInstance_1().u1i());
     $l$block: {
@@ -2047,23 +2074,23 @@
       var _iterator__ex2g4s = target.v39_1.p();
       while (_iterator__ex2g4s.s()) {
         var element = _iterator__ex2g4s.t();
-        this_0.g1q(parseClause(Companion_getInstance_6(), GraphExtension_instance.t3d() + '(X) :- X = ' + element));
+        this_0.g1q(parseClause(Companion_getInstance_6(), GraphExtension_instance.v3d() + '(X) :- X = ' + element));
       }
       if (target.m39_1) {
-        this_0.g1r(parseStruct(Companion_getInstance_7(), QueryMode_instance.t3d()));
+        this_0.g1r(parseStruct(Companion_getInstance_7(), QueryMode_instance.v3d()));
       }
       if (target.n39_1) {
-        this_0.g1r(parseStruct(Companion_getInstance_7(), AutoTransposition_instance.t3d()));
+        this_0.g1r(parseStruct(Companion_getInstance_7(), AutoTransposition_instance.v3d()));
       }
       if (target.o39_1) {
-        this_0.g1r(parseStruct(Companion_getInstance_7(), PrologStrictCompatibility_instance.t3d()));
+        this_0.g1r(parseStruct(Companion_getInstance_7(), PrologStrictCompatibility_instance.v3d()));
       }
-      this_0.g1r(parseStruct(Companion_getInstance_7(), GraphBuildMode_instance.t3d() + '(' + target.p39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance_7(), ArgumentLabellingMode_instance.t3d() + '(' + target.q39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance_7(), StatementLabellingMode_instance.t3d() + '(' + target.r39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingPrinciple_instance.t3d() + '(' + target.s39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingComparator_instance.t3d() + '(' + target.t39_1 + ')'));
-      this_0.g1r(parseStruct(Companion_getInstance_7(), ModulesPath_instance.t3d() + '(' + target.u39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), GraphBuildMode_instance.v3d() + '(' + target.p39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), ArgumentLabellingMode_instance.v3d() + '(' + target.q39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), StatementLabellingMode_instance.v3d() + '(' + target.r39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingPrinciple_instance.v3d() + '(' + target.s39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingComparator_instance.v3d() + '(' + target.t39_1 + ')'));
+      this_0.g1r(parseStruct(Companion_getInstance_7(), ModulesPath_instance.v3d() + '(' + target.u39_1 + ')'));
     }
     return this_0;
   };
@@ -2072,27 +2099,27 @@
     return Companion_instance_9;
   }
   function FlagsBuilder$create$1(this$0) {
-    this.v3d_1 = this$0;
-    this.u3d_1 = 'prolog.argumentation.flags';
+    this.x3d_1 = this$0;
+    this.w3d_1 = 'prolog.argumentation.flags';
   }
   protoOf(FlagsBuilder$create$1).y2b = function () {
-    return this.u3d_1;
+    return this.w3d_1;
   };
   protoOf(FlagsBuilder$create$1).y39 = function () {
-    return Companion_getInstance_2().of(this.u3d_1, VOID, Companion_instance_9.s3d(this.v3d_1));
+    return Companion_getInstance_2().of(this.w3d_1, VOID, Companion_instance_9.u3d(this.x3d_1));
   };
   function FlagsBuilder(emptyBuilder, queryMode, autoTransposition, prologStrictCompatibility, graphBuildMode, argumentLabellingMode, statementLabellingMode, orderingPrinciple, orderingComparator, modulesPath, graphExtensions) {
     emptyBuilder = emptyBuilder === VOID ? false : emptyBuilder;
-    queryMode = queryMode === VOID ? QueryMode_instance.w3d() : queryMode;
-    autoTransposition = autoTransposition === VOID ? AutoTransposition_instance.w3d() : autoTransposition;
-    prologStrictCompatibility = prologStrictCompatibility === VOID ? PrologStrictCompatibility_instance.w3d() : prologStrictCompatibility;
-    graphBuildMode = graphBuildMode === VOID ? GraphBuildMode_instance.w3d() : graphBuildMode;
-    argumentLabellingMode = argumentLabellingMode === VOID ? ArgumentLabellingMode_instance.w3d() : argumentLabellingMode;
-    statementLabellingMode = statementLabellingMode === VOID ? StatementLabellingMode_instance.w3d() : statementLabellingMode;
-    orderingPrinciple = orderingPrinciple === VOID ? OrderingPrinciple_instance.w3d() : orderingPrinciple;
-    orderingComparator = orderingComparator === VOID ? OrderingComparator_instance.w3d() : orderingComparator;
-    modulesPath = modulesPath === VOID ? ModulesPath_instance.w3d() : modulesPath;
-    graphExtensions = graphExtensions === VOID ? GraphExtension_instance.w3d() : graphExtensions;
+    queryMode = queryMode === VOID ? QueryMode_instance.y3d() : queryMode;
+    autoTransposition = autoTransposition === VOID ? AutoTransposition_instance.y3d() : autoTransposition;
+    prologStrictCompatibility = prologStrictCompatibility === VOID ? PrologStrictCompatibility_instance.y3d() : prologStrictCompatibility;
+    graphBuildMode = graphBuildMode === VOID ? GraphBuildMode_instance.y3d() : graphBuildMode;
+    argumentLabellingMode = argumentLabellingMode === VOID ? ArgumentLabellingMode_instance.y3d() : argumentLabellingMode;
+    statementLabellingMode = statementLabellingMode === VOID ? StatementLabellingMode_instance.y3d() : statementLabellingMode;
+    orderingPrinciple = orderingPrinciple === VOID ? OrderingPrinciple_instance.y3d() : orderingPrinciple;
+    orderingComparator = orderingComparator === VOID ? OrderingComparator_instance.y3d() : orderingComparator;
+    modulesPath = modulesPath === VOID ? ModulesPath_instance.y3d() : modulesPath;
+    graphExtensions = graphExtensions === VOID ? GraphExtension_instance.y3d() : graphExtensions;
     this.l39_1 = emptyBuilder;
     this.m39_1 = queryMode;
     this.n39_1 = autoTransposition;
@@ -2155,13 +2182,13 @@
     return true;
   };
   function MetaInterpreter() {
-    this.x3d_1 = 'prolog.argumentation.meta.crossjustice';
+    this.z3d_1 = 'prolog.argumentation.meta.crossjustice';
   }
   protoOf(MetaInterpreter).y2b = function () {
-    return this.x3d_1;
+    return this.z3d_1;
   };
   protoOf(MetaInterpreter).y39 = function () {
-    return Companion_getInstance_2().of(this.x3d_1, VOID, parseTheory(Companion_instance_0, '% with_facts_and_length/3\nwith_facts_and_length(X, Y, L) :-\n    solve(X, R),\n    recover_facts(R, Y),\n    length(Y, L).\n\n% lenght/2\n\nlength([], 0).\nlength([_|T], X) :- length(T, Y), X is Y + 1.\n\n% recover_facts/2\n\nrecover_facts([], []) :- !.\nrecover_facts([H|T], C) :-\n    is_list(H), !,\n    recover_facts(T, TC),\n    recover_facts(H, HC),\n    append(TC, HC, C).\nrecover_facts([H|T], C) :-\n    \\+ is_list(H),\n    recover_facts(T, TC),\n    evaluate(H, HC),\n    append(TC, HC, C).\n\nevaluate(user_fact(X), [X]) :- !.\nevaluate(_, []) :- !.\n\n% solve/2\n\nsolve((A,B), Result) :- !,\n    solve(A, ARes),\n    solve(B, BRes),\n    append(ARes, BRes, Result).\n\nsolve((A;B), Result) :- !,\n    solve(A, Result);\n    solve(B, Result).\n\nsolve(member(A, B), [system_predicate]) :- !,\n    call(member(A, B)).\n\nsolve(\\+(A), [not(A)]) :- !,\n    call(\\+(A)).\n\nsolve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n    call((A)\\=(B)).\n\nsolve(A, [system_predicate]) :-\n    catch(clause(A, _), B, true),\n    \\+ var(B), !,\n    call(A).\n\nsolve(A, [A]) :-\n    \\+ clause(A, B), !,\n    call(A).\n\nsolve(A, [A|[Res]]) :-\n    clause(A, B),\n    solve(B, Res).\n\n% is_list/1\n\nis_list(X) :- var(X), !, fail.\nis_list([]).\nis_list([_|T]) :- is_list(T).\n\n% fetch_argument_facts/2\n\nfetch_argument_facts(Conclusion, Facts) :-\n    argument([R, TR, [Conclusion]]),\n    findall(user_fact(Fact), \n        support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n    Facts).'));
+    return Companion_getInstance_2().of(this.z3d_1, VOID, parseTheory(Companion_instance_0, '% with_facts_and_length/3\nwith_facts_and_length(X, Y, L) :-\n    solve(X, R),\n    recover_facts(R, Y),\n    length(Y, L).\n\n% lenght/2\n\nlength([], 0).\nlength([_|T], X) :- length(T, Y), X is Y + 1.\n\n% recover_facts/2\n\nrecover_facts([], []) :- !.\nrecover_facts([H|T], C) :-\n    is_list(H), !,\n    recover_facts(T, TC),\n    recover_facts(H, HC),\n    append(TC, HC, C).\nrecover_facts([H|T], C) :-\n    \\+ is_list(H),\n    recover_facts(T, TC),\n    evaluate(H, HC),\n    append(TC, HC, C).\n\nevaluate(user_fact(X), [X]) :- !.\nevaluate(_, []) :- !.\n\n% solve/2\n\nsolve((A,B), Result) :- !,\n    solve(A, ARes),\n    solve(B, BRes),\n    append(ARes, BRes, Result).\n\nsolve((A;B), Result) :- !,\n    solve(A, Result);\n    solve(B, Result).\n\nsolve(member(A, B), [system_predicate]) :- !,\n    call(member(A, B)).\n\nsolve(\\+(A), [not(A)]) :- !,\n    call(\\+(A)).\n\nsolve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n    call((A)\\=(B)).\n\nsolve(A, [system_predicate]) :-\n    catch(clause(A, _), B, true),\n    \\+ var(B), !,\n    call(A).\n\nsolve(A, [A]) :-\n    \\+ clause(A, B), !,\n    call(A).\n\nsolve(A, [A|[Res]]) :-\n    clause(A, B),\n    solve(B, Res).\n\n% is_list/1\n\nis_list(X) :- var(X), !, fail.\nis_list([]).\nis_list([_|T]) :- is_list(T).\n\n% fetch_argument_facts/2\n\nfetch_argument_facts(Conclusion, Facts) :-\n    argument([R, TR, [Conclusion]]),\n    findall(user_fact(Fact), \n        support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n    Facts).'));
   };
   protoOf(MetaInterpreter).z39 = function () {
     return 'interpreter';
@@ -2171,13 +2198,13 @@
     return MetaInterpreter_instance;
   }
   function ModuleCalls() {
-    this.y3d_1 = 'prolog.argumentation.modularity';
+    this.a3e_1 = 'prolog.argumentation.modularity';
   }
   protoOf(ModuleCalls).y2b = function () {
-    return this.y3d_1;
+    return this.a3e_1;
   };
   protoOf(ModuleCalls).y39 = function () {
-    return Companion_getInstance_2().of(this.y3d_1, mapOf(to(ModuleCall_getInstance().z3d_1, ModuleCall_getInstance())));
+    return Companion_getInstance_2().of(this.a3e_1, mapOf(to(ModuleCall_getInstance().b3e_1, ModuleCall_getInstance())));
   };
   protoOf(ModuleCalls).z39 = function () {
     return 'module';
@@ -2205,9 +2232,9 @@
     return logicProgramming_0(VOID, ModuleCall$getCleanSolver$lambda_0(context, modules, module_0));
   }
   function ModuleCall$solve$slambda($solver, $goal, $request, resultContinuation) {
-    this.i3e_1 = $solver;
-    this.j3e_1 = $goal;
-    this.k3e_1 = $request;
+    this.k3e_1 = $solver;
+    this.l3e_1 = $goal;
+    this.m3e_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(ModuleCall$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -2228,8 +2255,8 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp_0 = this.i3e_1.solve(this.j3e_1);
-            suspendResult = this.l3e_1.sc(map(tmp_0, ModuleCall$solve$slambda$lambda(this.k3e_1)), this);
+            var tmp_0 = this.k3e_1.solve(this.l3e_1);
+            suspendResult = this.n3e_1.sc(map(tmp_0, ModuleCall$solve$slambda$lambda(this.m3e_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -2252,8 +2279,8 @@
      while (true);
   };
   protoOf(ModuleCall$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new ModuleCall$solve$slambda(this.i3e_1, this.j3e_1, this.k3e_1, completion);
-    i.l3e_1 = $this$sequence;
+    var i = new ModuleCall$solve$slambda(this.k3e_1, this.l3e_1, this.m3e_1, completion);
+    i.n3e_1 = $this$sequence;
     return i;
   };
   function ModuleCall$solve$slambda_0($solver, $goal, $request, resultContinuation) {
@@ -2301,7 +2328,7 @@
   }
   function ModuleCall() {
     ModuleCall_instance = this;
-    this.z3d_1 = new Signature('call_module', 2);
+    this.b3e_1 = new Signature('call_module', 2);
   }
   protoOf(ModuleCall).g2e = function (request) {
     var modules = request.arguments.w(0);
@@ -2337,10 +2364,10 @@
   }
   function ModulesPath() {
   }
-  protoOf(ModulesPath).t3d = function () {
+  protoOf(ModulesPath).v3d = function () {
     return 'modulesPath';
   };
-  protoOf(ModulesPath).w3d = function () {
+  protoOf(ModulesPath).y3d = function () {
     return 'none';
   };
   var ModulesPath_instance;
@@ -2349,11 +2376,11 @@
   }
   function AbstractModeBase() {
     LazyRawPrologContent.call(this);
-    this.n3e_1 = 'prolog.argumentation.abstract';
-    this.o3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.p3e_1 = 'prolog.argumentation.abstract';
+    this.q3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(AbstractModeBase).y2b = function () {
-    return this.n3e_1;
+    return this.p3e_1;
   };
   protoOf(AbstractModeBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2362,14 +2389,14 @@
     return 'abstract';
   };
   protoOf(AbstractModeBase).i39 = function () {
-    return this.o3e_1;
+    return this.q3e_1;
   };
   function GraphExtension() {
   }
-  protoOf(GraphExtension).t3d = function () {
+  protoOf(GraphExtension).v3d = function () {
     return 'graphExtension';
   };
-  protoOf(GraphExtension).w3d = function () {
+  protoOf(GraphExtension).y3d = function () {
     return listOf_0('standardPref');
   };
   var GraphExtension_instance;
@@ -2378,10 +2405,10 @@
   }
   function ArgumentLabellingMode() {
   }
-  protoOf(ArgumentLabellingMode).t3d = function () {
+  protoOf(ArgumentLabellingMode).v3d = function () {
     return 'argumentLabellingMode';
   };
-  protoOf(ArgumentLabellingMode).w3d = function () {
+  protoOf(ArgumentLabellingMode).y3d = function () {
     return 'grounded';
   };
   var ArgumentLabellingMode_instance;
@@ -2390,10 +2417,10 @@
   }
   function StatementLabellingMode() {
   }
-  protoOf(StatementLabellingMode).t3d = function () {
+  protoOf(StatementLabellingMode).v3d = function () {
     return 'statementLabellingMode';
   };
-  protoOf(StatementLabellingMode).w3d = function () {
+  protoOf(StatementLabellingMode).y3d = function () {
     return 'statement';
   };
   var StatementLabellingMode_instance;
@@ -2402,10 +2429,10 @@
   }
   function GraphBuildMode() {
   }
-  protoOf(GraphBuildMode).t3d = function () {
+  protoOf(GraphBuildMode).v3d = function () {
     return 'graphBuildMode';
   };
-  protoOf(GraphBuildMode).w3d = function () {
+  protoOf(GraphBuildMode).y3d = function () {
     return 'standard_af';
   };
   var GraphBuildMode_instance;
@@ -2414,11 +2441,11 @@
   }
   function ArgumentationGraphBuilderBase() {
     LazyRawPrologContent.call(this);
-    this.q3e_1 = 'prolog.argumentation.graph';
-    this.r3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.s3e_1 = 'prolog.argumentation.graph';
+    this.t3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(ArgumentationGraphBuilderBase).y2b = function () {
-    return this.q3e_1;
+    return this.s3e_1;
   };
   protoOf(ArgumentationGraphBuilderBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2427,15 +2454,15 @@
     return 'standard_af';
   };
   protoOf(ArgumentationGraphBuilderBase).i39 = function () {
-    return this.r3e_1;
+    return this.t3e_1;
   };
   function AttackRestrictionHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.t3e_1 = 'prolog.argumentation.graph.rebutrestriction';
-    this.u3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.v3e_1 = 'prolog.argumentation.graph.rebutrestriction';
+    this.w3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(AttackRestrictionHandlerBase).y2b = function () {
-    return this.t3e_1;
+    return this.v3e_1;
   };
   protoOf(AttackRestrictionHandlerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2444,15 +2471,15 @@
     return 'rebutRestriction';
   };
   protoOf(AttackRestrictionHandlerBase).i39 = function () {
-    return this.u3e_1;
+    return this.w3e_1;
   };
   function BpMetaGraphHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.w3e_1 = 'prolog.argumentation.graph.meta.bp';
-    this.x3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.y3e_1 = 'prolog.argumentation.graph.meta.bp';
+    this.z3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpMetaGraphHandlerBase).y2b = function () {
-    return this.w3e_1;
+    return this.y3e_1;
   };
   protoOf(BpMetaGraphHandlerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2461,15 +2488,15 @@
     return 'bp';
   };
   protoOf(BpMetaGraphHandlerBase).i39 = function () {
-    return this.x3e_1;
+    return this.z3e_1;
   };
   function DefeasiblePreferencesHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.z3e_1 = 'prolog.argumentation.graph.preferences.defeasible';
-    this.a3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.b3f_1 = 'prolog.argumentation.graph.preferences.defeasible';
+    this.c3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(DefeasiblePreferencesHandlerBase).y2b = function () {
-    return this.z3e_1;
+    return this.b3f_1;
   };
   protoOf(DefeasiblePreferencesHandlerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2478,15 +2505,15 @@
     return 'defeasiblePref';
   };
   protoOf(DefeasiblePreferencesHandlerBase).i39 = function () {
-    return this.a3f_1;
+    return this.c3f_1;
   };
   function GenericDefeasiblePreferencesHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.c3f_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
-    this.d3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.e3f_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
+    this.f3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(GenericDefeasiblePreferencesHandlerBase).y2b = function () {
-    return this.c3f_1;
+    return this.e3f_1;
   };
   protoOf(GenericDefeasiblePreferencesHandlerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2495,15 +2522,15 @@
     return 'defeasibleAllPref';
   };
   protoOf(GenericDefeasiblePreferencesHandlerBase).i39 = function () {
-    return this.d3f_1;
+    return this.f3f_1;
   };
   function StrictPreferencesHandlerBase() {
     LazyRawPrologContent.call(this);
-    this.f3f_1 = 'prolog.argumentation.graph.preferences.strict';
-    this.g3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.h3f_1 = 'prolog.argumentation.graph.preferences.strict';
+    this.i3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(StrictPreferencesHandlerBase).y2b = function () {
-    return this.f3f_1;
+    return this.h3f_1;
   };
   protoOf(StrictPreferencesHandlerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2512,24 +2539,52 @@
     return 'standardPref';
   };
   protoOf(StrictPreferencesHandlerBase).i39 = function () {
-    return this.g3f_1;
+    return this.i3f_1;
+  };
+  function AdmissibleLabeller() {
+    AdmissibleLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.k3f_1 = 'prolog.argumentation.graph.labelling.admissible';
+    this.l3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.m3f_1 = 'argumentLabelling :-\n    conflictfree::argumentLabelling,\n    admissibleSet.\n\nadmissibleSet :-\n    \\+ (context_check(inId(H)), \\+ admissible(H)).\nadmissible(H) :-\n    \\+ (\n        context_check(clause(att(Attacker, H), _)),\n        \\+ (\n            context_check(clause(att(Defendant, Attacker), _)),\n            context_check(inId(Defendant)),\n            Defendant \\= Attacker\n        )\n    ).';
+  }
+  protoOf(AdmissibleLabeller).y2b = function () {
+    return this.k3f_1;
+  };
+  protoOf(AdmissibleLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.k3f_1, VOID, this.c3a());
+  };
+  protoOf(AdmissibleLabeller).z39 = function () {
+    return 'admissible';
   };
+  protoOf(AdmissibleLabeller).i39 = function () {
+    return this.l3f_1;
+  };
+  protoOf(AdmissibleLabeller).b3a = function () {
+    return this.m3f_1;
+  };
+  var AdmissibleLabeller_instance;
+  function AdmissibleLabeller_getInstance() {
+    if (AdmissibleLabeller_instance == null)
+      new AdmissibleLabeller();
+    return AdmissibleLabeller_instance;
+  }
   function BinaryStatementLabeller() {
     BinaryStatementLabeller_instance = this;
-    this.h3f_1 = 'prolog.argumentation.graph.labelling.statement.binary';
-    this.i3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.n3f_1 = 'prolog.argumentation.graph.labelling.statement.binary';
+    this.o3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BinaryStatementLabeller).y2b = function () {
-    return this.h3f_1;
+    return this.n3f_1;
   };
   protoOf(BinaryStatementLabeller).y39 = function () {
-    return Companion_getInstance_2().of(this.h3f_1, VOID, Companion_instance_0.ofWithDefaultUnificator([BinaryLabelling_getInstance().n1s()]));
+    return Companion_getInstance_2().of(this.n3f_1, VOID, Companion_instance_0.ofWithDefaultUnificator([BinaryLabelling_getInstance().n1s()]));
   };
   protoOf(BinaryStatementLabeller).z39 = function () {
     return 'statement_binary';
   };
   protoOf(BinaryStatementLabeller).i39 = function () {
-    return this.i3f_1;
+    return this.o3f_1;
   };
   var BinaryStatementLabeller_instance;
   function BinaryStatementLabeller_getInstance() {
@@ -2555,11 +2610,11 @@
   }
   function BpCompleteLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.n3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
-    this.o3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.t3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
+    this.u3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpCompleteLabellerBase).y2b = function () {
-    return this.n3f_1;
+    return this.t3f_1;
   };
   protoOf(BpCompleteLabellerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2568,15 +2623,15 @@
     return 'bp_grounded_complete';
   };
   protoOf(BpCompleteLabellerBase).i39 = function () {
-    return this.o3f_1;
+    return this.u3f_1;
   };
   function BpLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.q3f_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
-    this.r3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.w3f_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
+    this.x3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpLabellerBase).y2b = function () {
-    return this.q3f_1;
+    return this.w3f_1;
   };
   protoOf(BpLabellerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2585,15 +2640,15 @@
     return 'bp_grounded';
   };
   protoOf(BpLabellerBase).i39 = function () {
-    return this.r3f_1;
+    return this.x3f_1;
   };
   function BpPartialLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.t3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
-    this.u3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.z3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
+    this.a3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(BpPartialLabellerBase).y2b = function () {
-    return this.t3f_1;
+    return this.z3f_1;
   };
   protoOf(BpPartialLabellerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2602,15 +2657,43 @@
     return 'bp_grounded_partial';
   };
   protoOf(BpPartialLabellerBase).i39 = function () {
-    return this.u3f_1;
+    return this.a3g_1;
   };
+  function Cf2Labeller() {
+    Cf2Labeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.c3g_1 = 'prolog.argumentation.graph.labelling.cf2';
+    this.d3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.e3g_1 = 'argumentLabelling :-\n    compute(naive).\n\ncompute(Base) :-\n    findall(A, context_check(clause(arg(A), _)), Args),\n    computeScc(Args, Scc),\n    context_active(Branch),\n    context_branch(Branch, NewBranch),\n    context_retract(arg(_) :- argument(_)),\n    computeIteratively(Base, Branch, Scc).\n\ncomputeIteratively(_, _, []).\ncomputeIteratively(Base, OriginBranch, Scc) :-\n    once(getNext(Scc, Next, Others)),\n    context_active(Branch),\n    context_branch(Branch, NewBranch),\n    moveArgs(Next, OriginBranch),\n    Base::argumentLabelling,\n    computeIteratively(Base, OriginBranch, Others).\n\ngetNext(Scc, X, Others) :-\n    member(X, Scc),\n    utils::subtract(Scc, [X], Others),   \n    utils::appendLists(Others, FO),\n    \\+ (\n        member(Y, X),\n        context_check(clause(att(A, Y), _)),\n        member(A, FO)\n    ).\n  \nmoveArgs([], _).\nmoveArgs([H|T], Branch) :-\n    context_check(Branch, clause(arg(H), argument(HA))),\n    context_assert(arg(H) :- argument(HA)),\n    moveArgs(T, Branch).\n    \ncomputeScc(T, MScc) :-\n    findall(R, scc(T, [], R), Scc),\n    findall(S, (member(S, Scc), check_maximal(S, Scc)), MScc).\n    \ncheck_maximal(S, All) :-\n    \\+ (\n        member(S1, All),\n        S \\== S1,\n        \\+ (\n            member(Y, S), \n            \\+ member(Y, S1)\n        )\n    ).\n\nscc([], L, L) :- stronglyConnected(L).\nscc([H|Others], T, R) :- scc(Others, [H|T], R). \nscc([_|Others], T, R) :- scc(Others, T, R).\n\nstronglyConnected(T) :-\n    \\+ (\n       member(X, T),\n       member(Y, T),\n       \\+ once(reach(X, Y, [X], T))\n    ).\n\nreach(X, X, _, _) :- !.\nreach(X, Y, P, S) :- \n    context_check(clause(att(X, X1), _)),\n    member(X1, S),\n    \\+ member(X1, P),\n    reach(X1, Y, [X1|P], S).\n';
+  }
+  protoOf(Cf2Labeller).y2b = function () {
+    return this.c3g_1;
+  };
+  protoOf(Cf2Labeller).y39 = function () {
+    return Companion_getInstance_2().of(this.c3g_1, VOID, this.c3a());
+  };
+  protoOf(Cf2Labeller).z39 = function () {
+    return 'cf2';
+  };
+  protoOf(Cf2Labeller).i39 = function () {
+    return this.d3g_1;
+  };
+  protoOf(Cf2Labeller).b3a = function () {
+    return this.e3g_1;
+  };
+  var Cf2Labeller_instance;
+  function Cf2Labeller_getInstance() {
+    if (Cf2Labeller_instance == null)
+      new Cf2Labeller();
+    return Cf2Labeller_instance;
+  }
   function CompleteLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.w3f_1 = 'prolog.argumentation.graph.labelling.complete';
-    this.x3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.g3g_1 = 'prolog.argumentation.graph.labelling.complete';
+    this.h3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(CompleteLabellerBase).y2b = function () {
-    return this.w3f_1;
+    return this.g3g_1;
   };
   protoOf(CompleteLabellerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2619,58 +2702,170 @@
     return 'complete';
   };
   protoOf(CompleteLabellerBase).i39 = function () {
-    return this.x3f_1;
+    return this.h3g_1;
+  };
+  function ConflictFreeLabeller() {
+    ConflictFreeLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.j3g_1 = 'prolog.argumentation.graph.labelling.conflictfree';
+    this.k3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.l3g_1 = 'argumentLabelling :-\n    context_active(Branch),\n    conflictFreeLabelling(Branch).\n\nconflictFreeLabelling(Branch) :-\n    findall(A, context_check(clause(arg(A), _)), Args),\n    combinations(Branch, Args, TentativeSet),\n    conflictFreeSet(TentativeSet),\n    context_branch(Branch, _),\n    findall(_, (\n        member(IdA, TentativeSet),    \n        context_check(clause(arg(IdA), argument(A))),\n        context_assert(in(A)),\n        context_assert(inId(IdA))\n    ), _),\n    finalizeLabelling.\n\ncombinations(_, [], []).\ncombinations(Branch, [H|T], [H|RT]) :- combinations(Branch, T, RT).\ncombinations(Branch, [H|T], RT) :- \\+ context_check(Branch, inId(H)), combinations(Branch, T, RT).\n\nconflictFreeSet(TentativeSet) :-\n    \\+ (\n        member(A, TentativeSet), \n        member(B, TentativeSet),\n        context_check(clause(att(A, B), _))\n    ).\n    \nfinalizeLabelling :-\n    findall(_, (\n       argument_to_evaluate(X, IdX),\n       context_check(clause(att(IdY, IdX), _)),\n       context_check(inId(IdY)),\n       context_assert(out(X)),\n       context_assert(outId(IdX))\n    ), _),\n    findall(_, (\n       argument_to_evaluate(X, IdX),\n       context_assert(und(X)),\n       context_assert(undId(IdX))\n    ), _).\n    \nargument_to_evaluate(X, IdX) :-\n    context_check(clause(arg(IdX), argument(X))),\n    \\+ context_check(outId(IdX)),\n    \\+ context_check(inId(IdX)).\n';
+  }
+  protoOf(ConflictFreeLabeller).y2b = function () {
+    return this.j3g_1;
+  };
+  protoOf(ConflictFreeLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.j3g_1, VOID, this.c3a());
+  };
+  protoOf(ConflictFreeLabeller).z39 = function () {
+    return 'conflictfree';
+  };
+  protoOf(ConflictFreeLabeller).i39 = function () {
+    return this.k3g_1;
+  };
+  protoOf(ConflictFreeLabeller).b3a = function () {
+    return this.l3g_1;
   };
+  var ConflictFreeLabeller_instance;
+  function ConflictFreeLabeller_getInstance() {
+    if (ConflictFreeLabeller_instance == null)
+      new ConflictFreeLabeller();
+    return ConflictFreeLabeller_instance;
+  }
+  function EagerLabeller() {
+    EagerLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.n3g_1 = 'prolog.argumentation.graph.labelling.eager';
+    this.o3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.p3g_1 = 'argumentLabelling :-\n    findall(In, (\n        semistable:::argumentLabelling,\n        context_active(Branch),\n        cache_check(complete(In, _, _, Branch))\n    ), Results),\n    utils::intersection(Results, Int),\n    utils::sort(Int, SortedInt),\n    cache_check(complete(SortedInt, _, _, Branch)),\n    context_checkout(Branch).';
+  }
+  protoOf(EagerLabeller).y2b = function () {
+    return this.n3g_1;
+  };
+  protoOf(EagerLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.n3g_1, VOID, this.c3a());
+  };
+  protoOf(EagerLabeller).z39 = function () {
+    return 'eager';
+  };
+  protoOf(EagerLabeller).i39 = function () {
+    return this.o3g_1;
+  };
+  protoOf(EagerLabeller).b3a = function () {
+    return this.p3g_1;
+  };
+  var EagerLabeller_instance;
+  function EagerLabeller_getInstance() {
+    if (EagerLabeller_instance == null)
+      new EagerLabeller();
+    return EagerLabeller_instance;
+  }
   function GroundedLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.z3f_1 = 'prolog.argumentation.graph.labelling.grounded';
-    this.a3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.r3g_1 = 'prolog.argumentation.graph.labelling.grounded.old';
+    this.s3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(GroundedLabellerBase).y2b = function () {
-    return this.z3f_1;
+    return this.r3g_1;
   };
   protoOf(GroundedLabellerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
   protoOf(GroundedLabellerBase).z39 = function () {
-    return 'grounded';
+    return 'grounded_old';
   };
   protoOf(GroundedLabellerBase).i39 = function () {
-    return this.a3g_1;
+    return this.s3g_1;
   };
   function GroundedLabellerOptimizedBase() {
     LazyRawPrologContent.call(this);
-    this.c3g_1 = 'prolog.argumentation.graph.labelling.grounded.optimized';
-    this.d3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.u3g_1 = 'prolog.argumentation.graph.labelling.grounded';
+    this.v3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(GroundedLabellerOptimizedBase).y2b = function () {
-    return this.c3g_1;
+    return this.u3g_1;
   };
   protoOf(GroundedLabellerOptimizedBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
   };
   protoOf(GroundedLabellerOptimizedBase).z39 = function () {
-    return 'grounded_hash';
+    return 'grounded';
   };
   protoOf(GroundedLabellerOptimizedBase).i39 = function () {
-    return this.d3g_1;
+    return this.v3g_1;
+  };
+  function IdealLabeller() {
+    IdealLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.x3g_1 = 'prolog.argumentation.graph.labelling.ideal';
+    this.y3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.z3g_1 = 'argumentLabelling :-\n    findall(In, (\n        preferred:::argumentLabelling,\n        context_active(Branch),\n        cache_check(complete(In, _, _, Branch))\n    ), Results),\n    utils::intersection(Results, Int),\n    utils::sort(Int, SortedInt),\n    cache_check(complete(SortedInt, _, _, Branch)),\n    context_checkout(Branch).';
+  }
+  protoOf(IdealLabeller).y2b = function () {
+    return this.x3g_1;
+  };
+  protoOf(IdealLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.x3g_1, VOID, this.c3a());
+  };
+  protoOf(IdealLabeller).z39 = function () {
+    return 'ideal';
+  };
+  protoOf(IdealLabeller).i39 = function () {
+    return this.y3g_1;
+  };
+  protoOf(IdealLabeller).b3a = function () {
+    return this.z3g_1;
+  };
+  var IdealLabeller_instance;
+  function IdealLabeller_getInstance() {
+    if (IdealLabeller_instance == null)
+      new IdealLabeller();
+    return IdealLabeller_instance;
+  }
+  function NaiveLabeller() {
+    NaiveLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.b3h_1 = 'prolog.argumentation.graph.labelling.naive';
+    this.c3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.d3h_1 = 'argumentLabelling :-\n    cache_retract(naive(_, _, _, _)),\n    conflictfree::argumentLabelling,\n    maximalConflictFreeSet,\n    utils::recoverArgumentLabellingId(In, Out, Und),\n    \\+ cache_check(naive(In, Out, Und, _)),\n    context_active(Branch),\n    cache_assert(naive(In, Out, Und, Branch)).\n    \n    \nmaximalConflictFreeSet :-\n    \\+ (\n        context_check(clause(arg(IdX), _)),\n        \\+ context_check(inId(IdX)),\n        \\+ (\n            (context_check(clause(att(IdX, IdY), _));context_check(clause(att(IdY, IdX), _))),\n            context_check(inId(IdY))\n        )\n    ).';
+  }
+  protoOf(NaiveLabeller).y2b = function () {
+    return this.b3h_1;
+  };
+  protoOf(NaiveLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.b3h_1, VOID, this.c3a());
+  };
+  protoOf(NaiveLabeller).z39 = function () {
+    return 'naive';
+  };
+  protoOf(NaiveLabeller).i39 = function () {
+    return this.c3h_1;
   };
+  protoOf(NaiveLabeller).b3a = function () {
+    return this.d3h_1;
+  };
+  var NaiveLabeller_instance;
+  function NaiveLabeller_getInstance() {
+    if (NaiveLabeller_instance == null)
+      new NaiveLabeller();
+    return NaiveLabeller_instance;
+  }
   function PassThroughStatementLabeller() {
     PassThroughStatementLabeller_instance = this;
-    this.e3g_1 = 'prolog.argumentation.graph.labelling.statement.pt';
-    this.f3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.e3h_1 = 'prolog.argumentation.graph.labelling.statement.pt';
+    this.f3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(PassThroughStatementLabeller).y2b = function () {
-    return this.e3g_1;
+    return this.e3h_1;
   };
   protoOf(PassThroughStatementLabeller).y39 = function () {
-    return Companion_getInstance_2().of(this.e3g_1, VOID, Companion_instance_0.ofWithDefaultUnificator([Labelling_getInstance().n1s()]));
+    return Companion_getInstance_2().of(this.e3h_1, VOID, Companion_instance_0.ofWithDefaultUnificator([Labelling_getInstance().n1s()]));
   };
   protoOf(PassThroughStatementLabeller).z39 = function () {
     return 'statement_pass_through';
   };
   protoOf(PassThroughStatementLabeller).i39 = function () {
-    return this.f3g_1;
+    return this.f3h_1;
   };
   var PassThroughStatementLabeller_instance;
   function PassThroughStatementLabeller_getInstance() {
@@ -2694,13 +2889,153 @@
       new Labelling();
     return Labelling_instance;
   }
+  function PreferredLabeller() {
+    PreferredLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.k3h_1 = 'prolog.argumentation.graph.labelling.preferred';
+    this.l3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.m3h_1 = 'argumentLabelling :-\n    findall(_, complete:::argumentLabelling, _),\n    findall((In, Out, Und, Branch), (\n        cache_check(complete(In, Out, Und, Branch))\n    ), Results),\n    filter(Results, Results, Filtered),\n    member(X, Filtered),\n    context_checkout(X).\n\nfilter([], _, []).\nfilter([(In, _, _, Branch)|T], All, [Branch|RT]) :-\n    check_maximal(In, All), !,\n    filter(T, All, RT).\nfilter([_|T], All, RT) :-\n    filter(T, All, RT).\n    \ncheck_maximal(In, All) :-\n    \\+ (\n        member((X, _, _, _), All),\n        In \\== X,\n        \\+ (\n            member(Y, In), \n            \\+ member(Y, X)\n        )\n    ).';
+  }
+  protoOf(PreferredLabeller).y2b = function () {
+    return this.k3h_1;
+  };
+  protoOf(PreferredLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.k3h_1, VOID, this.c3a());
+  };
+  protoOf(PreferredLabeller).z39 = function () {
+    return 'preferred';
+  };
+  protoOf(PreferredLabeller).i39 = function () {
+    return this.l3h_1;
+  };
+  protoOf(PreferredLabeller).b3a = function () {
+    return this.m3h_1;
+  };
+  var PreferredLabeller_instance;
+  function PreferredLabeller_getInstance() {
+    if (PreferredLabeller_instance == null)
+      new PreferredLabeller();
+    return PreferredLabeller_instance;
+  }
+  function SemistableLabeller() {
+    SemistableLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.o3h_1 = 'prolog.argumentation.graph.labelling.semistable';
+    this.p3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.q3h_1 = 'argumentLabelling :-\n    findall(_, complete:::argumentLabelling, _),\n    findall((In, Out, Und, Branch), (\n        cache_check(complete(In, Out, Und, Branch))\n    ), Results),\n    filter(Results, Results, Filtered),\n    member(X, Filtered),\n    context_checkout(X).\n\nfilter([], _, []).\nfilter([(_, _, Und, Branch)|T], All, [Branch|RT]) :-\n    check_minimal(Und, All), !,\n    filter(T, All, RT).\nfilter([_|T], All, RT) :-\n    filter(T, All, RT).\n    \ncheck_minimal(Und, All) :-\n    \\+ (\n        member((_, _, X, _), All),\n        Und \\== X,\n        \\+ (\n            member(Z, X),\n            \\+ member(Z, Und)\n        )\n    ).';
+  }
+  protoOf(SemistableLabeller).y2b = function () {
+    return this.o3h_1;
+  };
+  protoOf(SemistableLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.o3h_1, VOID, this.c3a());
+  };
+  protoOf(SemistableLabeller).z39 = function () {
+    return 'semistable';
+  };
+  protoOf(SemistableLabeller).i39 = function () {
+    return this.p3h_1;
+  };
+  protoOf(SemistableLabeller).b3a = function () {
+    return this.q3h_1;
+  };
+  var SemistableLabeller_instance;
+  function SemistableLabeller_getInstance() {
+    if (SemistableLabeller_instance == null)
+      new SemistableLabeller();
+    return SemistableLabeller_instance;
+  }
+  function StableLabeller() {
+    StableLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.s3h_1 = 'prolog.argumentation.graph.labelling.stable';
+    this.t3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.u3h_1 = 'argumentLabelling :-\n    findall(_, complete:::argumentLabelling, _),\n    findall((In, Out, Und, Branch), (\n        cache_check(complete(In, Out, Und, Branch))\n    ), Results),\n    filter(Results, Results, Filtered),\n    member(X, Filtered),\n    context_checkout(X).\n\nfilter([], _, []).\nfilter([(_, _, [], Branch)|T], All, [Branch|RT]) :- !,\n    filter(T, All, RT).\nfilter([_|T], All, RT) :-\n    filter(T, All, RT).\n ';
+  }
+  protoOf(StableLabeller).y2b = function () {
+    return this.s3h_1;
+  };
+  protoOf(StableLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.s3h_1, VOID, this.c3a());
+  };
+  protoOf(StableLabeller).z39 = function () {
+    return 'stable';
+  };
+  protoOf(StableLabeller).i39 = function () {
+    return this.t3h_1;
+  };
+  protoOf(StableLabeller).b3a = function () {
+    return this.u3h_1;
+  };
+  var StableLabeller_instance;
+  function StableLabeller_getInstance() {
+    if (StableLabeller_instance == null)
+      new StableLabeller();
+    return StableLabeller_instance;
+  }
+  function Stage2Labeller() {
+    Stage2Labeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.w3h_1 = 'prolog.argumentation.graph.labelling.stage2';
+    this.x3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.y3h_1 = 'argumentLabelling :-\n    cf2::compute(stage).\n';
+  }
+  protoOf(Stage2Labeller).y2b = function () {
+    return this.w3h_1;
+  };
+  protoOf(Stage2Labeller).y39 = function () {
+    return Companion_getInstance_2().of(this.w3h_1, VOID, this.c3a());
+  };
+  protoOf(Stage2Labeller).z39 = function () {
+    return 'stage2';
+  };
+  protoOf(Stage2Labeller).i39 = function () {
+    return this.x3h_1;
+  };
+  protoOf(Stage2Labeller).b3a = function () {
+    return this.y3h_1;
+  };
+  var Stage2Labeller_instance;
+  function Stage2Labeller_getInstance() {
+    if (Stage2Labeller_instance == null)
+      new Stage2Labeller();
+    return Stage2Labeller_instance;
+  }
+  function StageLabeller() {
+    StageLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.a3i_1 = 'prolog.argumentation.graph.labelling.stage';
+    this.b3i_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.c3i_1 = 'argumentLabelling :-\n    findall(_, naive:::argumentLabelling, _),\n    findall((In, Out, Und, Branch), (\n        cache_check(naive(In, Out, Und, Branch))\n    ), Results),\n    filter(Results, Results, Filtered),\n    member(X, Filtered),\n    context_checkout(X).\n\nfilter([], _, []).\nfilter([(_, _, Und, Branch)|T], All, [Branch|RT]) :-\n    check_minimal(Und, All), !,\n    filter(T, All, RT).\nfilter([_|T], All, RT) :-\n    filter(T, All, RT).\n    \ncheck_minimal(Und, All) :-\n    \\+ (\n        member((_, _, X, _), All),\n        Und \\== X,\n        \\+ (\n            member(Z, X),\n            \\+ member(Z, Und)\n        )\n    ).';
+  }
+  protoOf(StageLabeller).y2b = function () {
+    return this.a3i_1;
+  };
+  protoOf(StageLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.a3i_1, VOID, this.c3a());
+  };
+  protoOf(StageLabeller).z39 = function () {
+    return 'stage';
+  };
+  protoOf(StageLabeller).i39 = function () {
+    return this.b3i_1;
+  };
+  protoOf(StageLabeller).b3a = function () {
+    return this.c3i_1;
+  };
+  var StageLabeller_instance;
+  function StageLabeller_getInstance() {
+    if (StageLabeller_instance == null)
+      new StageLabeller();
+    return StageLabeller_instance;
+  }
   function StatementLabellerBase() {
     LazyRawPrologContent.call(this);
-    this.k3g_1 = 'prolog.argumentation.graph.labelling.statement';
-    this.l3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.e3i_1 = 'prolog.argumentation.graph.labelling.statement';
+    this.f3i_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(StatementLabellerBase).y2b = function () {
-    return this.k3g_1;
+    return this.e3i_1;
   };
   protoOf(StatementLabellerBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -2709,8 +3044,36 @@
     return 'statement';
   };
   protoOf(StatementLabellerBase).i39 = function () {
-    return this.l3g_1;
+    return this.f3i_1;
+  };
+  function StronglyAdmissibleLabeller() {
+    StronglyAdmissibleLabeller_instance = this;
+    LazyRawPrologContent.call(this);
+    this.h3i_1 = 'prolog.argumentation.graph.labelling.stronglyadmissible';
+    this.i3i_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.j3i_1 = 'argumentLabelling :-\n    admissible::argumentLabelling,\n    stronglyAdmissibleSet.\n\nstronglyAdmissibleSet :-\n    context_active(Branch),\n    \\+ (context_check(inId(H)), \\+ stronglyAdmissible(Branch, H)),\n    context_checkout(Branch).\nstronglyAdmissible(Branch, H) :-\n    context_branch(Branch, _),\n    context_retract(inId(H)),\n    admissible::admissible(H).';
+  }
+  protoOf(StronglyAdmissibleLabeller).y2b = function () {
+    return this.h3i_1;
+  };
+  protoOf(StronglyAdmissibleLabeller).y39 = function () {
+    return Companion_getInstance_2().of(this.h3i_1, VOID, this.c3a());
+  };
+  protoOf(StronglyAdmissibleLabeller).z39 = function () {
+    return 'stronglyadmissible';
   };
+  protoOf(StronglyAdmissibleLabeller).i39 = function () {
+    return this.i3i_1;
+  };
+  protoOf(StronglyAdmissibleLabeller).b3a = function () {
+    return this.j3i_1;
+  };
+  var StronglyAdmissibleLabeller_instance;
+  function StronglyAdmissibleLabeller_getInstance() {
+    if (StronglyAdmissibleLabeller_instance == null)
+      new StronglyAdmissibleLabeller();
+    return StronglyAdmissibleLabeller_instance;
+  }
   function Companion_2() {
   }
   protoOf(Companion_2).d39 = function () {
@@ -2771,11 +3134,11 @@
   }
   function RuleParserBase() {
     LazyRawPrologContent.call(this);
-    this.n3g_1 = 'prolog.argumentation.parser';
-    this.o3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_instance_10.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.l3i_1 = 'prolog.argumentation.parser';
+    this.m3i_1 = Companion_instance_8.d39().plusOperatorSet(Companion_instance_10.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(RuleParserBase).y2b = function () {
-    return this.n3g_1;
+    return this.l3i_1;
   };
   protoOf(RuleParserBase).y39 = function () {
     var tmp = Companion_getInstance_2();
@@ -2799,7 +3162,7 @@
     return 'parser';
   };
   protoOf(RuleParserBase).i39 = function () {
-    return this.o3g_1;
+    return this.m3i_1;
   };
   function StrictRules$computeAllSubstitutions$lambda($this_computeAllSubstitutions) {
     return function (clauses, prologScope) {
@@ -2819,7 +3182,7 @@
       var _iterator__ex2g4s_0 = destination.p();
       while (_iterator__ex2g4s_0.s()) {
         var item = _iterator__ex2g4s_0.t();
-        var tmp$ret$3 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.p3g(item, $this_computeAllSubstitutions), ensureNotNull(item.nw())]);
+        var tmp$ret$3 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.n3i(item, $this_computeAllSubstitutions), ensureNotNull(item.nw())]);
         destination_0.m(tmp$ret$3);
       }
       return listToTerm(destination_0);
@@ -2829,12 +3192,12 @@
     StrictRules_instance = this;
     WithoutSideEffects.call(this, 'prologStrictRules');
   }
-  protoOf(StrictRules).r3g = function (_this__u8e3s4, first) {
+  protoOf(StrictRules).p3i = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.s3g(_this__u8e3s4, first, VOID, StrictRules$computeAllSubstitutions$lambda(_this__u8e3s4));
+    return tmp.q3i(_this__u8e3s4, first, VOID, StrictRules$computeAllSubstitutions$lambda(_this__u8e3s4));
   };
   protoOf(StrictRules).x2g = function (_this__u8e3s4, first) {
-    return this.r3g(_this__u8e3s4, first);
+    return this.p3i(_this__u8e3s4, first);
   };
   var StrictRules_instance;
   function StrictRules_getInstance() {
@@ -2868,12 +3231,12 @@
     Axioms_instance = this;
     WithoutSideEffects.call(this, 'prologAxioms');
   }
-  protoOf(Axioms).r3g = function (_this__u8e3s4, first) {
+  protoOf(Axioms).p3i = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.s3g(_this__u8e3s4, first, VOID, Axioms$computeAllSubstitutions$lambda);
+    return tmp.q3i(_this__u8e3s4, first, VOID, Axioms$computeAllSubstitutions$lambda);
   };
   protoOf(Axioms).x2g = function (_this__u8e3s4, first) {
-    return this.r3g(_this__u8e3s4, first);
+    return this.p3i(_this__u8e3s4, first);
   };
   var Axioms_instance;
   function Axioms_getInstance() {
@@ -2914,12 +3277,12 @@
     Bps_instance = this;
     WithoutSideEffects.call(this, 'bpsNew');
   }
-  protoOf(Bps).r3g = function (_this__u8e3s4, first) {
+  protoOf(Bps).p3i = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.v3g(_this__u8e3s4, first, true, Bps$computeAllSubstitutions$lambda);
+    return tmp.t3i(_this__u8e3s4, first, true, Bps$computeAllSubstitutions$lambda);
   };
   protoOf(Bps).x2g = function (_this__u8e3s4, first) {
-    return this.r3g(_this__u8e3s4, first);
+    return this.p3i(_this__u8e3s4, first);
   };
   var Bps_instance;
   function Bps_getInstance() {
@@ -2953,12 +3316,12 @@
     Premises_instance = this;
     WithoutSideEffects.call(this, 'prologPremises');
   }
-  protoOf(Premises).r3g = function (_this__u8e3s4, first) {
+  protoOf(Premises).p3i = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.s3g(_this__u8e3s4, first, VOID, Premises$computeAllSubstitutions$lambda);
+    return tmp.q3i(_this__u8e3s4, first, VOID, Premises$computeAllSubstitutions$lambda);
   };
   protoOf(Premises).x2g = function (_this__u8e3s4, first) {
-    return this.r3g(_this__u8e3s4, first);
+    return this.p3i(_this__u8e3s4, first);
   };
   var Premises_instance;
   function Premises_getInstance() {
@@ -3024,7 +3387,7 @@
         }
         // Inline function 'kotlin.let' call
         var it = tmp_3;
-        var tmp$ret$6 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.p3g(it, $this_computeAllSubstitutions), ensureNotNull(it.nw())]);
+        var tmp$ret$6 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.n3i(it, $this_computeAllSubstitutions), ensureNotNull(it.nw())]);
         destination_0.m(tmp$ret$6);
       }
       return listToTerm(destination_0);
@@ -3034,12 +3397,12 @@
     DefeasibleRules_instance = this;
     WithoutSideEffects.call(this, 'prologDefeasibleRules');
   }
-  protoOf(DefeasibleRules).r3g = function (_this__u8e3s4, first) {
+  protoOf(DefeasibleRules).p3i = function (_this__u8e3s4, first) {
     var tmp = ConversionUtils_instance;
-    return tmp.s3g(_this__u8e3s4, first, VOID, DefeasibleRules$computeAllSubstitutions$lambda(_this__u8e3s4));
+    return tmp.q3i(_this__u8e3s4, first, VOID, DefeasibleRules$computeAllSubstitutions$lambda(_this__u8e3s4));
   };
   protoOf(DefeasibleRules).x2g = function (_this__u8e3s4, first) {
-    return this.r3g(_this__u8e3s4, first);
+    return this.p3i(_this__u8e3s4, first);
   };
   var DefeasibleRules_instance;
   function DefeasibleRules_getInstance() {
@@ -3120,10 +3483,10 @@
   }
   function AutoTransposition() {
   }
-  protoOf(AutoTransposition).t3d = function () {
+  protoOf(AutoTransposition).v3d = function () {
     return 'autoTransposition';
   };
-  protoOf(AutoTransposition).w3d = function () {
+  protoOf(AutoTransposition).y3d = function () {
     return false;
   };
   var AutoTransposition_instance;
@@ -3132,10 +3495,10 @@
   }
   function PrologStrictCompatibility() {
   }
-  protoOf(PrologStrictCompatibility).t3d = function () {
+  protoOf(PrologStrictCompatibility).v3d = function () {
     return 'prologStrictCompatibility';
   };
-  protoOf(PrologStrictCompatibility).w3d = function () {
+  protoOf(PrologStrictCompatibility).y3d = function () {
     return false;
   };
   var PrologStrictCompatibility_instance;
@@ -3197,16 +3560,16 @@
   }
   function ConversionUtils() {
   }
-  protoOf(ConversionUtils).p3g = function (target, context) {
+  protoOf(ConversionUtils).n3i = function (target, context) {
     return prolog(VOID, ConversionUtils$modifiers$lambda(target, context));
   };
-  protoOf(ConversionUtils).v3g = function (context, first, force, mapper) {
+  protoOf(ConversionUtils).t3i = function (context, first, force, mapper) {
     Companion_getInstance_9().v2e(context, 0);
     return prolog(VOID, ConversionUtils$commonMap$lambda(first, force, context, mapper));
   };
-  protoOf(ConversionUtils).s3g = function (context, first, force, mapper, $super) {
+  protoOf(ConversionUtils).q3i = function (context, first, force, mapper, $super) {
     force = force === VOID ? false : force;
-    return $super === VOID ? this.v3g(context, first, force, mapper) : $super.v3g.call(this, context, first, force, mapper);
+    return $super === VOID ? this.t3i(context, first, force, mapper) : $super.t3i.call(this, context, first, force, mapper);
   };
   var ConversionUtils_instance;
   function ConversionUtils_getInstance() {
@@ -3214,11 +3577,11 @@
   }
   function StructuredModeBase() {
     LazyRawPrologContent.call(this);
-    this.b3h_1 = 'prolog.argumentation.structured';
-    this.c3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.z3i_1 = 'prolog.argumentation.structured';
+    this.a3j_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(StructuredModeBase).y2b = function () {
-    return this.b3h_1;
+    return this.z3i_1;
   };
   protoOf(StructuredModeBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -3227,14 +3590,14 @@
     return 'structured';
   };
   protoOf(StructuredModeBase).i39 = function () {
-    return this.c3h_1;
+    return this.a3j_1;
   };
   function QueryMode() {
   }
-  protoOf(QueryMode).t3d = function () {
+  protoOf(QueryMode).v3d = function () {
     return 'queryMode';
   };
-  protoOf(QueryMode).w3d = function () {
+  protoOf(QueryMode).y3d = function () {
     return true;
   };
   var QueryMode_instance;
@@ -3243,11 +3606,11 @@
   }
   function AttackRelationBase() {
     LazyRawPrologContent.call(this);
-    this.e3h_1 = 'prolog.argumentation.attack';
-    this.f3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.c3j_1 = 'prolog.argumentation.attack';
+    this.d3j_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(AttackRelationBase).y2b = function () {
-    return this.e3h_1;
+    return this.c3j_1;
   };
   protoOf(AttackRelationBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -3256,15 +3619,15 @@
     return 'attack';
   };
   protoOf(AttackRelationBase).i39 = function () {
-    return this.f3h_1;
+    return this.d3j_1;
   };
   function DebugBase() {
     LazyRawPrologContent.call(this);
-    this.h3h_1 = 'prolog.argumentation.debug';
-    this.i3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.f3j_1 = 'prolog.argumentation.debug';
+    this.g3j_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(DebugBase).y2b = function () {
-    return this.h3h_1;
+    return this.f3j_1;
   };
   protoOf(DebugBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -3273,15 +3636,15 @@
     return 'debug';
   };
   protoOf(DebugBase).i39 = function () {
-    return this.i3h_1;
+    return this.g3j_1;
   };
   function SuperiorityRelationBase() {
     LazyRawPrologContent.call(this);
-    this.k3h_1 = 'prolog.argumentation.superiority';
-    this.l3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.i3j_1 = 'prolog.argumentation.superiority';
+    this.j3j_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(SuperiorityRelationBase).y2b = function () {
-    return this.k3h_1;
+    return this.i3j_1;
   };
   protoOf(SuperiorityRelationBase).y39 = function () {
     return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
@@ -3290,14 +3653,14 @@
     return 'superiority';
   };
   protoOf(SuperiorityRelationBase).i39 = function () {
-    return this.l3h_1;
+    return this.j3j_1;
   };
   function OrderingPrinciple() {
   }
-  protoOf(OrderingPrinciple).t3d = function () {
+  protoOf(OrderingPrinciple).v3d = function () {
     return 'orderingPrinciple';
   };
-  protoOf(OrderingPrinciple).w3d = function () {
+  protoOf(OrderingPrinciple).y3d = function () {
     return 'last';
   };
   var OrderingPrinciple_instance;
@@ -3306,10 +3669,10 @@
   }
   function OrderingComparator() {
   }
-  protoOf(OrderingComparator).t3d = function () {
+  protoOf(OrderingComparator).v3d = function () {
     return 'orderingComparator';
   };
-  protoOf(OrderingComparator).w3d = function () {
+  protoOf(OrderingComparator).y3d = function () {
     return 'elitist';
   };
   var OrderingComparator_instance;
@@ -3318,35 +3681,35 @@
   }
   function UtilsBase() {
     LazyRawPrologContent.call(this);
-    this.n3h_1 = 'prolog.argumentation.utils';
-    this.o3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
+    this.l3j_1 = 'prolog.argumentation.utils';
+    this.m3j_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
   }
   protoOf(UtilsBase).y2b = function () {
-    return this.n3h_1;
+    return this.l3j_1;
   };
   protoOf(UtilsBase).y39 = function () {
     var tmp0_$this = Companion_getInstance_2();
     var tmp1_alias = this.y2b();
     var tmp2_clauses = this.c3a();
-    var tmp = to(AppendOptimized_getInstance().p3h_1, AppendOptimized_getInstance());
-    var tmp_0 = to(AssertAll_getInstance().q3h_1, AssertAll_getInstance());
+    var tmp = to(AppendOptimized_getInstance().n3j_1, AppendOptimized_getInstance());
+    var tmp_0 = to(AssertAll_getInstance().o3j_1, AssertAll_getInstance());
     // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.descriptionPair' call
     var this_0 = ArgumentHash_getInstance();
     var tmp$ret$0 = to(this_0.signature, this_0.n1s());
-    var tmp3_primitives = mapOf_0([tmp, tmp_0, tmp$ret$0, to(Contains_getInstance().r3h_1, Contains_getInstance()), to(ContainsAny_getInstance().s3h_1, ContainsAny_getInstance())]);
+    var tmp3_primitives = mapOf_0([tmp, tmp_0, tmp$ret$0, to(Contains_getInstance().p3j_1, Contains_getInstance()), to(ContainsAny_getInstance().q3j_1, ContainsAny_getInstance())]);
     return tmp0_$this.of(tmp1_alias, tmp3_primitives, tmp2_clauses);
   };
   protoOf(UtilsBase).z39 = function () {
     return 'utils';
   };
   protoOf(UtilsBase).i39 = function () {
-    return this.o3h_1;
+    return this.m3j_1;
   };
   function AppendOptimized$solve$slambda($request, $res, $list1, $list2, resultContinuation) {
-    this.b3i_1 = $request;
-    this.c3i_1 = $res;
-    this.d3i_1 = $list1;
-    this.e3i_1 = $list2;
+    this.z3j_1 = $request;
+    this.a3k_1 = $res;
+    this.b3k_1 = $list1;
+    this.c3k_1 = $list2;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(AppendOptimized$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3367,7 +3730,7 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            suspendResult = this.f3i_1.pc(this.b3i_1.replyWith(Companion_getInstance_3().of(this.c3i_1, Companion_instance_6.ofList(plus(this.d3i_1.toList(), this.e3i_1.toList()))), VOID, []), this);
+            suspendResult = this.d3k_1.pc(this.z3j_1.replyWith(Companion_getInstance_3().of(this.a3k_1, Companion_instance_6.ofList(plus(this.b3k_1.toList(), this.c3k_1.toList()))), VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3390,8 +3753,8 @@
      while (true);
   };
   protoOf(AppendOptimized$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new AppendOptimized$solve$slambda(this.b3i_1, this.c3i_1, this.d3i_1, this.e3i_1, completion);
-    i.f3i_1 = $this$sequence;
+    var i = new AppendOptimized$solve$slambda(this.z3j_1, this.a3k_1, this.b3k_1, this.c3k_1, completion);
+    i.d3k_1 = $this$sequence;
     return i;
   };
   function AppendOptimized$solve$slambda_0($request, $res, $list1, $list2, resultContinuation) {
@@ -3404,7 +3767,7 @@
   }
   function AppendOptimized() {
     AppendOptimized_instance = this;
-    this.p3h_1 = new Signature('append_fast', 3);
+    this.n3j_1 = new Signature('append_fast', 3);
   }
   protoOf(AppendOptimized).g2e = function (request) {
     var list1 = request.arguments.w(0);
@@ -3442,7 +3805,7 @@
     };
   }
   function AssertAll$solve$slambda($request, resultContinuation) {
-    this.o3i_1 = $request;
+    this.m3k_1 = $request;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(AssertAll$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3463,7 +3826,7 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            suspendResult = this.p3i_1.pc(this.o3i_1.replyWithCondition(true, VOID, []), this);
+            suspendResult = this.n3k_1.pc(this.m3k_1.replyWithCondition(true, VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3486,8 +3849,8 @@
      while (true);
   };
   protoOf(AssertAll$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new AssertAll$solve$slambda(this.o3i_1, completion);
-    i.p3i_1 = $this$sequence;
+    var i = new AssertAll$solve$slambda(this.m3k_1, completion);
+    i.n3k_1 = $this$sequence;
     return i;
   };
   function AssertAll$solve$slambda_0($request, resultContinuation) {
@@ -3500,7 +3863,7 @@
   }
   function AssertAll() {
     AssertAll_instance = this;
-    this.q3h_1 = new Signature('assert_all', 1);
+    this.o3j_1 = new Signature('assert_all', 1);
   }
   protoOf(AssertAll).g2e = function (request) {
     var list = request.arguments.w(0);
@@ -3536,9 +3899,9 @@
     return ArgumentHash_instance;
   }
   function Contains$solve$slambda($request, $list, $elem, resultContinuation) {
-    this.z3i_1 = $request;
-    this.a3j_1 = $list;
-    this.b3j_1 = $elem;
+    this.x3k_1 = $request;
+    this.y3k_1 = $list;
+    this.z3k_1 = $elem;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(Contains$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3559,7 +3922,7 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp0 = this.a3j_1.toList();
+            var tmp0 = this.y3k_1.toList();
             var tmp$ret$0;
             l$ret$1: do {
               var tmp_0;
@@ -3575,7 +3938,7 @@
               var _iterator__ex2g4s = tmp0.p();
               while (_iterator__ex2g4s.s()) {
                 var element = _iterator__ex2g4s.t();
-                if (Companion_getInstance_1().u1i().match(element, this.b3j_1)) {
+                if (Companion_getInstance_1().u1i().match(element, this.z3k_1)) {
                   tmp$ret$0 = true;
                   break l$ret$1;
                 }
@@ -3583,7 +3946,7 @@
               tmp$ret$0 = false;
             }
              while (false);
-            suspendResult = this.c3j_1.pc(this.z3i_1.replyWithCondition(tmp$ret$0, VOID, []), this);
+            suspendResult = this.a3l_1.pc(this.x3k_1.replyWithCondition(tmp$ret$0, VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3606,8 +3969,8 @@
      while (true);
   };
   protoOf(Contains$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new Contains$solve$slambda(this.z3i_1, this.a3j_1, this.b3j_1, completion);
-    i.c3j_1 = $this$sequence;
+    var i = new Contains$solve$slambda(this.x3k_1, this.y3k_1, this.z3k_1, completion);
+    i.a3l_1 = $this$sequence;
     return i;
   };
   function Contains$solve$slambda_0($request, $list, $elem, resultContinuation) {
@@ -3620,7 +3983,7 @@
   }
   function Contains() {
     Contains_instance = this;
-    this.r3h_1 = new Signature('contains', 2);
+    this.p3j_1 = new Signature('contains', 2);
   }
   protoOf(Contains).g2e = function (request) {
     var elem = request.arguments.w(0);
@@ -3640,9 +4003,9 @@
     return Contains_instance;
   }
   function ContainsAny$solve$slambda($request, $list, $elemList, resultContinuation) {
-    this.l3j_1 = $request;
-    this.m3j_1 = $list;
-    this.n3j_1 = $elemList;
+    this.j3l_1 = $request;
+    this.k3l_1 = $list;
+    this.l3l_1 = $elemList;
     CoroutineImpl.call(this, resultContinuation);
   }
   protoOf(ContainsAny$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3663,13 +4026,13 @@
           case 0:
             this.c8_1 = 2;
             this.b8_1 = 1;
-            var tmp0 = this.m3j_1.xs();
+            var tmp0 = this.k3l_1.xs();
             var tmp$ret$2;
             l$ret$3: do {
               var _iterator__ex2g4s = tmp0.p();
               while (_iterator__ex2g4s.s()) {
                 var element = _iterator__ex2g4s.t();
-                var tmp0_0 = this.n3j_1.xs();
+                var tmp0_0 = this.l3l_1.xs();
                 var tmp$ret$0;
                 l$ret$1: do {
                   var _iterator__ex2g4s_0 = tmp0_0.p();
@@ -3691,7 +4054,7 @@
               tmp$ret$2 = false;
             }
              while (false);
-            suspendResult = this.o3j_1.pc(this.l3j_1.replyWithCondition(tmp$ret$2, VOID, []), this);
+            suspendResult = this.m3l_1.pc(this.j3l_1.replyWithCondition(tmp$ret$2, VOID, []), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -3714,8 +4077,8 @@
      while (true);
   };
   protoOf(ContainsAny$solve$slambda).d2o = function ($this$sequence, completion) {
-    var i = new ContainsAny$solve$slambda(this.l3j_1, this.m3j_1, this.n3j_1, completion);
-    i.o3j_1 = $this$sequence;
+    var i = new ContainsAny$solve$slambda(this.j3l_1, this.k3l_1, this.l3l_1, completion);
+    i.m3l_1 = $this$sequence;
     return i;
   };
   function ContainsAny$solve$slambda_0($request, $list, $elemList, resultContinuation) {
@@ -3728,7 +4091,7 @@
   }
   function ContainsAny() {
     ContainsAny_instance = this;
-    this.s3h_1 = new Signature('contains_any', 2);
+    this.q3j_1 = new Signature('contains_any', 2);
   }
   protoOf(ContainsAny).g2e = function (request) {
     var elemList = request.arguments.w(0);
@@ -3753,7 +4116,7 @@
   function mineGraph(_this__u8e3s4, context) {
     // Inline function 'kotlin.let' call
     var it = mineArguments(_this__u8e3s4, context);
-    return Companion_instance_12.p3j(mineLabels(_this__u8e3s4, context, it), mineAttacks(_this__u8e3s4, context, it), mineSupports(_this__u8e3s4, context, it));
+    return Companion_instance_12.n3l(mineLabels(_this__u8e3s4, context, it), mineAttacks(_this__u8e3s4, context, it), mineSupports(_this__u8e3s4, context, it));
   }
   function mineArguments(_this__u8e3s4, context) {
     return toList(logicProgramming(arguments$lambda(_this__u8e3s4, context)));
@@ -3772,7 +4135,7 @@
         var _iterator__ex2g4s_0 = labels.p();
         while (_iterator__ex2g4s_0.s()) {
           var element = _iterator__ex2g4s_0.t();
-          if (Companion_getInstance_1().u1i().match(item.a3k(), element.fc_1)) {
+          if (Companion_getInstance_1().u1i().match(item.y3l(), element.fc_1)) {
             tmp$ret$1 = element;
             break $l$block;
           }
@@ -3809,22 +4172,22 @@
     };
   }
   function arguments$lambda$lambda_1(solution) {
-    return Companion_instance_11.b3k(solution);
+    return Companion_instance_11.z3l(solution);
   }
   function arguments$lambda$lambda_2(it) {
-    return it.z3j_1.v();
+    return it.x3l_1.v();
   }
   function arguments$lambda$lambda_3(it) {
-    return it.q3j_1.v();
+    return it.o3l_1.v();
   }
   function arguments$lambda$lambda_4(it) {
-    return it.s3j_1;
+    return it.q3l_1;
   }
   function arguments$lambda$lambda_5(it) {
-    return it.r3j_1;
+    return it.p3l_1;
   }
   function arguments$lambda$lambda_6(index, arg) {
-    arg.y3j_1 = 'A' + index;
+    arg.w3l_1 = 'A' + index;
     return arg;
   }
   function arguments$lambda($this_arguments, $context) {
@@ -3857,7 +4220,7 @@
         var _iterator__ex2g4s = tmp0.p();
         while (_iterator__ex2g4s.s()) {
           var element = _iterator__ex2g4s.t();
-          if (Companion_getInstance_1().u1i().match(element.a3k(), solution.fc_1)) {
+          if (Companion_getInstance_1().u1i().match(element.y3l(), solution.fc_1)) {
             tmp$ret$1 = element;
             break $l$block;
           }
@@ -3872,7 +4235,7 @@
         var _iterator__ex2g4s_0 = tmp0_0.p();
         while (_iterator__ex2g4s_0.s()) {
           var element_0 = _iterator__ex2g4s_0.t();
-          if (Companion_getInstance_1().u1i().match(element_0.a3k(), solution.gc_1)) {
+          if (Companion_getInstance_1().u1i().match(element_0.y3l(), solution.gc_1)) {
             tmp$ret$3 = element_0;
             break $l$block_0;
           }
@@ -3907,7 +4270,7 @@
         var _iterator__ex2g4s = tmp0.p();
         while (_iterator__ex2g4s.s()) {
           var element = _iterator__ex2g4s.t();
-          if (Companion_getInstance_1().u1i().match(element.a3k(), solution.gc_1)) {
+          if (Companion_getInstance_1().u1i().match(element.y3l(), solution.gc_1)) {
             tmp$ret$1 = element;
             break $l$block;
           }
@@ -3923,7 +4286,7 @@
         var _iterator__ex2g4s_0 = tmp0_0.p();
         while (_iterator__ex2g4s_0.s()) {
           var element_0 = _iterator__ex2g4s_0.t();
-          if (Companion_getInstance_1().u1i().match(element_0.a3k(), solution.fc_1)) {
+          if (Companion_getInstance_1().u1i().match(element_0.y3l(), solution.fc_1)) {
             tmp$ret$3 = element_0;
             break $l$block_0;
           }
@@ -3932,7 +4295,7 @@
       }
       // Inline function 'kotlin.also' call
       var this_0 = new Support(tmp$ret$3, argument);
-      argument.z3j_1.m(this_0.c3k_1);
+      argument.x3l_1.m(this_0.a3m_1);
       return this_0;
     };
   }
@@ -4034,7 +4397,7 @@
   }
   function Companion_3() {
   }
-  protoOf(Companion_3).b3k = function (term) {
+  protoOf(Companion_3).z3l = function (term) {
     // Inline function 'kotlin.let' call
     var it = of$termAsList(term);
     return new Argument(of$argRules(it), of$argTopRule(it), of$argConclusion(it), of$argGroundings(it), of$argDefeasibleRules(it), of$argDefeasiblePremises(it), of$argLastDefeasibleRules(it), term);
@@ -4049,44 +4412,44 @@
     defeasiblePremises = defeasiblePremises === VOID ? emptyList() : defeasiblePremises;
     lastDefeasibleRules = lastDefeasibleRules === VOID ? emptyList() : lastDefeasibleRules;
     term = term === VOID ? null : term;
-    this.q3j_1 = rules;
-    this.r3j_1 = topRule;
-    this.s3j_1 = conclusion;
-    this.t3j_1 = groundings;
-    this.u3j_1 = defeasibleRules;
-    this.v3j_1 = defeasiblePremises;
-    this.w3j_1 = lastDefeasibleRules;
-    this.x3j_1 = term;
-    this.y3j_1 = '';
+    this.o3l_1 = rules;
+    this.p3l_1 = topRule;
+    this.q3l_1 = conclusion;
+    this.r3l_1 = groundings;
+    this.s3l_1 = defeasibleRules;
+    this.t3l_1 = defeasiblePremises;
+    this.u3l_1 = lastDefeasibleRules;
+    this.v3l_1 = term;
+    this.w3l_1 = '';
     var tmp = this;
     // Inline function 'kotlin.collections.mutableListOf' call
-    tmp.z3j_1 = ArrayList_init_$Create$_0();
+    tmp.x3l_1 = ArrayList_init_$Create$_0();
   }
   protoOf(Argument).hashCode = function () {
     // Inline function 'kotlin.hashCode' call
-    var tmp0_safe_receiver = this.x3j_1;
+    var tmp0_safe_receiver = this.v3l_1;
     var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
     return tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
   };
-  protoOf(Argument).e3k = function () {
-    var tmp = this.y3j_1 + ' : ';
+  protoOf(Argument).c3m = function () {
+    var tmp = this.w3l_1 + ' : ';
     var tmp_0;
-    if (this.r3j_1 === 'none') {
-      var tmp0_elvis_lhs = firstOrNull_0(this.q3j_1);
+    if (this.p3l_1 === 'none') {
+      var tmp0_elvis_lhs = firstOrNull_0(this.o3l_1);
       tmp_0 = tmp0_elvis_lhs == null ? '' : tmp0_elvis_lhs;
     } else {
       // Inline function 'kotlin.collections.map' call
-      var this_0 = this.z3j_1;
+      var this_0 = this.x3l_1;
       // Inline function 'kotlin.collections.mapTo' call
       var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
       var _iterator__ex2g4s = this_0.p();
       while (_iterator__ex2g4s.s()) {
         var item = _iterator__ex2g4s.t();
-        var tmp$ret$0 = item.y3j_1;
+        var tmp$ret$0 = item.w3l_1;
         destination.m(tmp$ret$0);
       }
       // Inline function 'kotlin.collections.reduce' call
-      var iterator = plus_1(destination, this.r3j_1).p();
+      var iterator = plus_1(destination, this.p3l_1).p();
       if (!iterator.s())
         throw UnsupportedOperationException_init_$Create$("Empty collection can't be reduced.");
       var accumulator = iterator.t();
@@ -4095,35 +4458,35 @@
       }
       tmp_0 = accumulator;
     }
-    return tmp + tmp_0 + ' : ' + this.s3j_1;
+    return tmp + tmp_0 + ' : ' + this.q3l_1;
   };
-  protoOf(Argument).a3k = function () {
-    var tmp0_elvis_lhs = this.x3j_1;
-    return tmp0_elvis_lhs == null ? parseStruct(Companion_getInstance_7(), '[' + toString(this.q3j_1) + ', ' + this.r3j_1 + ', [' + this.s3j_1 + '], ' + toString(this.t3j_1) + ', [' + toString(this.w3j_1) + ', ' + toString(this.u3j_1) + ', ' + toString(this.v3j_1) + ']]') : tmp0_elvis_lhs;
+  protoOf(Argument).y3l = function () {
+    var tmp0_elvis_lhs = this.v3l_1;
+    return tmp0_elvis_lhs == null ? parseStruct(Companion_getInstance_7(), '[' + toString(this.o3l_1) + ', ' + this.p3l_1 + ', [' + this.q3l_1 + '], ' + toString(this.r3l_1) + ', [' + toString(this.u3l_1) + ', ' + toString(this.s3l_1) + ', ' + toString(this.t3l_1) + ']]') : tmp0_elvis_lhs;
   };
   protoOf(Argument).toString = function () {
-    return 'argument(' + this.a3k().toString() + ')';
+    return 'argument(' + this.y3l().toString() + ')';
   };
   protoOf(Argument).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Argument))
       return false;
-    if (!equals(this.q3j_1, other.q3j_1))
+    if (!equals(this.o3l_1, other.o3l_1))
       return false;
-    if (!(this.r3j_1 === other.r3j_1))
+    if (!(this.p3l_1 === other.p3l_1))
       return false;
-    if (!(this.s3j_1 === other.s3j_1))
+    if (!(this.q3l_1 === other.q3l_1))
       return false;
-    if (!equals(this.t3j_1, other.t3j_1))
+    if (!equals(this.r3l_1, other.r3l_1))
       return false;
-    if (!equals(this.u3j_1, other.u3j_1))
+    if (!equals(this.s3l_1, other.s3l_1))
       return false;
-    if (!equals(this.v3j_1, other.v3j_1))
+    if (!equals(this.t3l_1, other.t3l_1))
       return false;
-    if (!equals(this.w3j_1, other.w3j_1))
+    if (!equals(this.u3l_1, other.u3l_1))
       return false;
-    if (!equals(this.x3j_1, other.x3j_1))
+    if (!equals(this.v3l_1, other.v3l_1))
       return false;
     return true;
   };
@@ -4133,23 +4496,23 @@
   function Attack(attacker, target, type, on) {
     type = type === VOID ? null : type;
     on = on === VOID ? null : on;
-    this.f3k_1 = attacker;
-    this.g3k_1 = target;
-    this.h3k_1 = type;
-    this.i3k_1 = on;
+    this.d3m_1 = attacker;
+    this.e3m_1 = target;
+    this.f3m_1 = type;
+    this.g3m_1 = on;
   }
   protoOf(Attack).toString = function () {
-    var tmp = toString(toString$parse(this.h3k_1));
-    var tmp_0 = this.f3k_1.a3k().toString();
-    var tmp_1 = this.g3k_1.a3k().toString();
-    var tmp0_safe_receiver = this.i3k_1;
-    return 'attack(' + tmp + ', ' + tmp_0 + ', ' + tmp_1 + ', ' + toString(toString$parse(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a3k())) + ')';
+    var tmp = toString(toString$parse(this.f3m_1));
+    var tmp_0 = this.d3m_1.y3l().toString();
+    var tmp_1 = this.e3m_1.y3l().toString();
+    var tmp0_safe_receiver = this.g3m_1;
+    return 'attack(' + tmp + ', ' + tmp_0 + ', ' + tmp_1 + ', ' + toString(toString$parse(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y3l())) + ')';
   };
   protoOf(Attack).hashCode = function () {
-    var result = this.f3k_1.hashCode();
-    result = imul(result, 31) + this.g3k_1.hashCode() | 0;
-    result = imul(result, 31) + (this.h3k_1 == null ? 0 : getStringHashCode(this.h3k_1)) | 0;
-    result = imul(result, 31) + (this.i3k_1 == null ? 0 : this.i3k_1.hashCode()) | 0;
+    var result = this.d3m_1.hashCode();
+    result = imul(result, 31) + this.e3m_1.hashCode() | 0;
+    result = imul(result, 31) + (this.f3m_1 == null ? 0 : getStringHashCode(this.f3m_1)) | 0;
+    result = imul(result, 31) + (this.g3m_1 == null ? 0 : this.g3m_1.hashCode()) | 0;
     return result;
   };
   protoOf(Attack).equals = function (other) {
@@ -4157,31 +4520,31 @@
       return true;
     if (!(other instanceof Attack))
       return false;
-    if (!this.f3k_1.equals(other.f3k_1))
+    if (!this.d3m_1.equals(other.d3m_1))
       return false;
-    if (!this.g3k_1.equals(other.g3k_1))
+    if (!this.e3m_1.equals(other.e3m_1))
       return false;
-    if (!(this.h3k_1 == other.h3k_1))
+    if (!(this.f3m_1 == other.f3m_1))
       return false;
-    if (!equals(this.i3k_1, other.i3k_1))
+    if (!equals(this.g3m_1, other.g3m_1))
       return false;
     return true;
   };
   function Companion_4() {
   }
-  protoOf(Companion_4).p3j = function (labellings, attacks, supports) {
+  protoOf(Companion_4).n3l = function (labellings, attacks, supports) {
     // Inline function 'kotlin.collections.map' call
     // Inline function 'kotlin.collections.mapTo' call
     var destination = ArrayList_init_$Create$(collectionSizeOrDefault(labellings, 10));
     var _iterator__ex2g4s = labellings.p();
     while (_iterator__ex2g4s.s()) {
       var item = _iterator__ex2g4s.t();
-      var tmp$ret$0 = item.j3k_1;
+      var tmp$ret$0 = item.h3m_1;
       destination.m(tmp$ret$0);
     }
     // Inline function 'kotlin.also' call
     var this_0 = new Graph(destination, attacks, supports);
-    this_0.o3k_1 = labellings;
+    this_0.m3m_1 = labellings;
     return this_0;
   };
   var Companion_instance_12;
@@ -4189,18 +4552,18 @@
     return Companion_instance_12;
   }
   function Graph(arguments_0, attacks, supports) {
-    this.l3k_1 = arguments_0;
-    this.m3k_1 = attacks;
-    this.n3k_1 = supports;
-    this.o3k_1 = emptyList();
+    this.j3m_1 = arguments_0;
+    this.k3m_1 = attacks;
+    this.l3m_1 = supports;
+    this.m3m_1 = emptyList();
   }
   protoOf(Graph).toString = function () {
-    return 'Graph(arguments=' + toString(this.l3k_1) + ', attacks=' + toString(this.m3k_1) + ', supports=' + toString(this.n3k_1) + ')';
+    return 'Graph(arguments=' + toString(this.j3m_1) + ', attacks=' + toString(this.k3m_1) + ', supports=' + toString(this.l3m_1) + ')';
   };
   protoOf(Graph).hashCode = function () {
-    var result = hashCode(this.l3k_1);
-    result = imul(result, 31) + hashCode(this.m3k_1) | 0;
-    result = imul(result, 31) + hashCode(this.n3k_1) | 0;
+    var result = hashCode(this.j3m_1);
+    result = imul(result, 31) + hashCode(this.k3m_1) | 0;
+    result = imul(result, 31) + hashCode(this.l3m_1) | 0;
     return result;
   };
   protoOf(Graph).equals = function (other) {
@@ -4208,24 +4571,24 @@
       return true;
     if (!(other instanceof Graph))
       return false;
-    if (!equals(this.l3k_1, other.l3k_1))
+    if (!equals(this.j3m_1, other.j3m_1))
       return false;
-    if (!equals(this.m3k_1, other.m3k_1))
+    if (!equals(this.k3m_1, other.k3m_1))
       return false;
-    if (!equals(this.n3k_1, other.n3k_1))
+    if (!equals(this.l3m_1, other.l3m_1))
       return false;
     return true;
   };
   function LabelledArgument(argument, label) {
-    this.j3k_1 = argument;
-    this.k3k_1 = label;
+    this.h3m_1 = argument;
+    this.i3m_1 = label;
   }
   protoOf(LabelledArgument).toString = function () {
-    return this.k3k_1 + '(' + this.j3k_1.a3k().toString() + ')';
+    return this.i3m_1 + '(' + this.h3m_1.y3l().toString() + ')';
   };
   protoOf(LabelledArgument).hashCode = function () {
-    var result = this.j3k_1.hashCode();
-    result = imul(result, 31) + getStringHashCode(this.k3k_1) | 0;
+    var result = this.h3m_1.hashCode();
+    result = imul(result, 31) + getStringHashCode(this.i3m_1) | 0;
     return result;
   };
   protoOf(LabelledArgument).equals = function (other) {
@@ -4233,22 +4596,22 @@
       return true;
     if (!(other instanceof LabelledArgument))
       return false;
-    if (!this.j3k_1.equals(other.j3k_1))
+    if (!this.h3m_1.equals(other.h3m_1))
       return false;
-    if (!(this.k3k_1 === other.k3k_1))
+    if (!(this.i3m_1 === other.i3m_1))
       return false;
     return true;
   };
   function Support(supporter, supported) {
-    this.c3k_1 = supporter;
-    this.d3k_1 = supported;
+    this.a3m_1 = supporter;
+    this.b3m_1 = supported;
   }
   protoOf(Support).toString = function () {
-    return 'support(' + this.c3k_1.a3k().toString() + ', ' + this.d3k_1.a3k().toString() + ')';
+    return 'support(' + this.a3m_1.y3l().toString() + ', ' + this.b3m_1.y3l().toString() + ')';
   };
   protoOf(Support).hashCode = function () {
-    var result = this.c3k_1.hashCode();
-    result = imul(result, 31) + this.d3k_1.hashCode() | 0;
+    var result = this.a3m_1.hashCode();
+    result = imul(result, 31) + this.b3m_1.hashCode() | 0;
     return result;
   };
   protoOf(Support).equals = function (other) {
@@ -4256,9 +4619,9 @@
       return true;
     if (!(other instanceof Support))
       return false;
-    if (!this.c3k_1.equals(other.c3k_1))
+    if (!this.a3m_1.equals(other.a3m_1))
       return false;
-    if (!this.d3k_1.equals(other.d3k_1))
+    if (!this.b3m_1.equals(other.b3m_1))
       return false;
     return true;
   };
@@ -4267,7 +4630,7 @@
     EngineInterfaceBase.call(this);
   }
   protoOf(EngineInterface).b3a = function () {
-    return ArgumentationEngineInterface_instance.s3k_1;
+    return ArgumentationEngineInterface_instance.q3m_1;
   };
   var EngineInterface_instance;
   function EngineInterface_getInstance() {
@@ -4280,7 +4643,7 @@
     AbstractModeBase.call(this);
   }
   protoOf(AbstractMode).b3a = function () {
-    return AbstractMode_instance_0.w3k_1;
+    return AbstractMode_instance_0.u3m_1;
   };
   var AbstractMode_instance;
   function AbstractMode_getInstance() {
@@ -4293,7 +4656,7 @@
     ArgumentationGraphBuilderBase.call(this);
   }
   protoOf(ArgumentationGraphBuilder).b3a = function () {
-    return ArgumentationGraph_instance.a3l_1;
+    return ArgumentationGraph_instance.y3m_1;
   };
   var ArgumentationGraphBuilder_instance;
   function ArgumentationGraphBuilder_getInstance() {
@@ -4306,7 +4669,7 @@
     AttackRestrictionHandlerBase.call(this);
   }
   protoOf(AttackRestrictionHandler).b3a = function () {
-    return AttackRestriction_instance.e3l_1;
+    return AttackRestriction_instance.c3n_1;
   };
   var AttackRestrictionHandler_instance;
   function AttackRestrictionHandler_getInstance() {
@@ -4319,7 +4682,7 @@
     BpMetaGraphHandlerBase.call(this);
   }
   protoOf(BpMetaGraphHandler).b3a = function () {
-    return Bp_instance.i3l_1;
+    return Bp_instance.g3n_1;
   };
   var BpMetaGraphHandler_instance;
   function BpMetaGraphHandler_getInstance() {
@@ -4332,7 +4695,7 @@
     DefeasiblePreferencesHandlerBase.call(this);
   }
   protoOf(DefeasiblePreferencesHandler).b3a = function () {
-    return DefPreferences_instance.m3l_1;
+    return DefPreferences_instance.k3n_1;
   };
   var DefeasiblePreferencesHandler_instance;
   function DefeasiblePreferencesHandler_getInstance() {
@@ -4345,7 +4708,7 @@
     GenericDefeasiblePreferencesHandlerBase.call(this);
   }
   protoOf(GenericDefeasiblePreferencesHandler).b3a = function () {
-    return GenericDefPreferences_instance.q3l_1;
+    return GenericDefPreferences_instance.o3n_1;
   };
   var GenericDefeasiblePreferencesHandler_instance;
   function GenericDefeasiblePreferencesHandler_getInstance() {
@@ -4358,7 +4721,7 @@
     StrictPreferencesHandlerBase.call(this);
   }
   protoOf(StrictPreferencesHandler).b3a = function () {
-    return Preferences_instance.u3l_1;
+    return Preferences_instance.s3n_1;
   };
   var StrictPreferencesHandler_instance;
   function StrictPreferencesHandler_getInstance() {
@@ -4371,7 +4734,7 @@
     BpCompleteLabellerBase.call(this);
   }
   protoOf(BpCompleteLabeller).b3a = function () {
-    return BpGroundedComplete_instance.y3l_1;
+    return BpGroundedComplete_instance.w3n_1;
   };
   var BpCompleteLabeller_instance;
   function BpCompleteLabeller_getInstance() {
@@ -4384,7 +4747,7 @@
     BpLabellerBase.call(this);
   }
   protoOf(BpLabeller).b3a = function () {
-    return BpGrounded_instance.c3m_1;
+    return BpGrounded_instance.a3o_1;
   };
   var BpLabeller_instance;
   function BpLabeller_getInstance() {
@@ -4397,7 +4760,7 @@
     BpPartialLabellerBase.call(this);
   }
   protoOf(BpPartialLabeller).b3a = function () {
-    return BpGroundedPartial_instance.g3m_1;
+    return BpGroundedPartial_instance.e3o_1;
   };
   var BpPartialLabeller_instance;
   function BpPartialLabeller_getInstance() {
@@ -4410,7 +4773,7 @@
     CompleteLabellerBase.call(this);
   }
   protoOf(CompleteLabeller).b3a = function () {
-    return Complete_instance.k3m_1;
+    return Complete_instance.i3o_1;
   };
   var CompleteLabeller_instance;
   function CompleteLabeller_getInstance() {
@@ -4423,7 +4786,7 @@
     GroundedLabellerBase.call(this);
   }
   protoOf(GroundedLabeller).b3a = function () {
-    return Grounded_instance.o3m_1;
+    return Grounded_instance.m3o_1;
   };
   var GroundedLabeller_instance;
   function GroundedLabeller_getInstance() {
@@ -4436,7 +4799,7 @@
     GroundedLabellerOptimizedBase.call(this);
   }
   protoOf(GroundedLabellerOptimized).b3a = function () {
-    return GroundedOptimized_instance.s3m_1;
+    return GroundedOptimized_instance.q3o_1;
   };
   var GroundedLabellerOptimized_instance;
   function GroundedLabellerOptimized_getInstance() {
@@ -4449,7 +4812,7 @@
     StatementLabellerBase.call(this);
   }
   protoOf(StatementLabeller).b3a = function () {
-    return StatementLabelling_instance.w3m_1;
+    return StatementLabelling_instance.u3o_1;
   };
   var StatementLabeller_instance;
   function StatementLabeller_getInstance() {
@@ -4462,7 +4825,7 @@
     RuleParserBase.call(this);
   }
   protoOf(RuleParser).b3a = function () {
-    return RuleTranslator_instance.a3n_1;
+    return RuleTranslator_instance.y3o_1;
   };
   var RuleParser_instance;
   function RuleParser_getInstance() {
@@ -4471,147 +4834,147 @@
     return RuleParser_instance;
   }
   function AbstractMode_0() {
-    this.w3k_1 = 'computeGlobalAcceptance :-\n    buildGraph,\n    modifyGraph,\n    buildArgumentLabelling,\n    buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n    computeGlobalAcceptance,\n    utils::recoverGraph(Arguments, Attacks, Supports),\n    utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n    utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n    graphBuildMode(X),\n    X:::buildArgumentationGraph.\nmodifyGraph :-\n    findall(X, graphExtension(X), Ext),\n    modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n    modifyGraph(Ext),\n    X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n    argumentLabellingMode(X),\n    X:::argumentLabelling.\nbuildStatementLabelling :-\n    statementLabellingMode(X),\n    X:::statementLabelling.';
+    this.u3m_1 = 'computeGlobalAcceptance :-\n    buildGraph,\n    modifyGraph,\n    buildArgumentLabelling,\n    buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n    computeGlobalAcceptance,\n    utils::recoverGraph(Arguments, Attacks, Supports),\n    utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n    utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n    graphBuildMode(X),\n    X:::buildArgumentationGraph.\nmodifyGraph :-\n    findall(X, graphExtension(X), Ext),\n    modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n    modifyGraph(Ext),\n    X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n    argumentLabellingMode(X),\n    X:::argumentLabelling.\nbuildStatementLabelling :-\n    statementLabellingMode(X),\n    X:::statementLabelling.\nsolve(Arguments, Attacks, I, O, U) :-\n    solve(Arguments, Attacks),\n    utils::recoverArgumentLabellingAbstract(I, O, U).\nsolve(Arguments, Attacks) :-\n    context_reset,\n    findall(_, (\n        member(A, Arguments),\n        standard_af::saveArgument(graph, [A], [[A], A, [A], [], [[], [], []]])\n    ), _),\n    findall(_, (\n        member((A, B), Attacks),\n        AA = [[A], A, [A], [], [[], [], []]],\n        BB = [[B], B, [B], [], [[], [], []]],\n        standard_af::saveAttack(abstract, AA, BB, BB)\n    ), _),\n    buildArgumentLabelling.';
   }
   var AbstractMode_instance_0;
   function AbstractMode_getInstance_0() {
     return AbstractMode_instance_0;
   }
   function ArgumentationEngineInterface() {
-    this.s3k_1 = 'argTuProlog.\nsolve :- buildLabelSetsSilent.\nsolve(Query) :- answerQuery(Query).\nsolve(Query, Res) :- answerQuery(Query, Res).\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n    buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n    debug::printArgumentationGraph(Arguments, Attacks, Supports),\n    debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n    debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Res).\nanswerQuery(Goal) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal).\nbuildLabelSetsSilent :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance.';
+    this.q3m_1 = 'argTuProlog.\nsolve :- buildLabelSetsSilent.\nsolve(Query) :- answerQuery(Query).\nsolve(Query, Res) :- answerQuery(Query, Res).\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n    buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n    debug::printArgumentationGraph(Arguments, Attacks, Supports),\n    debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n    debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Res).\nanswerQuery(Goal) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal).\nbuildLabelSetsSilent :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance.';
   }
   var ArgumentationEngineInterface_instance;
   function ArgumentationEngineInterface_getInstance() {
     return ArgumentationEngineInterface_instance;
   }
   function ArgumentationGraph() {
-    this.a3l_1 = 'buildArgumentationGraph :-\n    buildArguments,\n    findall(_, buildAdditionalArgument, _),\n    buildAttacks.\nbuildAdditionalArgument :-\n    metaConflicts,\n    conf_arg(A, CArg),\n    context_check(clause(conc(A), argument([R, T, C, B, I]))),\n    \\+ filter_meta([R, T, C, B, I]),\n    saveArgument(a, A, [[mc|R], T, C, B, I]),\n    saveSupport(CArg, [[mc|R], T, C, B, I]),\n    cloneSupport([R, T, C, B, I], [[mc|R], T, C, B, I]),\n    fail.\nbuildAdditionalArgument.\ncloneSupport(Original, New) :-\n    findall(_, (\n        context_check(support(S, Original)),\n        saveSupport(S, New)\n    ), _).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _, _)]), argument(Arg))).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _)]), argument(Arg))).\nfilter_meta([Id, _, _, _, _]) :- metaConflicts, member(mc, Id).\nfilter_meta(_) :- \\+ metaConflicts.\nbuildArguments :-\n\tbuildArgumentsFromPremises,\n\tbuildArgumentsFromEmptyRules,\n\tfindall([RuleID, RuleBody, RuleHead], (\n\t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n\t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n    ), Rules),\n    findall(X, context_check(newConc(a, [X])), N),\n\tbuildArgumentsFromRules(N, b, Rules, Rules, n).\nbuildArgumentsFromPremises :-\n    findall(\n        _,\n        (\n            parser::classic_rule(PremiseID, Premise),\n            checkStrict(PremiseID, DefPrem),\n            saveArgument(a, Premise, [[PremiseID], none, Premise, [], [[], [], DefPrem]])\n        ),\n        _\n    ).\nbuildArgumentsFromEmptyRules :-\n    findall(\n        _,\n        (\n            emptyRule([RuleID, RulePrem, RuleHead]),\n            checkStrict(RuleID, DefRule),\n            saveArgument(a, RuleHead, [[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])\n        ),\n        _\n    ).\nemptyRule([RuleID, Body, RuleHead]) :-\n    parser::classic_rule(RuleID, Body, RuleHead),\n    \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n    ruleBodyIsSupported(RuleID, RuleHead, Body, Body, [[], [], [], []], _).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\nbuildArgumentsFromRules(_, _, Rules, [], n) :- !.\nbuildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\nbuildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n    utils::contains_any(Body, N),\n    findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n    R \\== [],\n    buildArgumentsFromRules(N, Tn, Rules, T, y), !.\nbuildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n    buildArgumentsFromRules(N, Tn, Rules, T, X).\nbuildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n\tsaveArgument(Tn, RuleHead, Argument).\nclean(Tn, Rules) :-\n    invert(Tn, Tx),\n    context_retract(newConc(Tx, _)),\n    findall(X, context_check(newConc(Tn, [X])), N),\n    buildArgumentsFromRules(N, Tx, Rules, Rules, n).\ninvert(a, b).\ninvert(b, a).\ndefRules(Id, Def, Def) :- parser::check_strict(Id), !.\ndefRules(Id, Def, [Id|Def]).\nlastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\nlastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\nargumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n    utils::sortDistinct(Prem, FPrem),\n    defRules(RuleId, Def, NDef),\n    utils::sortDistinct(NDef, FDef),\n    lastDefRules(RuleId, LDef, NLDef),\n    utils::sortDistinct(NLDef, FLDef).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n    utils::appendLists(TAll, All),\n    \\+ utils::contains(RuleID, All),\n    utils::appendLists(TLDef, LDef),\n    utils::appendLists(TDef, Def),\n    utils::appendLists(TPrem, Prem),\n    argumentInfo(RuleID, LDef, Def, Prem, Info),\n    utils::sort([RuleID|All], Rules),\n    Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n    \\+ context_check(clause(conc(RuleHead), argument(Argument))).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n\t(callable(Check) -> call(Check); Check),\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n    context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n\truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n\tsaveSupport([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument).\nbuildAttacks :-\n\tfindall(_, buildDirectAttack, _).\nbuildDirectAttack :-\n    context_check(argument(A)),\n    attack::findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tfilter_meta(B),\n\tA \\== B,\n    attack::attacks(T, B, A),\n    saveAttack(T, B, A, A),\n    findall(_, (\n        expanded_support(A, C),\n        saveAttack(T, B, C, A)\n    ),_),\n\tfail.\nbuildDirectAttack.\nexpanded_support(A, B) :-\n    context_check(support(A, B)).\nexpanded_support(A, C) :-\n    context_check(support(A, B)),\n    expanded_support(B, C).\nsaveArgument(T, Conclusion, Argument) :-\n    \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n    context_assert(newConc(T, Conclusion)),\n    utils::hash(argument(Argument), Id),\n    context_assert(argument(Argument)),\n    context_assert(conc(Conclusion) :- argument(Argument)),\n    context_assert(arg(Id) :- argument(Argument)).\nsaveAttack(T, A, C, D) :-\n    \\+ context_check(attack(T, A, C, D)),\n    context_assert(attack(T, A, C, D)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(C), IdC),\n    context_assert(att(IdA, IdC) :- attack(T, A, C, D)).\nsaveSupport(A, B) :-\n    \\+ context_check(support(A, B)),\n    context_assert(support(A, B)).\nremoveAttack(T, A, B, C) :-\n    context_retract(attack(T, A, B, C)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(B), IdB),\n    context_retract(att(IdA, IdB) :- attack(T, A, B, C)).';
+    this.y3m_1 = 'buildArgumentationGraph :-\n    buildArguments,\n    findall(_, buildAdditionalArgument, _),\n    buildAttacks.\nbuildAdditionalArgument :-\n    metaConflicts,\n    conf_arg(A, CArg),\n    context_check(clause(conc(A), argument([R, T, C, B, I]))),\n    \\+ filter_meta([R, T, C, B, I]),\n    saveArgument(a, A, [[mc|R], T, C, B, I]),\n    saveSupport(CArg, [[mc|R], T, C, B, I]),\n    cloneSupport([R, T, C, B, I], [[mc|R], T, C, B, I]),\n    fail.\nbuildAdditionalArgument.\ncloneSupport(Original, New) :-\n    findall(_, (\n        context_check(support(S, Original)),\n        saveSupport(S, New)\n    ), _).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _, _)]), argument(Arg))).\nconf_arg([A], Arg) :-\n    context_check(clause(conc([conflict(A, _)]), argument(Arg))).\nfilter_meta([Id, _, _, _, _]) :- metaConflicts, member(mc, Id).\nfilter_meta(_) :- \\+ metaConflicts.\nbuildArguments :-\n\tbuildArgumentsFromPremises,\n\tbuildArgumentsFromEmptyRules,\n\tfindall([RuleID, RuleBody, RuleHead], (\n\t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n\t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n    ), Rules),\n    findall(X, context_check(newConc(a, [X])), N),\n\tbuildArgumentsFromRules(N, b, Rules, Rules, n).\nbuildArgumentsFromPremises :-\n    findall(\n        _,\n        (\n            parser::classic_rule(PremiseID, Premise),\n            checkStrict(PremiseID, DefPrem),\n            saveArgument(a, Premise, [[PremiseID], none, Premise, [], [[], [], DefPrem]])\n        ),\n        _\n    ).\nbuildArgumentsFromEmptyRules :-\n    findall(\n        _,\n        (\n            emptyRule([RuleID, RulePrem, RuleHead]),\n            checkStrict(RuleID, DefRule),\n            saveArgument(a, RuleHead, [[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])\n        ),\n        _\n    ).\nemptyRule([RuleID, Body, RuleHead]) :-\n    parser::classic_rule(RuleID, Body, RuleHead),\n    \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n    ruleBodyIsSupported(RuleID, RuleHead, Body, Body, [[], [], [], []], _).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\nbuildArgumentsFromRules(_, _, Rules, [], n) :- !.\nbuildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\nbuildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n    utils::contains_any(Body, N),\n    findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n    R \\== [],\n    buildArgumentsFromRules(N, Tn, Rules, T, y), !.\nbuildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n    buildArgumentsFromRules(N, Tn, Rules, T, X).\nbuildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n\tsaveArgument(Tn, RuleHead, Argument).\nclean(Tn, Rules) :-\n    invert(Tn, Tx),\n    context_retract(newConc(Tx, _)),\n    findall(X, context_check(newConc(Tn, [X])), N),\n    buildArgumentsFromRules(N, Tx, Rules, Rules, n).\ninvert(a, b).\ninvert(b, a).\ndefRules(Id, Def, Def) :- parser::check_strict(Id), !.\ndefRules(Id, Def, [Id|Def]).\nlastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\nlastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\nargumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n    utils::sortDistinct(Prem, FPrem),\n    defRules(RuleId, Def, NDef),\n    utils::sortDistinct(NDef, FDef),\n    lastDefRules(RuleId, LDef, NLDef),\n    utils::sortDistinct(NLDef, FLDef).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n    utils::appendLists(TAll, All),\n    \\+ utils::contains(RuleID, All),\n    utils::appendLists(TLDef, LDef),\n    utils::appendLists(TDef, Def),\n    utils::appendLists(TPrem, Prem),\n    argumentInfo(RuleID, LDef, Def, Prem, Info),\n    utils::sort([RuleID|All], Rules),\n    Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n    \\+ context_check(clause(conc(RuleHead), argument(Argument))).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n\t(callable(Check) -> call(Check); Check),\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n    context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n\truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n\tsaveSupport([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument).\nbuildAttacks :-\n\tfindall(_, buildDirectAttack, _).\nbuildDirectAttack :-\n    context_check(argument(A)),\n    attack::findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tfilter_meta(B),\n\tA \\== B,\n    attack::attacks(T, B, A),\n    saveAttack(T, B, A, A),\n    findall(_, (\n        expanded_support(A, C),\n        saveAttack(T, B, C, A)\n    ),_),\n\tfail.\nbuildDirectAttack.\nexpanded_support(A, B) :-\n    context_check(support(A, B)).\nexpanded_support(A, C) :-\n    context_check(support(A, B)),\n    expanded_support(B, C).\nsaveArgument(T, Conclusion, Argument) :-\n    \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n    context_assert(newConc(T, Conclusion)),\n    utils::hash(argument(Argument), Id),\n    context_assert(argument(Argument)),\n    context_assert(conc(Conclusion) :- argument(Argument)),\n    context_assert(arg(Id) :- argument(Argument)).\nsaveAttack(T, A, C, D) :-\n    \\+ context_check(attack(T, A, C, D)),\n    context_assert(attack(T, A, C, D)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(C), IdC),\n    context_assert(att(IdA, IdC) :- attack(T, A, C, D)).\nsaveSupport(A, B) :-\n    \\+ context_check(support(A, B)),\n    context_assert(support(A, B)).\nremoveAttack(T, A, B, C) :-\n    context_retract(attack(T, A, B, C)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(B), IdB),\n    context_retract(att(IdA, IdB) :- attack(T, A, B, C)).';
   }
   var ArgumentationGraph_instance;
   function ArgumentationGraph_getInstance() {
     return ArgumentationGraph_instance;
   }
   function AttackRelation() {
-    this.b3n_1 = 'attacks(rebut, A, B) :- rebuts(A, B), !.\nattacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\nattacks(undermine, A, B) :- undermines(A, B), !.\nattacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\nattacks(undercut, A, B) :- undercuts(A, B), !.\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB, Guard),\n    (callable(Guard) -> call(Guard); Guard).\nrebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n\tRuleB \\== none,\n    Info \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleA \\== none,\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n\tInfo \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\nundercuts([_, _, NegRuleB, _, _], [_, RuleB, _, _, [[RuleB], _, _]]) :-\n    expanded_conflict(NegRuleB, [RuleB]).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n    member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID], Guard).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID]).';
+    this.z3o_1 = 'attacks(rebut, A, B) :- rebuts(A, B), !.\nattacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\nattacks(undermine, A, B) :- undermines(A, B), !.\nattacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\nattacks(undercut, A, B) :- undercuts(A, B), !.\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n    parser::classic_conflict(HeadA, HeadB, Guard),\n    (callable(Guard) -> call(Guard); Guard).\nrebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n\tRuleB \\== none,\n    Info \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleA \\== none,\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n\tInfo \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\nundercuts([_, _, NegRuleB, _, _], [_, RuleB, _, _, [[RuleB], _, _]]) :-\n    expanded_conflict(NegRuleB, [RuleB]).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    parser::classic_conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n    member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID], Guard).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n    parser::classic_conflict(Conf, [RuleID]).';
   }
   var AttackRelation_instance;
   function AttackRelation_getInstance() {
     return AttackRelation_instance;
   }
   function AttackRestriction() {
-    this.e3l_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkRebutRestriction(T, A, B, C)\n    ), _).\ncheckRebutRestriction(T, A, B, C) :-\n    \\+ rebutRestriction(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nrebutRestriction(rebut, _, _, C) :- restrict(C).\nrebutRestriction(undermine, _, _, C).\nrebutRestriction(contrary_rebut, _, _, _).\nrebutRestriction(contrary_undermine, _, _, _).\nrebutRestriction(undercut, _, _, _).\nrestrict([_, TopRule, _, _, [[TopRule], _, _]]) :- TopRule \\== none.';
+    this.c3n_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkRebutRestriction(T, A, B, C)\n    ), _).\ncheckRebutRestriction(T, A, B, C) :-\n    \\+ rebutRestriction(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nrebutRestriction(rebut, _, _, C) :- restrict(C).\nrebutRestriction(undermine, _, _, C).\nrebutRestriction(contrary_rebut, _, _, _).\nrebutRestriction(contrary_undermine, _, _, _).\nrebutRestriction(undercut, _, _, _).\nrestrict([_, TopRule, _, _, [[TopRule], _, _]]) :- TopRule \\== none.';
   }
   var AttackRestriction_instance;
   function AttackRestriction_getInstance() {
     return AttackRestriction_instance;
   }
   function Bp() {
-    this.i3l_1 = 'modifyArgumentationGraph :-\n    findall(([Rules, Top, [bp(Checked)], G, I], [Z, P, [Y], GG, II]), (\n        context_check(argument([Rules, Top, [bp(Checked)], G, I])),\n        member(Y, [Checked]),\n        context_check(argument([Z, P, [Y], GG, II]))\n    ), TemplateBpPairs),\n    checkBpArguments(TemplateBpPairs).\ncheckBpArguments([]).\ncheckBpArguments(TemplateBpPairs) :-\n    createBpArguments(TemplateBpPairs, BpPairs),\n    createBpAttacks(BpPairs).\ncreateBpArguments([], []).\ncreateBpArguments([(Original, [Z, P, Y, B, I])|Others], [(Conflict, [Z, P, Y, B, I])|BpPairs]) :-\n    Conflict = [[artificial|Z], artificial, [-burdmet(Y)], [], [[artificial], [artificial], []]],\n    standard_af::saveArgument(a, [-burdmet(Y)], Conflict),\n    standard_af::saveSupport(Original, Conflict),\n    liftBpAttacks(Original, Conflict),\n    createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n    findall(_, (\n        context_check(attack(T, A, Template, O)),\n        standard_af::saveAttack(T, A, BpArg, O)\n    ), _).\ncreateBpAttacks(BpPairs) :-\n    generateBpsEvaluationChain(BpPairs, OrderedBpPairs),\n    evaluateBurdenedArgs(OrderedBpPairs).\ngenerateBpsEvaluationChain([], []).\ngenerateBpsEvaluationChain([BpPair|BpPairs], OrderedBpPairs) :-\n    generateBpsEvaluationChain(BpPairs, TempOrderedBpPairs),\n    insertBpPair(BpPair, TempOrderedBpPairs, OrderedBpPairs).\ninsertBpPair(BpPair, [], [BpPair]).\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(BpL, BurdenedL)|Return]) :-\n    bp_grounded::argumentChain(BurdenedL, Burdened),\n    insertBpPair((Bp, Burdened), Others, Return), !.\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(Bp, Burdened)|[(BpL, BurdenedL)|Others]]).\nevaluateBurdenedArgs([]).\nevaluateBurdenedArgs([(Bp, Burdened)|Others]) :-\n    context_active(X),\n    grounded:::argumentLabelling,\n    statusToAttack((Bp, Burdened), attack(T, A, B, C)),\n    context_checkout(X),\n    standard_af::saveAttack(T, A, B, C),\n    evaluateBurdenedArgs(Others).\nstatusToAttack((Bp, Burdened), attack(bprebut, Burdened, Bp, Bp)) :-\n    context_check(in(Burdened)).\nstatusToAttack((Bp, Burdened), attack(bprebut, Bp, Burdened, Burdened)) :-\n    \\+ context_check(in(Burdened)).';
+    this.g3n_1 = 'modifyArgumentationGraph :-\n    findall(([Rules, Top, [bp(Checked)], G, I], [Z, P, [Y], GG, II]), (\n        context_check(argument([Rules, Top, [bp(Checked)], G, I])),\n        member(Y, [Checked]),\n        context_check(argument([Z, P, [Y], GG, II]))\n    ), TemplateBpPairs),\n    checkBpArguments(TemplateBpPairs).\ncheckBpArguments([]).\ncheckBpArguments(TemplateBpPairs) :-\n    createBpArguments(TemplateBpPairs, BpPairs),\n    createBpAttacks(BpPairs).\ncreateBpArguments([], []).\ncreateBpArguments([(Original, [Z, P, Y, B, I])|Others], [(Conflict, [Z, P, Y, B, I])|BpPairs]) :-\n    Conflict = [[artificial|Z], artificial, [-burdmet(Y)], [], [[artificial], [artificial], []]],\n    standard_af::saveArgument(a, [-burdmet(Y)], Conflict),\n    standard_af::saveSupport(Original, Conflict),\n    liftBpAttacks(Original, Conflict),\n    createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n    findall(_, (\n        context_check(attack(T, A, Template, O)),\n        standard_af::saveAttack(T, A, BpArg, O)\n    ), _).\ncreateBpAttacks(BpPairs) :-\n    generateBpsEvaluationChain(BpPairs, OrderedBpPairs),\n    evaluateBurdenedArgs(OrderedBpPairs).\ngenerateBpsEvaluationChain([], []).\ngenerateBpsEvaluationChain([BpPair|BpPairs], OrderedBpPairs) :-\n    generateBpsEvaluationChain(BpPairs, TempOrderedBpPairs),\n    insertBpPair(BpPair, TempOrderedBpPairs, OrderedBpPairs).\ninsertBpPair(BpPair, [], [BpPair]).\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(BpL, BurdenedL)|Return]) :-\n    bp_grounded::argumentChain(BurdenedL, Burdened),\n    insertBpPair((Bp, Burdened), Others, Return), !.\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(Bp, Burdened)|[(BpL, BurdenedL)|Others]]).\nevaluateBurdenedArgs([]).\nevaluateBurdenedArgs([(Bp, Burdened)|Others]) :-\n    context_active(X),\n    grounded:::argumentLabelling,\n    statusToAttack((Bp, Burdened), attack(T, A, B, C)),\n    context_checkout(X),\n    standard_af::saveAttack(T, A, B, C),\n    evaluateBurdenedArgs(Others).\nstatusToAttack((Bp, Burdened), attack(bprebut, Burdened, Bp, Bp)) :-\n    context_check(in(Burdened)).\nstatusToAttack((Bp, Burdened), attack(bprebut, Bp, Burdened, Burdened)) :-\n    \\+ context_check(in(Burdened)).';
   }
   var Bp_instance;
   function Bp_getInstance() {
     return Bp_instance;
   }
   function BpGrounded() {
-    this.c3m_1 = 'argumentLabelling :-\n    reifyBurdenOfProofs,\n    filterBpDefeats,\n    findall(X, context_check(argument(X)), Arguments),\n    bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    grounded::allAttacksOUT(A), !,\n    context_assert(in(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    \\+ isArgumentInBurdenOfProof(A),\n    grounded::oneAttackIN(A), !,\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    context_active(Branch),\n    mostGroundedBpUnd(Arguments, A),\n    context_branch(Branch, _),\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Args) :-\n    notLabelled(Args),\n    findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n    \\+ (\n        member(A, Args),\n        (\n            context_check(in(A));\n            context_check(out(A));\n            context_check(und(A))\n        )\n    ).\nisInBurdenOfProof(Conclusion) :-\n    context_check(reifiedBp(Literals)),\n    member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n    isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        filterBpDefeat(T, A, B, C)\n    ), _).\nfilterBpDefeat(T, B, A, C) :-\n    (T = rebut; T = undermine),\n    isArgumentInBurdenOfProof(B),\n    \\+ superiority::superiorArgument(B, C),\n    context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n    member(Arg, Arguments),\n    isArgumentInBurdenOfProof(Arg),\n    \\+ (\n        member(A, Arguments), Arg \\= A,\n        isArgumentInBurdenOfProof(A),\n        argumentChain(A, Arg)\n    ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n    A \\== B,\n    context_check(attack(_, A, C, _)),\n    argumentChain(C, B).\nreifyBurdenOfProofs :-\n    findall(_, (\n        context_check(abstractBp(AbstractBp)),\n        fillTemplate(AbstractBp, R),\n        \\+ context_check(reifiedBp(R)),\n        context_assert(reifiedBp(R))\n    ), _).\n/*\n    Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n    context_check(argument([_ , _, [P], _, _])),\n    fillTemplate(T, R).';
+    this.a3o_1 = 'argumentLabelling :-\n    reifyBurdenOfProofs,\n    filterBpDefeats,\n    findall(X, context_check(argument(X)), Arguments),\n    bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    grounded_old::allAttacksOUT(A), !,\n    context_assert(in(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    \\+ isArgumentInBurdenOfProof(A),\n    grounded_old::oneAttackIN(A), !,\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    context_active(Branch),\n    mostGroundedBpUnd(Arguments, A),\n    context_branch(Branch, _),\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Args) :-\n    notLabelled(Args),\n    findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n    \\+ (\n        member(A, Args),\n        (\n            context_check(in(A));\n            context_check(out(A));\n            context_check(und(A))\n        )\n    ).\nisInBurdenOfProof(Conclusion) :-\n    context_check(reifiedBp(Literals)),\n    member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n    isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        filterBpDefeat(T, A, B, C)\n    ), _).\nfilterBpDefeat(T, B, A, C) :-\n    (T = rebut; T = undermine),\n    isArgumentInBurdenOfProof(B),\n    \\+ superiority::superiorArgument(B, C),\n    context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n    member(Arg, Arguments),\n    isArgumentInBurdenOfProof(Arg),\n    \\+ (\n        member(A, Arguments), Arg \\= A,\n        isArgumentInBurdenOfProof(A),\n        argumentChain(A, Arg)\n    ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n    A \\== B,\n    context_check(attack(_, A, C, _)),\n    argumentChain(C, B).\nreifyBurdenOfProofs :-\n    findall(_, (\n        context_check(abstractBp(AbstractBp)),\n        fillTemplate(AbstractBp, R),\n        \\+ context_check(reifiedBp(R)),\n        context_assert(reifiedBp(R))\n    ), _).\n/*\n    Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n    context_check(argument([_ , _, [P], _, _])),\n    fillTemplate(T, R).';
   }
   var BpGrounded_instance;
   function BpGrounded_getInstance() {
     return BpGrounded_instance;
   }
   function BpGroundedComplete() {
-    this.y3l_1 = 'argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n    bp_grounded_partial::partialBpLabelling(Arguments), !,\n    findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n    grounded::groundedLabelling(NewArgs),\n    findall(X, context_check(und(X)), LeftArguments),\n    stopCondition(Stop, Arguments, LeftArguments),\n    completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n    utils::sort(Args, SortedArgs),\n    utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
+    this.w3n_1 = 'argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n    bp_grounded_partial::partialBpLabelling(Arguments), !,\n    findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n    grounded_old::groundedLabelling(NewArgs),\n    findall(X, context_check(und(X)), LeftArguments),\n    stopCondition(Stop, Arguments, LeftArguments),\n    completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n    utils::sort(Args, SortedArgs),\n    utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
   }
   var BpGroundedComplete_instance;
   function BpGroundedComplete_getInstance() {
     return BpGroundedComplete_instance;
   }
   function BpGroundedPartial() {
-    this.g3m_1 = "argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    partialBpLabelling(Arguments), !.\npartialBpLabelling([]).\npartialBpLabelling(Arguments) :-\n    mostGroundedArgument(Arguments, A),\n    debug::writeDebug(['Evaluating ', A]),\n    demonstration(Arguments, A, [A], Evaluated),\n    utils::subtract(Arguments, [Evaluated], NewArgs),\n    partialBpLabelling(NewArgs).\n/*\n    (a.i) BP(neg(\u03C6)), and no argument B for neg(\u03C6) such that A < B is IN*, and no A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    superiorComplementArgument(A, B),\n\t    context_check(in(B))\n\t),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    context_check(support(X, A)),\n\t    context_check(out(X))\n\t),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.i)']),\n    context_assert(in(A)).\n/*\n    (a.ii) not BP(neg(\u03C6)) and every argument B for neg(\u03C6) such that B(not <)A is OUT*, and every A1,...An is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, B),\n        \\+ context_check(out(B))\n    ),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        context_check(support(X, A)),\n        \\+ context_check(in(X))\n    ),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.ii)']),\n    context_assert(in(A)).\n/*\n    (b.i.1) BP(\u03C6) and exists an argument B for neg(\u03C6) such that B(not <)A is not OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorOrEqualComplementArgument(A, B),\n\t\\+ context_check(out(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.1)']),\n    context_assert(out(A)).\n/*\n    (b.i.2) BP(\u03C6) and exist one of A1,...An is not IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    \\+ context_check(in(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.2)']),\n    context_assert(out(A)).\n/*\n    (b.ii.1) not BP(\u03C6) and an argument B for neg(\u03C6) such A < B is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorComplementArgument(A, B),\n\tcontext_check(in(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.1)']),\n    context_assert(out(A)).\n/*\n    (b.ii.2) not BP(\u03C6) and one of A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    context_check(out(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.2)']),\n    context_assert(out(A)).\n/*\n    If above definitions do not apply try to decide on the arguments on which they depend\n*/\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorComplementArgument(A, X),\n        context_check(in(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    \\+ isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, X),\n        \\+ context_check(out(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\n/*\n    (c) A is labelled UND* otherwise.\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tdebug::writeDebug(['Adding argument: ', A, ' to UND* (2.c)']),\n    context_assert(und(A)).\nisComplementInBurdenOfProof(A) :-\n    complement(A, Complement),\n    bp_grounded::isInBurdenOfProof(Complement), !.\nmostGroundedArgument([], []).\nmostGroundedArgument([X], X).\nmostGroundedArgument([[L, _, _, _, _]|T], [L2, Q2, W2, B2, I2]) :-\n    mostGroundedArgument(T, [L2, Q2, W2, B2, I2]),\n    length(L, LN1),\n    length(L2, LN2),\n    LN1 > LN2, !.\nmostGroundedArgument([A|_], A).\n/*\n    Get a conclusion complement\n*/\ncomplement([_, _, Conclusion, _, _], A) :-\n    attack::expanded_conflict(Conclusion, A).\nnotEvaluatedSubArgument(Arguments, A, Resolving, B) :-\n    context_check(support(B, A)),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B) :-\n    superiorComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B) :-\n    superiorOrEqualComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nsuperiorComplementArgument(A, [A, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    superiority::superiorArgument([R, B, CA, BB, I], A).\nsuperiorOrEqualComplementArgument(A, [R, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    \\+ superiority::superiorArgument(A, [R, B, CA, BB, I]).";
+    this.e3o_1 = "argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    partialBpLabelling(Arguments), !.\npartialBpLabelling([]).\npartialBpLabelling(Arguments) :-\n    mostGroundedArgument(Arguments, A),\n    debug::writeDebug(['Evaluating ', A]),\n    demonstration(Arguments, A, [A], Evaluated),\n    utils::subtract(Arguments, [Evaluated], NewArgs),\n    partialBpLabelling(NewArgs).\n/*\n    (a.i) BP(neg(\u03C6)), and no argument B for neg(\u03C6) such that A < B is IN*, and no A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    superiorComplementArgument(A, B),\n\t    context_check(in(B))\n\t),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t    context_check(support(X, A)),\n\t    context_check(out(X))\n\t),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.i)']),\n    context_assert(in(A)).\n/*\n    (a.ii) not BP(neg(\u03C6)) and every argument B for neg(\u03C6) such that B(not <)A is OUT*, and every A1,...An is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, B),\n        \\+ context_check(out(B))\n    ),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        context_check(support(X, A)),\n        \\+ context_check(in(X))\n    ),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.ii)']),\n    context_assert(in(A)).\n/*\n    (b.i.1) BP(\u03C6) and exists an argument B for neg(\u03C6) such that B(not <)A is not OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorOrEqualComplementArgument(A, B),\n\t\\+ context_check(out(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.1)']),\n    context_assert(out(A)).\n/*\n    (b.i.2) BP(\u03C6) and exist one of A1,...An is not IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    \\+ context_check(in(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.2)']),\n    context_assert(out(A)).\n/*\n    (b.ii.1) not BP(\u03C6) and an argument B for neg(\u03C6) such A < B is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorComplementArgument(A, B),\n\tcontext_check(in(B)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.1)']),\n    context_assert(out(A)).\n/*\n    (b.ii.2) not BP(\u03C6) and one of A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n    context_check(out(X)),\n    debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.2)']),\n    context_assert(out(A)).\n/*\n    If above definitions do not apply try to decide on the arguments on which they depend\n*/\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorComplementArgument(A, X),\n        context_check(in(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n    \\+ isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n        superiorOrEqualComplementArgument(A, X),\n        \\+ context_check(out(X))\n    ),\n    notEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n    demonstration(Arguments, B, [B|Resolving], Evaluated).\n/*\n    (c) A is labelled UND* otherwise.\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tdebug::writeDebug(['Adding argument: ', A, ' to UND* (2.c)']),\n    context_assert(und(A)).\nisComplementInBurdenOfProof(A) :-\n    complement(A, Complement),\n    bp_grounded::isInBurdenOfProof(Complement), !.\nmostGroundedArgument([], []).\nmostGroundedArgument([X], X).\nmostGroundedArgument([[L, _, _, _, _]|T], [L2, Q2, W2, B2, I2]) :-\n    mostGroundedArgument(T, [L2, Q2, W2, B2, I2]),\n    length(L, LN1),\n    length(L2, LN2),\n    LN1 > LN2, !.\nmostGroundedArgument([A|_], A).\n/*\n    Get a conclusion complement\n*/\ncomplement([_, _, Conclusion, _, _], A) :-\n    attack::expanded_conflict(Conclusion, A).\nnotEvaluatedSubArgument(Arguments, A, Resolving, B) :-\n    context_check(support(B, A)),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B) :-\n    superiorComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B) :-\n    superiorOrEqualComplementArgument(A, B),\n    member(B, Arguments),\n    \\+ member(B, Resolving).\nsuperiorComplementArgument(A, [A, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    superiority::superiorArgument([R, B, CA, BB, I], A).\nsuperiorOrEqualComplementArgument(A, [R, B, CA, BB, I]) :-\n    complement(A, CA),\n    context_check(argument([R, B, CA, BB, I])),\n    \\+ superiority::superiorArgument(A, [R, B, CA, BB, I]).";
   }
   var BpGroundedPartial_instance;
   function BpGroundedPartial_getInstance() {
     return BpGroundedPartial_instance;
   }
   function Complete() {
-    this.k3m_1 = 'argumentLabelling :-\n    cache_retract(complete(_,_,_)),\n    grounded:::argumentLabelling,\n    context_active(Branch),\n    completeLabelling(Branch).\ncompleteLabelling(_) :-\n    admissibleSet,\n    utils::recoverArgumentLabelling(In, Out, Und),\n    \\+ cache_check(complete(In, Out, Und)),\n    cache_assert(complete(In, Out, Und)).\ncompleteLabelling(Branch) :-\n    context_check(und(X)),\n    context_branch(Branch, NewBranch),\n    findall(Y, (context_check(und(Y)), Y \\= X), Arguments),\n    context_retract(und(_)),\n    context_assert(in(X)),\n    grounded::groundedLabelling(Arguments),\n    completeLabelling(NewBranch).\nadmissibleSet :-\n    \\+ (context_check(in(H)), \\+ admissible(H)).\nadmissible(H) :-\n    \\+ (\n        context_check(attack(_, Attacker, H, _)),\n        \\+ (\n            context_check(attack(_, Defendant, Attacker, _)),\n            context_check(in(Defendant))\n        )\n    ).';
+    this.i3o_1 = 'argumentLabelling :-\n    cache_retract(complete(_,_,_,_)),\n    grounded:::argumentLabelling,\n    context_active(Branch),\n    completeLabelling(Branch).\ncompleteLabelling(Branch) :-\n    admissibleSet,\n    utils::recoverArgumentLabellingId(In, Out, Und),\n    \\+ cache_check(complete(In, Out, Und, _)),\n    cache_assert(complete(In, Out, Und, Branch)).\ncompleteLabelling(Branch) :-\n    context_check(undId(IdX)),\n    context_check(clause(arg(IdX), argument(X))),\n    context_branch(Branch, NewBranch),\n    context_retract(und(_)),\n    context_retract(undId(_)),\n    context_assert(in(X)),\n    context_assert(inId(IdX)),\n    grounded::argumentLabelling,\n    completeLabelling(NewBranch).\nadmissibleSet :-\n    \\+ (context_check(inId(H)), \\+ admissible(H)).\nadmissible(H) :-\n    \\+ (\n        context_check(clause(att(Attacker, H), _)),\n        \\+ (\n            context_check(clause(att(Defendant, Attacker), _)),\n            context_check(inId(Defendant)),\n            Defendant \\= Attacker\n        )\n    ).';
   }
   var Complete_instance;
   function Complete_getInstance() {
     return Complete_instance;
   }
   function Debug() {
-    this.c3n_1 = "printTheory(Rules) :-\n    write('HERE THE THEORY:'),nl,\n    findall(rule([Id, Body, Head]), member(rule([Id, Body, Head]), Rules), ListRules),\n    utils::writeListNl(ListRules),\n    findall(premise([A, B]), member(premise([A, B]), Rules), ListPremises),\n    utils::writeListNl(ListPremises),\n    findall(sup(A, B), member(sup(A, B), Rules), ListSups),\n    utils::writeListNl(ListSups).\nprintArgumentationGraph(Arguments, Attacks, Supports) :-\n\tfindall(\n\t    [IDPremises, '\\n',  ' TOPRULE ',  TopRule, '\\n', ' CONCLUSION ', RuleHead, '\\n', ' BODY ', Body, '\\n', ' INFO ', Info, '\\n'],\n\t    member([IDPremises, TopRule, RuleHead, Body, Info], Arguments),\n        ArgumentsToPrint\n    ),\n    findall((A1, ' SUPPORTS ', A2), member((A1, A2), Supports), SupportsToPrint),\n\tfindall((A1, ' ', T, ' ', A2, ' ON ', A3),  member((T, A1, A2, A3), Attacks),  AttacksToPrint),\n    write('HERE THE GROUNDED SEMI-ABSTRACT ARGUMENTATION GRAPH'),nl,\n\tutils::writeListNl(ArgumentsToPrint),\n\tutils::writeListNl(SupportsToPrint),\n\tutils::writeListNl(AttacksToPrint).\nprintArgumentLabelling([IN, OUT, UND]) :-\n    write('HERE THE ARGUMENTS LABELLED IN: '),nl,\n    utils::writeListNl(IN),\n    write('HERE THE ARGUMENTS LABELLED OUT: '),nl,\n    utils::writeListNl(OUT),\n    write('HERE THE ARGUMENTS LABELLED UND: '),nl,\n    utils::writeListNl(UND).\nprintStatementLabelling([In, Ni, Und]) :-\n    write('HERE THE STATEMENTS LABELLED IN: '),nl,\n    utils::writeListNl(In),\n    write('HERE THE STATEMENTS LABELLED NI: '),nl,\n    utils::writeListNl(Ni),\n    write('HERE THE STATEMENTS LABELLED UND: '),nl,\n    utils::writeListNl(Und).\ndebug.\nwriteDebug(List) :-\n    debug,\n    utils::writeList(List).\nwriteDebug(_) :- \\+ debug.";
+    this.a3p_1 = "printTheory(Rules) :-\n    write('HERE THE THEORY:'),nl,\n    findall(rule([Id, Body, Head]), member(rule([Id, Body, Head]), Rules), ListRules),\n    utils::writeListNl(ListRules),\n    findall(premise([A, B]), member(premise([A, B]), Rules), ListPremises),\n    utils::writeListNl(ListPremises),\n    findall(sup(A, B), member(sup(A, B), Rules), ListSups),\n    utils::writeListNl(ListSups).\nprintArgumentationGraph(Arguments, Attacks, Supports) :-\n\tfindall(\n\t    [IDPremises, '\\n',  ' TOPRULE ',  TopRule, '\\n', ' CONCLUSION ', RuleHead, '\\n', ' BODY ', Body, '\\n', ' INFO ', Info, '\\n'],\n\t    member([IDPremises, TopRule, RuleHead, Body, Info], Arguments),\n        ArgumentsToPrint\n    ),\n    findall((A1, ' SUPPORTS ', A2), member((A1, A2), Supports), SupportsToPrint),\n\tfindall((A1, ' ', T, ' ', A2, ' ON ', A3),  member((T, A1, A2, A3), Attacks),  AttacksToPrint),\n    write('HERE THE GROUNDED SEMI-ABSTRACT ARGUMENTATION GRAPH'),nl,\n\tutils::writeListNl(ArgumentsToPrint),\n\tutils::writeListNl(SupportsToPrint),\n\tutils::writeListNl(AttacksToPrint).\nprintArgumentLabelling([IN, OUT, UND]) :-\n    write('HERE THE ARGUMENTS LABELLED IN: '),nl,\n    utils::writeListNl(IN),\n    write('HERE THE ARGUMENTS LABELLED OUT: '),nl,\n    utils::writeListNl(OUT),\n    write('HERE THE ARGUMENTS LABELLED UND: '),nl,\n    utils::writeListNl(UND).\nprintStatementLabelling([In, Ni, Und]) :-\n    write('HERE THE STATEMENTS LABELLED IN: '),nl,\n    utils::writeListNl(In),\n    write('HERE THE STATEMENTS LABELLED NI: '),nl,\n    utils::writeListNl(Ni),\n    write('HERE THE STATEMENTS LABELLED UND: '),nl,\n    utils::writeListNl(Und).\ndebug.\nwriteDebug(List) :-\n    debug,\n    utils::writeList(List).\nwriteDebug(_) :- \\+ debug.";
   }
   var Debug_instance;
   function Debug_getInstance() {
     return Debug_instance;
   }
   function DefPreferences() {
-    this.m3l_1 = 'modifyArgumentationGraph :-\n    assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    convertAttacks(InvalidAttacks),\n    buildPrefAttacks.\nassertAllSup :-\n    context_retract(sup(_, _)),\n    findall(_,\n        (\n            context_check(argument([_, _, [sup(RuleOne, RuleTwo)], _, _])),\n            \\+ context_check(sup(RuleOne, RuleTwo)),\n            context_assert(sup(RuleOne, RuleTwo))\n        ),\n    _).\nfilterSupRelatedAttacks([], []).\nfilterSupRelatedAttacks([(T, A, B, C)|Attacks], [(T, A, B, C)|Invalid]) :-\n    invalid(T, A, B, C, _),\n    filterSupRelatedAttacks(Attacks, Invalid), !.\nfilterSupRelatedAttacks([_|Attacks], Invalid) :-\n    filterSupRelatedAttacks(Attacks, Invalid).\ninvalid(rebut, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\ninvalid(undermine, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\n/*\n*   Translates the attack relations identified during the building phase.\n*   Attack from A to B -> Argument [[], attack, Attack]\n*                         support(A, Argument)\n*                         attack(Argument, B)\n*   If an Argument A built in this way attacks the argument B, and this one also attacks a third argument C\n*   through the argument B1 we have to consider an attack from A to B1 (transitive attack)\n*/\nconvertAttacks(Attacks) :-\n    conversion(Attacks),\n    standard_af::buildTransitiveAttacks.\nconversion(List) :-\n    member((T, A, B, B), List),\n    generateDirectAttackArgument(T, A, B, B),\n    fail.\nconversion(List) :-\n    member((T, A, B, C), List),\n    C \\= B,\n    generateTransitiveAttackArgument(T, A, B, C),\n    fail.\nconversion(_).\ngenerateTransitiveAttackArgument(T, A, B, C) :-\n    context_check(argument([Id, attack, [attack(T, A, C, C)], G, I])),\n    standard_af::saveAttack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C),\n    standard_af::removeAttack(T, A, B, C).\ngenerateDirectAttackArgument(T, A, B, B) :-\n    RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n    standard_af::saveArgument(a, [attack(T, A, B, B)], RArgument),\n    standard_af::saveSupport(A, RArgument),\n    standard_af::saveAttack(T, RArgument, B, B),\n    standard_af::removeAttack(T, A, B, B).\n/*\n*   Computes the pref attack. If an Argument A has a conclusion in the form sup(a, b), we verify if\n*   the attacks involving arguments built on the rules a or b are compatible with this preference.\n*   If there are some contradictions we add an attack from the argument A towards the incompatible attack\n*/\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    invalid(T, A, B, C, SupSet),\n    member(X, SupSet),\n    context_check(argument([IdA, TRA, [X], GG, II])),\n    standard_af::saveAttack(pref, [IdA, TRA, [X], GG, II], [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.';
+    this.k3n_1 = 'modifyArgumentationGraph :-\n    assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    convertAttacks(InvalidAttacks),\n    buildPrefAttacks.\nassertAllSup :-\n    context_retract(sup(_, _)),\n    findall(_,\n        (\n            context_check(argument([_, _, [sup(RuleOne, RuleTwo)], _, _])),\n            \\+ context_check(sup(RuleOne, RuleTwo)),\n            context_assert(sup(RuleOne, RuleTwo))\n        ),\n    _).\nfilterSupRelatedAttacks([], []).\nfilterSupRelatedAttacks([(T, A, B, C)|Attacks], [(T, A, B, C)|Invalid]) :-\n    invalid(T, A, B, C, _),\n    filterSupRelatedAttacks(Attacks, Invalid), !.\nfilterSupRelatedAttacks([_|Attacks], Invalid) :-\n    filterSupRelatedAttacks(Attacks, Invalid).\ninvalid(rebut, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\ninvalid(undermine, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\n/*\n*   Translates the attack relations identified during the building phase.\n*   Attack from A to B -> Argument [[], attack, Attack]\n*                         support(A, Argument)\n*                         attack(Argument, B)\n*   If an Argument A built in this way attacks the argument B, and this one also attacks a third argument C\n*   through the argument B1 we have to consider an attack from A to B1 (transitive attack)\n*/\nconvertAttacks(Attacks) :-\n    conversion(Attacks),\n    standard_af::buildTransitiveAttacks.\nconversion(List) :-\n    member((T, A, B, B), List),\n    generateDirectAttackArgument(T, A, B, B),\n    fail.\nconversion(List) :-\n    member((T, A, B, C), List),\n    C \\= B,\n    generateTransitiveAttackArgument(T, A, B, C),\n    fail.\nconversion(_).\ngenerateTransitiveAttackArgument(T, A, B, C) :-\n    context_check(argument([Id, attack, [attack(T, A, C, C)], G, I])),\n    standard_af::saveAttack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C),\n    standard_af::removeAttack(T, A, B, C).\ngenerateDirectAttackArgument(T, A, B, B) :-\n    RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n    standard_af::saveArgument(a, [attack(T, A, B, B)], RArgument),\n    standard_af::saveSupport(A, RArgument),\n    standard_af::saveAttack(T, RArgument, B, B),\n    standard_af::removeAttack(T, A, B, B).\n/*\n*   Computes the pref attack. If an Argument A has a conclusion in the form sup(a, b), we verify if\n*   the attacks involving arguments built on the rules a or b are compatible with this preference.\n*   If there are some contradictions we add an attack from the argument A towards the incompatible attack\n*/\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    invalid(T, A, B, C, SupSet),\n    member(X, SupSet),\n    context_check(argument([IdA, TRA, [X], GG, II])),\n    standard_af::saveAttack(pref, [IdA, TRA, [X], GG, II], [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.';
   }
   var DefPreferences_instance;
   function DefPreferences_getInstance() {
     return DefPreferences_instance;
   }
   function GenericDefPreferences() {
-    this.q3l_1 = 'modifyArgumentationGraph :-\n    defeasiblePref::assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    defeasiblePref::filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    defeasiblePref::convertAttacks(InvalidAttacks),\n    buildPrefAttacks,\n    standard_af::buildTransitiveAttacks.\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    defeasiblePref::invalid(T, A, B, C, SupSet),\n    createSuperiorityArgument(SupSet, Arg),\n    standard_af::saveAttack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.\ncreateSuperiorityArgument(SupSet, Argument) :-\n    findall([Id, TR, [X], G, I], (\n        member(X, SupSet),\n        context_check(argument([Id, TR, [X], G, I]))\n    ), SupportArguments),\n    mergeIds(SupportArguments, MergedId),\n    Argument = [MergedId, pref, [preference(SupSet)], [], [[pref], MergedId, []]],\n    standard_af::saveArgument(a, [preference(SupSet)], Argument),\n    findall(_, (\n        member(A, SupportArguments),\n        standard_af::saveSupport(A, Argument)\n    ), _).\nmergeIds([], [pref]).\nmergeIds(Arguments, [pref|MergedId]) :-\n    findall(Id, member([Id, _, _, _, _], Arguments), Res),\n    utils::appendLists(Res, MergedId).';
+    this.o3n_1 = 'modifyArgumentationGraph :-\n    defeasiblePref::assertAllSup,\n    findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n    defeasiblePref::filterSupRelatedAttacks(Attacks, InvalidAttacks),\n    defeasiblePref::convertAttacks(InvalidAttacks),\n    buildPrefAttacks,\n    standard_af::buildTransitiveAttacks.\nbuildPrefAttacks :-\n    context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n    defeasiblePref::invalid(T, A, B, C, SupSet),\n    createSuperiorityArgument(SupSet, Arg),\n    standard_af::saveAttack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    fail.\nbuildPrefAttacks.\ncreateSuperiorityArgument(SupSet, Argument) :-\n    findall([Id, TR, [X], G, I], (\n        member(X, SupSet),\n        context_check(argument([Id, TR, [X], G, I]))\n    ), SupportArguments),\n    mergeIds(SupportArguments, MergedId),\n    Argument = [MergedId, pref, [preference(SupSet)], [], [[pref], MergedId, []]],\n    standard_af::saveArgument(a, [preference(SupSet)], Argument),\n    findall(_, (\n        member(A, SupportArguments),\n        standard_af::saveSupport(A, Argument)\n    ), _).\nmergeIds([], [pref]).\nmergeIds(Arguments, [pref|MergedId]) :-\n    findall(Id, member([Id, _, _, _, _], Arguments), Res),\n    utils::appendLists(Res, MergedId).';
   }
   var GenericDefPreferences_instance;
   function GenericDefPreferences_getInstance() {
     return GenericDefPreferences_instance;
   }
   function Grounded() {
-    this.o3m_1 = 'argumentLabelling :-\n    findall(X, context_check(argument(X)), Arguments),\n    groundedLabelling(Arguments).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    allAttacksOUT(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(in(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    oneAttackIN(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(out(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\nallAttacksOUT(A) :-\n    \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\noneAttackIN(A) :-\n    context_check(attack(_, B, A, _)),\n    context_check(in(B)), !.\noneAttackIN(A) :-\n    context_check(attack(_, A, B, _)),\n    context_check(in(B)), !.';
+    this.m3o_1 = 'argumentLabelling :-\n    findall(X, context_check(argument(X)), Arguments),\n    groundedLabelling(Arguments).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    allAttacksOUT(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(in(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(UND) :-\n    member(A, UND),\n    oneAttackIN(A), !,\n    utils::subtract(UND, [A], NewUND),\n    context_assert(out(A)),\n    groundedLabelling(NewUND).\ngroundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\nallAttacksOUT(A) :-\n    \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\noneAttackIN(A) :-\n    context_check(attack(_, B, A, _)),\n    context_check(in(B)), !.\noneAttackIN(A) :-\n    context_check(attack(_, A, B, _)),\n    context_check(in(B)), !.';
   }
   var Grounded_instance;
   function Grounded_getInstance() {
     return Grounded_instance;
   }
   function GroundedOptimized() {
-    this.s3m_1 = 'argumentLabelling :-\n    groundedLabelling.\ngroundedLabelling :-\n    findall(t, evaluateIn, I),\n    findall(t, evaluateOut, O),\n    finalize(I, O).\nevaluateIn :-\n    argument_to_evaluate(A, IdA),\n    allAttacksOUT(IdA),\n    context_assert(in(A)),\n    context_assert(inId(IdA)).\nevaluateOut :-\n    argument_to_evaluate(A, IdA),\n    oneAttackIN(IdA),\n    context_assert(out(A)),\n    context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n    argument_to_evaluate(A, _),\n    context_assert(und(A)),\n    fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n    context_check(clause(arg(IdX), argument(X))),\n    \\+ context_check(outId(IdX)),\n    \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n    \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n    context_check(clause(att(B, A), _)),\n    context_check(inId(B)), !.\noneAttackIN(A) :-\n    context_check(clause(att(A, B), _)),\n    context_check(inId(B)), !.';
+    this.q3o_1 = 'argumentLabelling :-\n    groundedLabelling.\ngroundedLabelling :-\n    findall(t, evaluateIn, I),\n    findall(t, evaluateOut, O),\n    finalize(I, O).\nevaluateIn :-\n    argument_to_evaluate(A, IdA),\n    allAttacksOUT(IdA),\n    context_assert(in(A)),\n    context_assert(inId(IdA)).\nevaluateOut :-\n    argument_to_evaluate(A, IdA),\n    oneAttackIN(IdA),\n    context_assert(out(A)),\n    context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n    argument_to_evaluate(A, IdA),\n    context_assert(und(A)),\n    context_assert(undId(IdA)),\n    fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n    context_check(clause(arg(IdX), argument(X))),\n    \\+ context_check(outId(IdX)),\n    \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n    \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n    context_check(clause(att(B, A), _)),\n    context_check(inId(B)), !.';
   }
   var GroundedOptimized_instance;
   function GroundedOptimized_getInstance() {
     return GroundedOptimized_instance;
   }
   function Preferences() {
-    this.u3l_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkStandardPreference(T, A, B, C)\n    ), _).\ncheckStandardPreference(T, A, B, C) :-\n    \\+ standardPreferences(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).';
+    this.s3n_1 = 'modifyArgumentationGraph :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        checkStandardPreference(T, A, B, C)\n    ), _).\ncheckStandardPreference(T, A, B, C) :-\n    \\+ standardPreferences(T, A, B, C),\n    standard_af::removeAttack(T, A, B, C).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).';
   }
   var Preferences_instance;
   function Preferences_getInstance() {
     return Preferences_instance;
   }
   function QueryMode_0() {
-    this.d3n_1 = 'computeStatementAcceptance(Goal, Res) :-\n    computeStatementAcceptance(Goal),\n    mineResults(Goal, Res).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    computeStatementAcceptance(Goal),\n    mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal) :-\n    \\+ queryMode,\n    abstract:::computeGlobalAcceptance.\ncomputeStatementAcceptance(Goal) :-\n    queryMode,\n    findall(_, buildSubGraph(Goal, _), _),\n    graphBuildMode(X),\n    X:::buildAttacks,\n    abstract:::modifyGraph,\n    abstract:::buildArgumentLabelling,\n    abstract:::buildStatementLabelling.\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n    findall(Goal, context_check(statIn([Goal])), In),\n    findall(Goal, context_check(statOut([Goal])), Out),\n    findall(Goal, context_check(statUnd([Goal])), Und),\n    utils::sort(In, YesResult),\n    utils::sort(Out, NoResult),\n    utils::sort(Und, UndResult).\nmineResults(Goal, Result) :-\n    findall(in(Goal), context_check(statIn([Goal])), In),\n    findall(out(Goal), context_check(statOut([Goal])), Out),\n    findall(und(Goal), context_check(statUnd([Goal])), Und),\n    utils::appendLists([In, Out, Und], Result).\nground_vars(Term, Grounded) :-\n    copy_term(Term, Copy),\n    ground_vars(Copy, Grounded, 0, _).\nground_vars(Var, var, N0, N) :-\n    var(Var), !,\n    N is N0 + 1.\nground_vars(Term, Grounded, N0, N) :-\n    compound(Term), !,\n    Term =.. [F|Args],\n    ground_vars_list(Args, GArgs, N0, N),\n    Grounded =.. [F|GArgs].\nground_vars(Term, Term, N, N) :-\n    atomic(Term).\nground_vars_list([], [], N, N).\nground_vars_list([X|Xs], [GX|GXs], N0, N) :-\n    ground_vars(X, GX, N0, N1),\n    ground_vars_list(Xs, GXs, N1, N).\nbuildSubGraph(Query, Argument) :-\n    ground_vars(Query, Normalized),\n    \\+ context_check(explored(Normalized)),\n    findall(_, (\n        findSingleArgument([Query], Argument, Support),\n        saveArgument(query, [Query], Argument),\n        saveSupports(Argument, Support),\n        attack::findPossibleAttackers(Argument, [Conflict]),\n        buildSubGraph(Conflict, _)\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildSubGraph(Query, Argument) :- context_check(clause(conc([Query]), argument(Argument))).\nfindSingleArgument(Query, Argument, Support) :-\n    findArgument(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises], Support),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nfindArgument(Conclusion, _, [], [AllRules, TopRule, LastDefRules, DefRules, DefPremises], []) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]).\nfindArgument(Conclusion, Ids, Conclusions, [AllRules, TopRule, LastDefRules, DefRules, DefPremises], Support) :-\n    parser::rule(Id, Premises, Conclusion),\n    findPremises(Premises, [Id|Ids], Conclusions, ResRules, Support),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]).\nfindPremises([], _, [], [[], [], [], []], []).\nfindPremises([H|T], Ids, TConclusions, TRules, TSupport) :-\n    parser::prolog([H], Term), !,\n    findPremises(T, Ids, TConclusions, TRules, TSupport),\n    (callable(Term) -> call(Term); Term).\nfindPremises([H|T], Ids, [H|TConclusions], TRules, TSupport) :-\n    parser::contrary([H], _), !,\n    findPremises(T, Ids, TConclusions, TRules, TSupport).\nfindPremises([H|T], Ids, [PP|TConclusions], Rules, [[AllRules, P, [PP], HConclusions, [LastDefRules, DefRules, DefPremises]]|TSupport]) :-\n    findPremises(T, Ids, TConclusions, TRules, TSupport),\n    buildSubGraph(H, [AllRules, P, [PP], HConclusions, [LastDefRules, DefRules, DefPremises]]),\n    mergeRules([AllRules, [], LastDefRules, DefRules, DefPremises], TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n    [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n    [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n   utils::appendLists([HAR, TAR], AR),\n   utils::appendLists([HLDR, TLDR], LDR),\n   utils::appendLists([HDR, TDR], DR),\n   utils::appendLists([HDP, TDP], DP).\nsaveArgument(T, Conclusion, Argument) :-\n    \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n    context_assert(newConc(T, Conclusion)),\n    utils::hash(argument(Argument), Id),\n    context_assert(argument(Argument)),\n    context_assert(conc(Conclusion) :- argument(Argument)),\n    context_assert(arg(Id) :- argument(Argument)).\nsaveSupports(_, []).\nsaveSupports(A, [B|T]) :-\n    saveSupport(B, A),\n    saveSupports(A, T).\nsaveSupport(A, B) :-\n    \\+ context_check(support(A, B)),\n    context_assert(support(A, B)).\nquery(Query, Res) :-\n    buildArgument(Query, Argument),\n    once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == yes,\n    bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == und,\n    ambiguityCheck(Argument, Attacker, Res),\n    bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n    attack::expanded_conflict(ConclusionA, ConclusionB).\nambiguityCheck(A, B, no) :- ambiguityBlocking,\n    \\+ complementary(A, B),\n    context_check(attack(direct, B, A, _)), !.\nambiguityCheck(_, _, und).\ndefend(Argument, QueryChain, und) :-\n    findAttacker(Argument, QueryChain, Attacker, no),\n    bufferResult(Argument, und), !.\ndefend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\nbufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\nbufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\nbufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\nbufferResult(_, _).\nfindAttacker(Target, QueryChain, Attacker, IsValid) :-\n    attacker(Target, Attacker, Type),\n    bufferAttacker(Attacker, Target, Type),\n    detectCycle(Attacker, QueryChain, IsValid).\nbufferAttacker(Attacker, Target, Type) :-\n    \\+ context_check(attack(Type, Attacker, Target, none)),\n    context_assert(attack(Type, Attacker, Target, none)), !.\nbufferAttacker(_, _, _).\ndetectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\ndetectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Rules),\n    \\+ parser::strict(X),\n    attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Groundings),\n    attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattackerOnRule(Rule, _, Argument, undercut) :-\n    parser::undercut(Undercut, Rule),\n    buildArgument(Undercut, Argument).\nattackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n    \\+ parser::contrary(Term, _),\n    \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n    (graphExtension(rebutRestriction) ->\n        (\n            getSubArgument(Term, TargetRules, SubArgument),\n            rebutRestriction(SubArgument)\n        );\n        true\n    ),\n    attack::expanded_conflict(Term, [X]),\n    buildArgument(X, Attacker),\n    (graphExtension(standardPref) ->\n        (\n            once(getSubArgument(Term, TargetRules, SubArgument)),\n            \\+ superiorArgument(SubArgument, Attacker)\n        );\n        true\n    ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n    parser::contrary(Unless, X),\n    buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction),\n    TopRule \\= none,\n    rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n    superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n    context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n    contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n    \\+ context_check(explored(Query)),\n    findall(_, (\n        buildSingleArgument([Query], Argument),\n        context_assert(argument(Argument))\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n    build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::rule(Id, Premises, Conclusion),\n    \\+ member(Id, Ids),\n    buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n    build([H], Ids, HConclusions, HRules),\n    buildPremises(T, Ids, TConclusions, TRules),\n    utils::appendLists([HConclusions, TConclusions], Conclusions),\n    mergeRules(HRules, TRules, Rules).';
+    this.b3p_1 = 'computeStatementAcceptance(Goal, Res) :-\n    computeStatementAcceptance(Goal),\n    mineResults(Goal, Res).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    computeStatementAcceptance(Goal),\n    mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal) :-\n    \\+ queryMode,\n    abstract:::computeGlobalAcceptance.\ncomputeStatementAcceptance(Goal) :-\n    queryMode,\n    findall(_, buildSubGraph(Goal, _), _),\n    graphBuildMode(X),\n    X:::buildAttacks,\n    abstract:::modifyGraph,\n    abstract:::buildArgumentLabelling,\n    abstract:::buildStatementLabelling.\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n    findall(Goal, context_check(statIn([Goal])), In),\n    findall(Goal, context_check(statOut([Goal])), Out),\n    findall(Goal, context_check(statUnd([Goal])), Und),\n    utils::sort(In, YesResult),\n    utils::sort(Out, NoResult),\n    utils::sort(Und, UndResult).\nmineResults(Goal, Result) :-\n    findall(in(Goal), context_check(statIn([Goal])), In),\n    findall(out(Goal), context_check(statOut([Goal])), Out),\n    findall(und(Goal), context_check(statUnd([Goal])), Und),\n    utils::appendLists([In, Out, Und], Result).\nground_vars(Term, Grounded) :-\n    copy_term(Term, Copy),\n    ground_vars(Copy, Grounded, 0, _).\nground_vars(Var, var, N0, N) :-\n    var(Var), !,\n    N is N0 + 1.\nground_vars(Term, Grounded, N0, N) :-\n    compound(Term), !,\n    Term =.. [F|Args],\n    ground_vars_list(Args, GArgs, N0, N),\n    Grounded =.. [F|GArgs].\nground_vars(Term, Term, N, N) :-\n    atomic(Term).\nground_vars_list([], [], N, N).\nground_vars_list([X|Xs], [GX|GXs], N0, N) :-\n    ground_vars(X, GX, N0, N1),\n    ground_vars_list(Xs, GXs, N1, N).\nbuildSubGraph(Query, Argument) :-\n    ground_vars(Query, Normalized),\n    \\+ context_check(explored(Normalized)),\n    findall(_, (\n        findSingleArgument([Query], Argument, Support),\n        saveArgument(query, [Query], Argument),\n        saveSupports(Argument, Support),\n        attack::findPossibleAttackers(Argument, [Conflict]),\n        buildSubGraph(Conflict, _)\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildSubGraph(Query, Argument) :- context_check(clause(conc([Query]), argument(Argument))).\nfindSingleArgument(Query, Argument, Support) :-\n    findArgument(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises], Support),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nfindArgument(Conclusion, _, [], [AllRules, TopRule, LastDefRules, DefRules, DefPremises], []) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]).\nfindArgument(Conclusion, Ids, Conclusions, [AllRules, TopRule, LastDefRules, DefRules, DefPremises], Support) :-\n    parser::rule(Id, Premises, Conclusion),\n    findPremises(Premises, [Id|Ids], Conclusions, ResRules, Support),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]).\nfindPremises([], _, [], [[], [], [], []], []).\nfindPremises([H|T], Ids, TConclusions, TRules, TSupport) :-\n    parser::prolog([H], Term), !,\n    findPremises(T, Ids, TConclusions, TRules, TSupport),\n    (callable(Term) -> call(Term); Term).\nfindPremises([H|T], Ids, [H|TConclusions], TRules, TSupport) :-\n    parser::contrary([H], _), !,\n    findPremises(T, Ids, TConclusions, TRules, TSupport).\nfindPremises([H|T], Ids, [PP|TConclusions], Rules, [[AllRules, P, [PP], HConclusions, [LastDefRules, DefRules, DefPremises]]|TSupport]) :-\n    findPremises(T, Ids, TConclusions, TRules, TSupport),\n    buildSubGraph(H, [AllRules, P, [PP], HConclusions, [LastDefRules, DefRules, DefPremises]]),\n    mergeRules([AllRules, [], LastDefRules, DefRules, DefPremises], TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n    [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n    [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n   utils::appendLists([HAR, TAR], AR),\n   utils::appendLists([HLDR, TLDR], LDR),\n   utils::appendLists([HDR, TDR], DR),\n   utils::appendLists([HDP, TDP], DP).\nsaveArgument(T, Conclusion, Argument) :-\n    \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n    context_assert(newConc(T, Conclusion)),\n    utils::hash(argument(Argument), Id),\n    context_assert(argument(Argument)),\n    context_assert(conc(Conclusion) :- argument(Argument)),\n    context_assert(arg(Id) :- argument(Argument)).\nsaveSupports(_, []).\nsaveSupports(A, [B|T]) :-\n    saveSupport(B, A),\n    saveSupports(A, T).\nsaveSupport(A, B) :-\n    \\+ context_check(support(A, B)),\n    context_assert(support(A, B)).\nquery(Query, Res) :-\n    buildArgument(Query, Argument),\n    once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == yes,\n    bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == und,\n    ambiguityCheck(Argument, Attacker, Res),\n    bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n    attack::expanded_conflict(ConclusionA, ConclusionB).\nambiguityCheck(A, B, no) :- ambiguityBlocking,\n    \\+ complementary(A, B),\n    context_check(attack(direct, B, A, _)), !.\nambiguityCheck(_, _, und).\ndefend(Argument, QueryChain, und) :-\n    findAttacker(Argument, QueryChain, Attacker, no),\n    bufferResult(Argument, und), !.\ndefend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\nbufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\nbufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\nbufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\nbufferResult(_, _).\nfindAttacker(Target, QueryChain, Attacker, IsValid) :-\n    attacker(Target, Attacker, Type),\n    bufferAttacker(Attacker, Target, Type),\n    detectCycle(Attacker, QueryChain, IsValid).\nbufferAttacker(Attacker, Target, Type) :-\n    \\+ context_check(attack(Type, Attacker, Target, none)),\n    context_assert(attack(Type, Attacker, Target, none)), !.\nbufferAttacker(_, _, _).\ndetectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\ndetectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Rules),\n    \\+ parser::strict(X),\n    attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n    member(X, Groundings),\n    attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattackerOnRule(Rule, _, Argument, undercut) :-\n    parser::undercut(Undercut, Rule),\n    buildArgument(Undercut, Argument).\nattackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n    \\+ parser::contrary(Term, _),\n    \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n    (graphExtension(rebutRestriction) ->\n        (\n            getSubArgument(Term, TargetRules, SubArgument),\n            rebutRestriction(SubArgument)\n        );\n        true\n    ),\n    attack::expanded_conflict(Term, [X]),\n    buildArgument(X, Attacker),\n    (graphExtension(standardPref) ->\n        (\n            once(getSubArgument(Term, TargetRules, SubArgument)),\n            \\+ superiorArgument(SubArgument, Attacker)\n        );\n        true\n    ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n    parser::contrary(Unless, X),\n    buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction),\n    TopRule \\= none,\n    rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n    superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n    context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n    contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n    \\+ context_check(explored(Query)),\n    findall(_, (\n        buildSingleArgument([Query], Argument),\n        context_assert(argument(Argument))\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n    build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::rule(Id, Premises, Conclusion),\n    \\+ member(Id, Ids),\n    buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n    build([H], Ids, HConclusions, HRules),\n    buildPremises(T, Ids, TConclusions, TRules),\n    utils::appendLists([HConclusions, TConclusions], Conclusions),\n    mergeRules(HRules, TRules, Rules).';
   }
   var QueryMode_instance_0;
   function QueryMode_getInstance_0() {
     return QueryMode_instance_0;
   }
   function RuleTranslator() {
-    this.a3n_1 = "/*\n *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n *  or (Name : Effects) and then if:\n *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n *  - It is a bp rule, translate it to (abstractBp([Effects]))\n *  During the process, clean them from the unallowed symbols (-, o, p).\n */\nconvertAllRules(ArgRules) :-\n    defeasibleRules(DefeasibleRules),\n    strictRules(StrictRules, RulesIds),\n    ordinaryPremises(Premises),\n    axiomPremises(Axioms, AxiomsIds),\n    specialRules(SpecialRules),\n    utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms], Rules),\n    rule_to_clause(Rules, Clauses),\n    findall(sup(X, Y), sup(X, Y), Sup),\n    utils::appendLists([Clauses, AxiomsIds, RulesIds, Sup, SpecialRules], ArgRules),\n    utils::assert_all(ArgRules), !.\ndefeasibleRules(DefeasibleRules) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n    prologDefeasibleRules(DefeasibleRulesNew),\n    utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\nstrictRules(CtrRules, Ids) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n    prologStrictRules(StrictRulesNew),\n    utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n    transpose(StrictRules, StrictRules, CtrRules),\n    extract_id(CtrRules, Ids).\nordinaryPremises(Premises) :-\n    findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n    prologPremises(PremisesNew),\n    utils::append_fast(PremisesOld, PremisesNew, Premises).\naxiomPremises(Axioms, Ids) :-\n    findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n    prologAxioms(AxiomsNew),\n    utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n    extract_id(Axioms, Ids).\nspecialRules(SpecialRules) :-\n    bpsNew(SpecialRules).\ntranspose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\ntranspose([], CtrRules, CtrRules).\ntranspose([H|T], TempCtrRules, CtrRules) :-\n    transpose(T, TempCtrRules, CR),\n    findall(TrH, transposition(H, TrH), Tran),\n    mergeCtrRules(CR, Tran, CtrRules).\nmergeCtrRules(All, ToMerge, X) :-\n    utils::append_fast(All, ToMerge, XT),\n    deduplicate(XT, X).\ndeduplicate([], []).\ndeduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \ntransposition([Id, Prec, Effect], [Id, Prec, Effect]).\ntransposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n    compound(Prec),\n    tuple_to_list(Prec, LPrec),!,\n    transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\ntransposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n    \\+ compound(Prec),\n    Prec \\== [],\n    prologEscape(Prec),\n    negate(Prec, XNegated),\n    negate(Effect, EffectNegated),\n    atom_concat(Id, '_i', NewId).\ntransposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\ntransposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    prologEscape(X),\n    utils::append_fast(Skipped, T, CleanedPrec),\n    negate(X, XNegated),\n    negate(Effect, EffectNegated),\n    list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n    newIdentifier(Skipped, Id, NewId).\nnewIdentifier(List, OldId, NewId) :-\n    modifier(List, Mod),\n    atom_concat(OldId, Mod, NewId).\nmodifier([], '_i').\nmodifier([_|Tail], Index):-\n    modifier(Tail, Index1),\n    atom_concat(Index1, 'i', Index).\nnegate(X, Arg) :-\n    functor(X, '-', _) -> (\n        arg(1, X, Arg));\n    functor(X, 'p', _) -> (\n        arg(1, X, PX),\n        (functor(PX, '-', _) -> (\n            arg(1, PX, PNX),\n            Arg = o(PNX)\n        );\n        Arg = o(-(PX))));\n    Arg = -(X).\nprologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n/*\n *   Standard rules (RuleName : Preconditions => Effects)\n *   Special rules (RuleName : Effects)\n */\nconvertAllRules([], []).\nconvertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\nconvertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n/*\n *   Convert the given rule to the standard format\n *   Example:\n *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n */\nconvertRule(RuleName, Preconditions, Effects, rule(List)) :-\n    tuple_to_list(Preconditions, Lprecond),\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n    List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n/*\n *   Convert the given special rule\n *   Example:\n *   bp(-liable(X)).\n *   abastractBp([[neg, liable(X_e4149)]]).\n */\nconvertRule(bps, Effects, abstractBp(Checked)) :-\n    functor(Effects, 'bp', _),\n    Effects =.. L,\n    removehead(L, LC),\n    check_modifiers_in_list(effects, LC, Checked), !.\nconvertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n/*\n *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n *   raplace them with the assigned literal (neg, obl, perm)\n */\ncheck_modifiers_in_list(MODE, [], []) :- !.\ncheck_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\ncheck_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n                            check_modifiers_once(H, LH),\n                            check_modifiers_in_list(MODE, T, LT),\n                            utils::append_fast([LH], LT, L),\n                            R = L.\ncheck_modifiers_once(H, List) :- once(check_modifiers(H, List)).\ncheck_modifiers([], []).\ncheck_modifiers(H, List) :-\n    functor(H, '-', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        utils::append_fast([neg], Lobl, Lf),\n        List = Lf);\n    functor(H, 'o', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        List = [obl|[Lobl]]);\n    functor(H, 'p', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [perm|[Lper]]);\n    functor(H, '~', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [unless|[Lper]]);\n    functor(H, 'bp', _) -> (\n        H =.. [_|Arg],\n        check_modifiers_in_list(effects, Arg, Lper),\n        List = [bp|[Lper]]);\n    List = [H].\nlist_to_tuple([H], (H)) :- !.\nlist_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n/*\n *   Replace all the occurences of a given element with the given argument\n */\nreplace(_, _, [],[]) :- !.\nreplace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\nreplace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\nflatten_first_level([X], X) :- !.\nflatten_first_level.\nremovehead([_|Tail], Tail).\nin(A, A) :- nonvar(A), A \\= (_ , _), !.\nin(A, (A, _)) :- !.\nin(A, (_ , Cs)) :- in(A, Cs).\ncheck_admissibility(preconditions, H, LH) :-\n    \\+ defeasible_admissible(LH),\n    throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(effects, H, LH) :-\n    \\+ admissible(LH),\n    throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(_, _, _).\ndefeasible_admissible([unless, Term]) :- admissible(Term).\ndefeasible_admissible(Term) :- admissible(Term).\nadmissible([neg, bp, Term]) :- admissible_terms_complete(Term).\nadmissible([bp, Term]) :- admissible_terms_complete(Term).\nadmissible([neg, Term]) :- admissible_term(Term).\nadmissible([obl, [Term]]) :- admissible_term(Term).\nadmissible([obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([perm, [Term]]) :- admissible_term(Term).\nadmissible([perm, [neg, Term]]) :- admissible_term(Term).\nadmissible([Term]) :- admissible_term(Term).\nadmissible_term(Term) :-\n    atomic(Term),\n    Term \\== neg,\n    Term \\== obl,\n    Term \\== perm,\n    Term \\== unless,\n    Term \\== bp.\nadmissible_term(Term) :- var(Term).\nadmissible_term(Term) :-\n    compound(Term),\n    \\+ functor(Term, 'o', _),\n    \\+ functor(Term, 'p', _),\n    \\+ functor(Term, '-', _),\n    \\+ functor(Term, '~', _),\n    \\+ functor(Term, 'bp', _),\n    Term =.. [_|Args],\n    admissible_terms(Args).\nadmissible_terms([]).\nadmissible_terms([H|T]) :-\n    admissible_term(H),\n    admissible_terms(T).\nadmissible_terms_complete([]).\nadmissible_terms_complete([H|T]) :-\n    admissible(H),\n    admissible_terms_complete(T).\nrule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\npremise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\ncheck_strict(Id) :- context_check(strict(Id)).\nprolog([prolog(Term)], Term).\ncontrary([~(Term)], Term).\nundercut(undercut(Rule), Rule).\nsuperiority(sup(Id1, Id2), Id1, Id2).\n/*\n *   Convert the given tuple to list\n */\ntuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\ntuple_to_list((A,B),L) :-\n    tuple_to_list(A, La),\n    tuple_to_list(B, Lb),\n    utils::append_fast(La, Lb,L).\nff([[]], []) :- !.\nff([[X]], [X]) :- !.\nff(X, X).\nclassic_rule(X, [applicable(X)|Y], Z) :- metaRules, !, rule(X, Y, Z).\nclassic_rule(X, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).\nclassic_conflict([A], [B], C) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B, C)]), _)).\nclassic_conflict([A], [B]) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B)]), _)).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    member(conflict(A, B, C), [\n        conflict([Atom], [-Atom], (Atom \\= -_)),\n        conflict([-Atom], [Atom], true),\n        conflict([o(Atom)], [o(-Atom)], (Atom \\= -_)),                   % O(x) <-> O(-x)\n        conflict([o(-Atom)], [o(Atom)], true),\n        conflict([p(Atom)], [o(-Atom)], (Atom \\= -_)),                   % P(x) <-> O(-x)\n        conflict([o(-Atom)], [p(Atom)], true),\n        conflict([o(Atom)], [p(-Atom)], (Atom \\= -_)),                   % O(x) <-> P(-x)\n        conflict([p(-Atom)], [o(Atom)], true),\n        conflict([o(Atom)], [-p(Atom)], true),                           % O(x) <-> O(-x) (-P(x))\n        conflict([-p(Atom)], [o(Atom)], true),\n        conflict([sup(X, Y)], [sup(Y, X)], true)\n    ]).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    conflict(A, B, C).\nclassic_conflict(A, B) :-\n    \\+ metaConflicts,\n    conflict(A, B).";
+    this.y3o_1 = "/*\n *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n *  or (Name : Effects) and then if:\n *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n *  - It is a bp rule, translate it to (abstractBp([Effects]))\n *  During the process, clean them from the unallowed symbols (-, o, p).\n */\nconvertAllRules(ArgRules) :-\n    defeasibleRules(DefeasibleRules),\n    strictRules(StrictRules, RulesIds),\n    ordinaryPremises(Premises),\n    axiomPremises(Axioms, AxiomsIds),\n    specialRules(SpecialRules),\n    utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms], Rules),\n    rule_to_clause(Rules, Clauses),\n    findall(sup(X, Y), sup(X, Y), Sup),\n    utils::appendLists([Clauses, AxiomsIds, RulesIds, Sup, SpecialRules], ArgRules),\n    utils::assert_all(ArgRules), !.\ndefeasibleRules(DefeasibleRules) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n    prologDefeasibleRules(DefeasibleRulesNew),\n    utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\nstrictRules(CtrRules, Ids) :-\n    findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n    prologStrictRules(StrictRulesNew),\n    utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n    transpose(StrictRules, StrictRules, CtrRules),\n    extract_id(CtrRules, Ids).\nordinaryPremises(Premises) :-\n    findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n    prologPremises(PremisesNew),\n    utils::append_fast(PremisesOld, PremisesNew, Premises).\naxiomPremises(Axioms, Ids) :-\n    findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n    prologAxioms(AxiomsNew),\n    utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n    extract_id(Axioms, Ids).\nspecialRules(SpecialRules) :-\n    bpsNew(SpecialRules).\ntranspose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\ntranspose([], CtrRules, CtrRules).\ntranspose([H|T], TempCtrRules, CtrRules) :-\n    transpose(T, TempCtrRules, CR),\n    findall(TrH, transposition(H, TrH), Tran),\n    mergeCtrRules(CR, Tran, CtrRules).\nmergeCtrRules(All, ToMerge, X) :-\n    utils::append_fast(All, ToMerge, XT),\n    deduplicate(XT, X).\ndeduplicate([], []).\ndeduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \ntransposition([Id, Prec, Effect], [Id, Prec, Effect]).\ntransposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n    compound(Prec),\n    tuple_to_list(Prec, LPrec),!,\n    transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\ntransposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n    \\+ compound(Prec),\n    Prec \\== [],\n    prologEscape(Prec),\n    negate(Prec, XNegated),\n    negate(Effect, EffectNegated),\n    atom_concat(Id, '_i', NewId).\ntransposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\ntransposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n    prologEscape(X),\n    utils::append_fast(Skipped, T, CleanedPrec),\n    negate(X, XNegated),\n    negate(Effect, EffectNegated),\n    list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n    newIdentifier(Skipped, Id, NewId).\nnewIdentifier(List, OldId, NewId) :-\n    modifier(List, Mod),\n    atom_concat(OldId, Mod, NewId).\nmodifier([], '_i').\nmodifier([_|Tail], Index):-\n    modifier(Tail, Index1),\n    atom_concat(Index1, 'i', Index).\nnegate(X, Arg) :-\n    functor(X, '-', _) -> (\n        arg(1, X, Arg));\n    functor(X, 'p', _) -> (\n        arg(1, X, PX),\n        (functor(PX, '-', _) -> (\n            arg(1, PX, PNX),\n            Arg = o(PNX)\n        );\n        Arg = o(-(PX))));\n    Arg = -(X).\nprologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n/*\n *   Standard rules (RuleName : Preconditions => Effects)\n *   Special rules (RuleName : Effects)\n */\nconvertAllRules([], []).\nconvertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\nconvertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n/*\n *   Convert the given rule to the standard format\n *   Example:\n *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n */\nconvertRule(RuleName, Preconditions, Effects, rule(List)) :-\n    tuple_to_list(Preconditions, Lprecond),\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n    List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n/*\n *   Convert the given special rule\n *   Example:\n *   bp(-liable(X)).\n *   abastractBp([[neg, liable(X_e4149)]]).\n */\nconvertRule(bps, Effects, abstractBp(Checked)) :-\n    functor(Effects, 'bp', _),\n    Effects =.. L,\n    removehead(L, LC),\n    check_modifiers_in_list(effects, LC, Checked), !.\nconvertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n    tuple_to_list(Effects, Leffects),\n    check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n    flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n/*\n *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n *   raplace them with the assigned literal (neg, obl, perm)\n */\ncheck_modifiers_in_list(MODE, [], []) :- !.\ncheck_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\ncheck_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n                            check_modifiers_once(H, LH),\n                            check_modifiers_in_list(MODE, T, LT),\n                            utils::append_fast([LH], LT, L),\n                            R = L.\ncheck_modifiers_once(H, List) :- once(check_modifiers(H, List)).\ncheck_modifiers([], []).\ncheck_modifiers(H, List) :-\n    functor(H, '-', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        utils::append_fast([neg], Lobl, Lf),\n        List = Lf);\n    functor(H, 'o', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lobl),\n        List = [obl|[Lobl]]);\n    functor(H, 'p', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [perm|[Lper]]);\n    functor(H, '~', _) -> (\n        arg(1, H, Arg),\n        check_modifiers_once(Arg, Lper),\n        List = [unless|[Lper]]);\n    functor(H, 'bp', _) -> (\n        H =.. [_|Arg],\n        check_modifiers_in_list(effects, Arg, Lper),\n        List = [bp|[Lper]]);\n    List = [H].\nlist_to_tuple([H], (H)) :- !.\nlist_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n/*\n *   Replace all the occurences of a given element with the given argument\n */\nreplace(_, _, [],[]) :- !.\nreplace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\nreplace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\nflatten_first_level([X], X) :- !.\nflatten_first_level.\nremovehead([_|Tail], Tail).\nin(A, A) :- nonvar(A), A \\= (_ , _), !.\nin(A, (A, _)) :- !.\nin(A, (_ , Cs)) :- in(A, Cs).\ncheck_admissibility(preconditions, H, LH) :-\n    \\+ defeasible_admissible(LH),\n    throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(effects, H, LH) :-\n    \\+ admissible(LH),\n    throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\ncheck_admissibility(_, _, _).\ndefeasible_admissible([unless, Term]) :- admissible(Term).\ndefeasible_admissible(Term) :- admissible(Term).\nadmissible([neg, bp, Term]) :- admissible_terms_complete(Term).\nadmissible([bp, Term]) :- admissible_terms_complete(Term).\nadmissible([neg, Term]) :- admissible_term(Term).\nadmissible([obl, [Term]]) :- admissible_term(Term).\nadmissible([obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([perm, [Term]]) :- admissible_term(Term).\nadmissible([perm, [neg, Term]]) :- admissible_term(Term).\nadmissible([Term]) :- admissible_term(Term).\nadmissible_term(Term) :-\n    atomic(Term),\n    Term \\== neg,\n    Term \\== obl,\n    Term \\== perm,\n    Term \\== unless,\n    Term \\== bp.\nadmissible_term(Term) :- var(Term).\nadmissible_term(Term) :-\n    compound(Term),\n    \\+ functor(Term, 'o', _),\n    \\+ functor(Term, 'p', _),\n    \\+ functor(Term, '-', _),\n    \\+ functor(Term, '~', _),\n    \\+ functor(Term, 'bp', _),\n    Term =.. [_|Args],\n    admissible_terms(Args).\nadmissible_terms([]).\nadmissible_terms([H|T]) :-\n    admissible_term(H),\n    admissible_terms(T).\nadmissible_terms_complete([]).\nadmissible_terms_complete([H|T]) :-\n    admissible(H),\n    admissible_terms_complete(T).\nrule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\npremise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\ncheck_strict(Id) :- context_check(strict(Id)).\nprolog([prolog(Term)], Term).\ncontrary([~(Term)], Term).\nundercut(undercut(Rule), Rule).\nsuperiority(sup(Id1, Id2), Id1, Id2).\n/*\n *   Convert the given tuple to list\n */\ntuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\ntuple_to_list((A,B),L) :-\n    tuple_to_list(A, La),\n    tuple_to_list(B, Lb),\n    utils::append_fast(La, Lb,L).\nff([[]], []) :- !.\nff([[X]], [X]) :- !.\nff(X, X).\nclassic_rule(X, [applicable(X)|Y], Z) :- metaRules, !, rule(X, Y, Z).\nclassic_rule(X, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).\nclassic_conflict([A], [B], C) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B, C)]), _)).\nclassic_conflict([A], [B]) :- metaConflicts,\n    context_check(clause(conc([conflict(A, B)]), _)).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    member(conflict(A, B, C), [\n        conflict([Atom], [-Atom], (Atom \\= -_)),\n        conflict([-Atom], [Atom], true),\n        conflict([o(Atom)], [o(-Atom)], (Atom \\= -_)),                   % O(x) <-> O(-x)\n        conflict([o(-Atom)], [o(Atom)], true),\n        conflict([p(Atom)], [o(-Atom)], (Atom \\= -_)),                   % P(x) <-> O(-x)\n        conflict([o(-Atom)], [p(Atom)], true),\n        conflict([o(Atom)], [p(-Atom)], (Atom \\= -_)),                   % O(x) <-> P(-x)\n        conflict([p(-Atom)], [o(Atom)], true),\n        conflict([o(Atom)], [-p(Atom)], true),                           % O(x) <-> O(-x) (-P(x))\n        conflict([-p(Atom)], [o(Atom)], true),\n        conflict([sup(X, Y)], [sup(Y, X)], true)\n    ]).\nclassic_conflict(A, B, C) :-\n    \\+ metaConflicts,\n    conflict(A, B, C).\nclassic_conflict(A, B) :-\n    \\+ metaConflicts,\n    conflict(A, B).";
   }
   var RuleTranslator_instance;
   function RuleTranslator_getInstance() {
     return RuleTranslator_instance;
   }
   function StatementLabelling() {
-    this.w3m_1 = 'statementLabelling :-\n    findall(_, (\n        context_check(in([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        context_assert(statIn(Conc))\n    ), _),\n    findall(_, (\n        context_check(out([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        context_assert(statOut(Conc))\n    ), _),\n    findall(_, (\n        context_check(und([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        \\+ context_check(statUnd(Conc)),\n        context_assert(statUnd(Conc))\n    ), _).';
+    this.u3o_1 = 'statementLabelling :-\n    findall(_, (\n        context_check(in([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        context_assert(statIn(Conc))\n    ), _),\n    findall(_, (\n        context_check(out([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        context_assert(statOut(Conc))\n    ), _),\n    findall(_, (\n        context_check(und([_, _, Conc, _, _])),\n        \\+ context_check(statIn(Conc)),\n        \\+ context_check(statOut(Conc)),\n        \\+ context_check(statUnd(Conc)),\n        context_assert(statUnd(Conc))\n    ), _).';
   }
   var StatementLabelling_instance;
   function StatementLabelling_getInstance() {
     return StatementLabelling_instance;
   }
   function SuperiorityRelation() {
-    this.e3n_1 = 'superiorArgument(A, B) :- superiorArgumentSupportBuffered(A, B, _).\nsuperiorArgument(A, B, SupSet) :- superiorArgumentSupportBuffered(A, B, SupSet).\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, false)),\n    fail, !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ context_check(superior(A, B, _, _)),\n    superiorArgumentSupport(A, B, SupSet),\n    context_assert(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ cache_check(superior(A, B, _, _)),\n    context_assert(superior(A, B, [], false)),\n    fail, !.\nsuperiorArgumentSupport([_, _, _, _, [LastDefRulesA, DefRulesA, DefPremisesA]], [_, _, _, _, [LastDefRulesB, DefRulesB, DefPremisesB]], SupSet) :-\n\tsuperiorArgumentSupport(LastDefRulesA, DefRulesA, DefPremisesA, LastDefRulesB, DefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(LastDefRulesA, _, DefPremisesA, LastDefRulesB, _, DefPremisesB, SupSet) :-\n    orderingPrinciple(last),\n\tsuperior(LastDefRulesA, DefPremisesA, LastDefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(_, DefRulesA, DefPremisesA, _, DefRulesB, DefPremisesB, SupSet) :-\n    orderingPrinciple(weakest),\n\tsuperior(DefRulesA, DefPremisesA, DefRulesB, DefPremisesB, SupSet).\nsuperior([], PremisesA, [], PremisesB, SupSet) :-\n\tweaker(PremisesB, PremisesA, SupSet).\nsuperior(DefRulesA, _, DefRulesB, _, SupSet) :-\n\torderingPrinciple(last),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, [], DefRulesB, [], SupSet) :-\n\torderingPrinciple(weakest),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, PremisesA, DefRulesB, PremisesB, SupSet) :-\n\torderingPrinciple(weakest),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\t(PremisesA \\== []; PremisesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSetA),\n\tweaker(PremisesB, PremisesA, SupSetB),\n\tutils::appendLists([SupSetA, SupSetB], SupSet).\nweaker(RulesA, [], []) :-\n\tRulesA \\== [].\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(elitist),\n\tmember(Rule, RulesA),\n\tallStronger(Rule, RulesB, SupSet), !.\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(democrat),\n\tweakerDemo(RulesA, RulesB, SupSet).\nweaker(RulesA, RulesB, [sup(X, W)]) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(normal),\n\tmember(W, RulesA),\n\tmember(X, RulesB),\n\tcontext_check(sup(X, W)), !.\nweakerDemo([], _, []).\nweakerDemo([H|T], Rules, [Sup|SupSet]) :-\n\tsingleStronger(H, Rules, Sup),\n\tweakerDemo(T, Rules, SupSet).\nsingleStronger(Target, Rules, sup(Rule, Target)) :-\n\tmember(Rule, Rules),\n\tcontext_check(sup(Rule, Target)), !.\nallStronger(_, [], []).\nallStronger(Target, [Rule|Rules], [sup(Rule, Target)|SupSet]) :-\n\tcontext_check(sup(Rule, Target)),\n\tallStronger(Target, Rules, SupSet).';
+    this.c3p_1 = 'superiorArgument(A, B) :- superiorArgumentSupportBuffered(A, B, _).\nsuperiorArgument(A, B, SupSet) :- superiorArgumentSupportBuffered(A, B, SupSet).\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    context_check(superior(A, B, SupSet, false)),\n    fail, !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ context_check(superior(A, B, _, _)),\n    superiorArgumentSupport(A, B, SupSet),\n    context_assert(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n    \\+ cache_check(superior(A, B, _, _)),\n    context_assert(superior(A, B, [], false)),\n    fail, !.\nsuperiorArgumentSupport([_, _, _, _, [LastDefRulesA, DefRulesA, DefPremisesA]], [_, _, _, _, [LastDefRulesB, DefRulesB, DefPremisesB]], SupSet) :-\n\tsuperiorArgumentSupport(LastDefRulesA, DefRulesA, DefPremisesA, LastDefRulesB, DefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(LastDefRulesA, _, DefPremisesA, LastDefRulesB, _, DefPremisesB, SupSet) :-\n    orderingPrinciple(last),\n\tsuperior(LastDefRulesA, DefPremisesA, LastDefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(_, DefRulesA, DefPremisesA, _, DefRulesB, DefPremisesB, SupSet) :-\n    orderingPrinciple(weakest),\n\tsuperior(DefRulesA, DefPremisesA, DefRulesB, DefPremisesB, SupSet).\nsuperior([], PremisesA, [], PremisesB, SupSet) :-\n\tweaker(PremisesB, PremisesA, SupSet).\nsuperior(DefRulesA, _, DefRulesB, _, SupSet) :-\n\torderingPrinciple(last),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, [], DefRulesB, [], SupSet) :-\n\torderingPrinciple(weakest),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, PremisesA, DefRulesB, PremisesB, SupSet) :-\n\torderingPrinciple(weakest),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\t(PremisesA \\== []; PremisesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSetA),\n\tweaker(PremisesB, PremisesA, SupSetB),\n\tutils::appendLists([SupSetA, SupSetB], SupSet).\nweaker(RulesA, [], []) :-\n\tRulesA \\== [].\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(elitist),\n\tmember(Rule, RulesA),\n\tallStronger(Rule, RulesB, SupSet), !.\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(democrat),\n\tweakerDemo(RulesA, RulesB, SupSet).\nweaker(RulesA, RulesB, [sup(X, W)]) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(normal),\n\tmember(W, RulesA),\n\tmember(X, RulesB),\n\tcontext_check(sup(X, W)), !.\nweakerDemo([], _, []).\nweakerDemo([H|T], Rules, [Sup|SupSet]) :-\n\tsingleStronger(H, Rules, Sup),\n\tweakerDemo(T, Rules, SupSet).\nsingleStronger(Target, Rules, sup(Rule, Target)) :-\n\tmember(Rule, Rules),\n\tcontext_check(sup(Rule, Target)), !.\nallStronger(_, [], []).\nallStronger(Target, [Rule|Rules], [sup(Rule, Target)|SupSet]) :-\n\tcontext_check(sup(Rule, Target)),\n\tallStronger(Target, Rules, SupSet).';
   }
   var SuperiorityRelation_instance;
   function SuperiorityRelation_getInstance() {
     return SuperiorityRelation_instance;
   }
   function Utils() {
-    this.f3n_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nsortDistinct(List, Sorted) :-\n    deduplicate(List, Deduplicated),\n    sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n    List \\== [],\n    setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n    H @>= X,\n    pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n    X @> H,\n    pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n        member(Head, L2), !,\n        subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n        subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n    appendLists(T, AT),\n    append_fast(H, AT, R).\nsearch(F, L, S) :-\n   between(1, L, N),\n   functor(S, F, N),\n   call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n        findall(X, context_check(argument(X)), TempArgs),\n        findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n        findall((A, B), context_check(support(A, B)), TempSupports),\n        utils::sort(TempArgs, Args),\n        utils::sort(TempAttacks, Attacks),\n        utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(in(X)), TempArgsIn),\n        findall(X, context_check(out(X)), TempArgsOut),\n        findall(X, context_check(und(X)), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n        findall(X, context_check(statIn(X)), TempIn),\n        findall(X, context_check(statOut(X)), TempOut),\n        findall(X, context_check(statUnd(X)), TempUnd),\n        utils::sort(TempIn, In),\n        utils::sort(TempOut, Out),\n        utils::sort(TempUnd, Und).';
+    this.d3p_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nintersection(Sets, Intersection) :-\n    once(member(X, Sets)),\n    findall(Y, (\n        member(Y, X),\n        \\+ (\n            member(Set, Sets),\n            \\+ member(Y, Set)\n        )\n    ), Intersection).\nsortDistinct(List, Sorted) :-\n    deduplicate(List, Deduplicated),\n    sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n    List \\== [],\n    setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n    H @>= X,\n    pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n    X @> H,\n    pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n        member(Head, L2), !,\n        subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n        subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n    appendLists(T, AT),\n    append_fast(H, AT, R).\nsearch(F, L, S) :-\n   between(1, L, N),\n   functor(S, F, N),\n   call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n        findall(X, context_check(argument(X)), TempArgs),\n        findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n        findall((A, B), context_check(support(A, B)), TempSupports),\n        utils::sort(TempArgs, Args),\n        utils::sort(TempAttacks, Attacks),\n        utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(in(X)), TempArgsIn),\n        findall(X, context_check(out(X)), TempArgsOut),\n        findall(X, context_check(und(X)), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n        findall(X, context_check(statIn(X)), TempIn),\n        findall(X, context_check(statOut(X)), TempOut),\n        findall(X, context_check(statUnd(X)), TempUnd),\n        utils::sort(TempIn, In),\n        utils::sort(TempOut, Out),\n        utils::sort(TempUnd, Und).\nrecoverArgumentLabellingId(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(inId(X)), TempArgsIn),\n        findall(X, context_check(outId(X)), TempArgsOut),\n        findall(X, context_check(undId(X)), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).\nrecoverArgumentLabellingAbstract(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(in([_, _, [X], _, _])), TempArgsIn),\n        findall(X, context_check(out([_, _, [X], _, _])), TempArgsOut),\n        findall(X, context_check(und([_, _, [X], _, _])), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).';
   }
   var Utils_instance;
   function Utils_getInstance() {
@@ -4622,7 +4985,7 @@
     StructuredModeBase.call(this);
   }
   protoOf(StructuredMode).b3a = function () {
-    return QueryMode_instance_0.d3n_1;
+    return QueryMode_instance_0.b3p_1;
   };
   var StructuredMode_instance;
   function StructuredMode_getInstance() {
@@ -4635,7 +4998,7 @@
     AttackRelationBase.call(this);
   }
   protoOf(AttackRelation_0).b3a = function () {
-    return AttackRelation_instance.b3n_1;
+    return AttackRelation_instance.z3o_1;
   };
   var AttackRelation_instance_0;
   function AttackRelation_getInstance_0() {
@@ -4648,7 +5011,7 @@
     DebugBase.call(this);
   }
   protoOf(Debug_0).b3a = function () {
-    return Debug_instance.c3n_1;
+    return Debug_instance.a3p_1;
   };
   var Debug_instance_0;
   function Debug_getInstance_0() {
@@ -4661,7 +5024,7 @@
     SuperiorityRelationBase.call(this);
   }
   protoOf(SuperiorityRelation_0).b3a = function () {
-    return SuperiorityRelation_instance.e3n_1;
+    return SuperiorityRelation_instance.c3p_1;
   };
   var SuperiorityRelation_instance_0;
   function SuperiorityRelation_getInstance_0() {
@@ -4674,7 +5037,7 @@
     UtilsBase.call(this);
   }
   protoOf(Utils_0).b3a = function () {
-    return Utils_instance.f3n_1;
+    return Utils_instance.d3p_1;
   };
   var Utils_instance_0;
   function Utils_getInstance_0() {