@tuprolog/arg2p-core 0.6.0 → 0.6.3

package/kotlin/arg2p-core.js

@@ -108,6 +108,7 @@
   var Random = Kotlin.kotlin.random.Random;
   var toTerm = $module$_2p_core.it.unibo.tuprolog.core.listToTerm;
   var UnaryPredicate$WithoutSideEffects = $module$_2p_solve.it.unibo.tuprolog.solve.primitive.UnaryPredicate.WithoutSideEffects;
+  var BinaryRelation$WithoutSideEffects = $module$_2p_solve.it.unibo.tuprolog.solve.primitive.BinaryRelation.WithoutSideEffects;
   var copyToArray = Kotlin.kotlin.collections.copyToArray;
   var AliasedLibrary = $module$_2p_solve.it.unibo.tuprolog.solve.library.AliasedLibrary;
   var compareBy = Kotlin.kotlin.comparisons.compareBy_bvgy4j$;
@@ -167,6 +168,8 @@
   DefeasibleRules.prototype.constructor = DefeasibleRules;
   Bps.prototype = Object.create(UnaryPredicate$WithoutSideEffects.prototype);
   Bps.prototype.constructor = Bps;
+  ExtractStrictIds.prototype = Object.create(BinaryRelation$WithoutSideEffects.prototype);
+  ExtractStrictIds.prototype.constructor = ExtractStrictIds;
   StructuredModeBase.prototype = Object.create(LazyRawPrologContent.prototype);
   StructuredModeBase.prototype.constructor = StructuredModeBase;
   DebugBase.prototype = Object.create(LazyRawPrologContent.prototype);
@@ -3077,7 +3080,9 @@
         return $receiver.descriptionPair;
       }.bind(null, Premises_getInstance())).get(), getPropertyCallableRef('descriptionPair', 0, function ($receiver) {
         return $receiver.descriptionPair;
-      }.bind(null, DefeasibleRules_getInstance())).get()]), this.prologTheory, RuleParserBase$Companion_getInstance().operators());
+      }.bind(null, DefeasibleRules_getInstance())).get(), getPropertyCallableRef('descriptionPair', 0, function ($receiver) {
+        return $receiver.descriptionPair;
+      }.bind(null, ExtractStrictIds_getInstance())).get()]), this.prologTheory, RuleParserBase$Companion_getInstance().operators());
     }
   });
   Object.defineProperty(RuleParserBase.prototype, 'baseFlags', {
@@ -3147,7 +3152,7 @@
     return 'prologStrictCompatibility';
   };
   PrologStrictCompatibility.prototype.default = function () {
-    return true;
+    return false;
   };
   PrologStrictCompatibility.prototype.values = function () {
     return Unit;
@@ -3414,6 +3419,35 @@
       new Bps();
     }return Bps_instance;
   }
+  function ExtractStrictIds() {
+    ExtractStrictIds_instance = this;
+    BinaryRelation$WithoutSideEffects.call(this, 'extract_id');
+  }
+  ExtractStrictIds.prototype.computeAllSubstitutions_2j1e5m$ = function ($receiver, first, second) {
+    var tmp$ = Substitution.Companion;
+    var tmp$_0 = ensureNotNull(second.asVar());
+    var tmp$_1 = List.Companion;
+    var $receiver_0 = ensureNotNull(first.asList()).toList();
+    var destination = ArrayList_init(collectionSizeOrDefault($receiver_0, 10));
+    var tmp$_2;
+    tmp$_2 = $receiver_0.iterator();
+    while (tmp$_2.hasNext()) {
+      var item = tmp$_2.next();
+      destination.add_11rb$(Struct.Companion.of('strict', [ensureNotNull(item.asCons()).head]));
+    }
+    return sequenceOf([tmp$.of(tmp$_0, tmp$_1.ofList(destination))]);
+  };
+  ExtractStrictIds.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'ExtractStrictIds',
+    interfaces: [BinaryRelation$WithoutSideEffects]
+  };
+  var ExtractStrictIds_instance = null;
+  function ExtractStrictIds_getInstance() {
+    if (ExtractStrictIds_instance === null) {
+      new ExtractStrictIds();
+    }return ExtractStrictIds_instance;
+  }
   function StructuredModeBase() {
     LazyRawPrologContent.call(this);
     this.alias_k0m5up$_0 = 'prolog.argumentation.structured';
@@ -3631,7 +3665,11 @@
   Object.defineProperty(UtilsBase.prototype, 'baseContent', {
     configurable: true,
     get: function () {
-      return Library.Companion.aliased(this.alias, void 0, this.prologTheory);
+      var tmp$, tmp$_0, tmp$_1;
+      tmp$_1 = Library.Companion;
+      tmp$ = this.alias;
+      tmp$_0 = this.prologTheory;
+      return tmp$_1.aliased(tmp$, mapOf_0([to(AppendOptimized_getInstance().signature, AppendOptimized_getInstance()), to(AssertAll_getInstance().signature, AssertAll_getInstance())]), tmp$_0);
     }
   });
   Object.defineProperty(UtilsBase.prototype, 'baseFlags', {
@@ -3654,6 +3692,172 @@
     simpleName: 'UtilsBase',
     interfaces: [Loadable, LazyRawPrologContent, ArgLibrary]
   };
+  function AppendOptimized() {
+    AppendOptimized_instance = this;
+    this.signature = new Signature('append_fast', 3);
+  }
+  function Coroutine$AppendOptimized$solve$lambda(closure$request_0, closure$res_0, closure$list1_0, closure$list2_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$closure$res = closure$res_0;
+    this.local$closure$list1 = closure$list1_0;
+    this.local$closure$list2 = closure$list2_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$AppendOptimized$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$AppendOptimized$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$AppendOptimized$solve$lambda.prototype.constructor = Coroutine$AppendOptimized$solve$lambda;
+  Coroutine$AppendOptimized$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(this.local$closure$request.replyWith(Substitution.Companion.of(this.local$closure$res, List.Companion.ofList(plus(this.local$closure$list1.toList(), this.local$closure$list2.toList()))), void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function AppendOptimized$solve$lambda(closure$request_0, closure$res_0, closure$list1_0, closure$list2_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$AppendOptimized$solve$lambda(closure$request_0, closure$res_0, closure$list1_0, closure$list2_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  AppendOptimized.prototype.solve = function (request) {
+    var list1 = request.arguments.get_za3lpa$(0);
+    var list2 = request.arguments.get_za3lpa$(1);
+    var res = request.arguments.get_za3lpa$(2);
+    if (!Kotlin.isType(list1, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list1);
+    }if (!Kotlin.isType(list2, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list2);
+    }if (!Kotlin.isType(res, Var)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.VARIABLE, res);
+    }return sequence(AppendOptimized$solve$lambda(request, res, list1, list2));
+  };
+  AppendOptimized.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'AppendOptimized',
+    interfaces: [Primitive]
+  };
+  var AppendOptimized_instance = null;
+  function AppendOptimized_getInstance() {
+    if (AppendOptimized_instance === null) {
+      new AppendOptimized();
+    }return AppendOptimized_instance;
+  }
+  function AssertAll() {
+    AssertAll_instance = this;
+    this.signature = new Signature('assert_all', 1);
+  }
+  function AssertAll$solve$lambda(closure$list, closure$request) {
+    return function ($receiver) {
+      var $receiver_0 = closure$list.toSequence();
+      var tmp$;
+      tmp$ = $receiver_0.iterator();
+      while (tmp$.hasNext()) {
+        var element = tmp$.next();
+        first(closure$request.solve($receiver.stringInvoke('context_assert', element, [])));
+      }
+      return Unit;
+    };
+  }
+  function Coroutine$AssertAll$solve$lambda(closure$request_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$AssertAll$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$AssertAll$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$AssertAll$solve$lambda.prototype.constructor = Coroutine$AssertAll$solve$lambda;
+  Coroutine$AssertAll$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(this.local$closure$request.replyWithCondition(true, void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function AssertAll$solve$lambda_0(closure$request_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$AssertAll$solve$lambda(closure$request_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  AssertAll.prototype.solve = function (request) {
+    var list = request.arguments.get_za3lpa$(0);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }arg2pScope(AssertAll$solve$lambda(list, request));
+    return sequence(AssertAll$solve$lambda_0(request));
+  };
+  AssertAll.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'AssertAll',
+    interfaces: [Primitive]
+  };
+  var AssertAll_instance = null;
+  function AssertAll_getInstance() {
+    if (AssertAll_instance === null) {
+      new AssertAll();
+    }return AssertAll_instance;
+  }
   function MetaInterpreterLib() {
     MetaInterpreterLib_instance = this;
     this.$delegate_3wovwi$_0 = Library.Companion.aliased('prolog.argumentation.meta', void 0, parse_2(Theory.Companion, trimIndent('\n        % with_facts_and_length/3\n        with_facts_and_length(X, Y, L) :-\n            solve(X, R),\n            recover_facts(R, Y),\n            length(Y, L).\n\n        % lenght/2\n\n        length([], 0).\n        length([_|T], X) :- length(T, Y), X is Y + 1.\n\n        % recover_facts/2\n\n        recover_facts([], []) :- !.\n        recover_facts([H|T], C) :-\n            is_list(H), !,\n            recover_facts(T, TC),\n            recover_facts(H, HC),\n            append(TC, HC, C).\n        recover_facts([H|T], C) :-\n            \\+ is_list(H),\n            recover_facts(T, TC),\n            evaluate(H, HC),\n            append(TC, HC, C).\n\n        evaluate(user_fact(X), [X]) :- !.\n        evaluate(_, []) :- !.\n\n        % solve/2\n\n        solve((A,B), Result) :- !,\n            solve(A, ARes),\n            solve(B, BRes),\n            append(ARes, BRes, Result).\n\n        solve((A;B), Result) :- !,\n            solve(A, Result);\n            solve(B, Result).\n\n        solve(member(A, B), [system_predicate]) :- !,\n            call(member(A, B)).\n\n        solve(\\+(A), [not(A)]) :- !,\n            call(\\+(A)).\n\n        solve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n            call((A)\\=(B)).\n\n        solve(A, [system_predicate]) :-\n            catch(clause(A, _), B, true),\n            \\+ var(B), !,\n            call(A).\n\n        solve(A, [A]) :-\n            \\+ clause(A, B), !,\n            call(A).\n\n        solve(A, [A|[Res]]) :-\n            clause(A, B),\n            solve(B, Res).\n\n        % is_list/1\n\n        is_list(X) :- var(X), !, fail.\n        is_list([]).\n        is_list([_|T]) :- is_list(T).\n        \n        % fetch_argument_facts/2\n        \n        fetch_argument_facts(Conclusion, Facts) :-\n            argument([R, TR, [Conclusion]]),\n            findall(user_fact(Fact), \n                support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n            Facts).\n        ')));
@@ -4681,7 +4885,7 @@
   }
   function ArgumentationGraph() {
     ArgumentationGraph_instance = this;
-    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tfindall([RuleID, RuleBody, RuleHead], context_check(rule([RuleID, RuleBody, RuleHead])), Rules),\n    \tbuildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                context_check(premise([PremiseID, Premise])),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromRules(Rules, [], n).\n    buildArgumentsFromRules(Rules, [], y) :- buildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromRules(Rules, [H|T], _) :-\n        copy_term(H, HH),\n        buildArgumentsFromRule(HH),\n        buildArgumentsFromRules(Rules, T, y), !.\n    buildArgumentsFromRules(Rules, [_|T], X) :-\n        buildArgumentsFromRules(Rules, T, X).\n    buildArgumentsFromRule([RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleBody, [], [], SupportRules, ArgSupports),\n    \t\\+ member(RuleID, SupportRules),\n    \tground(RuleHead),\n    \tutils::sort([RuleID|SupportRules], SortedPremises),\n    \t\\+ context_check(argument([SortedPremises, RuleID, RuleHead, RuleBody, _])),\n    \tbuildArgumentInfo(ArgSupports, RuleID, Info),\n        NewArgument = [SortedPremises, RuleID, RuleHead, RuleBody, Info],\n    \tcontext_assert(argument(NewArgument)),\n    \tsupports(NewArgument, ArgSupports).\n    supports(Argument, Supports) :-\n        findall(_, (\n            member(S, Supports),\n            context_assert(support(S, Argument))\n        ), _).\n    checkStrict(Id, [Id]) :- \\+ context_check(strict(Id)).\n    checkStrict(Id, []) :- context_check(strict(Id)).\n    buildArgumentInfo(Supports, RuleId, [LastDefRules, DefRules, DefPrem]) :-\n        defeasibleRules(RuleId, Supports, DefRules),\n        ordinaryPremises(Supports, DefPrem),\n        lastDefeasibleRules(Supports, RuleId, LastDefRules).\n    ordinaryPremises(Supports, DefPrem) :-\n        findall(Def, member([_, _, _, _, [_, _, Def]], Supports), Prem),\n        utils::appendLists(Prem, TempPrem),\n        utils::sortDistinct(TempPrem, DefPrem).\n    defeasibleRules(RuleId, Supports, DefRules) :-\n    \tfindall(Def, member([_, _, _, _, [_, Def, _]], Supports), UnsortedRules),\n    \tcheckStrict(RuleId, DefRule),\n    \tutils::appendLists([DefRule|UnsortedRules], TempRules),\n    \tutils::sortDistinct(TempRules, DefRules).\n    lastDefeasibleRules(_, TopRule, [TopRule]) :-\n        TopRule \\== none, \\+ context_check(strict(TopRule)).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tcontext_check(strict(TopRule)),\n    \tfindall(Def, member([_, _, _, _, [Def, _, _]], Supports), Res),\n    \tutils::appendLists(Res, TempLastRules),\n    \tutils::sortDistinct(TempLastRules, LastRules).\n    ruleBodyIsSupported([], ResultPremises, ResultSupports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [unless, _] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [prolog(Check)] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([Statement|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n        context_check(argument([ArgumentID, RuleID, Statement, Body, Info])),\n    \tappend(ArgumentID, Premises, NewPremises),\n    \truleBodyIsSupported(Others, NewPremises, [[ArgumentID, RuleID, Statement, Body, Info]|Supports], ResultPremises, ResultSupports).\n    buildAttacks :-\n        findall(X, context_check(argument(X)), Args),\n    \tbuildDirectAttacks(Args),\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks([]).\n    buildDirectAttacks([H|T]) :-\n        findall(_, buildDirectAttack(H), _),\n        buildDirectAttacks(T).\n    buildDirectAttack(A) :-\n    \tcontext_check(argument(B)),\n    \tA \\== B,\n        attacks(T, A, B),\n    \t\\+ context_check(attack(T, A, B, B)),\n    \tcontext_assert(attack(T, A, B, B)).\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    conflict( [Atom], [neg, Atom]).\n    conflict( [neg, Atom], [Atom]).\n    conflict( [obl, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, Lit],  [neg, obl, Lit]).\n    conflict( [neg, obl, Lit],  [obl, Lit]).\n    conflict( [perm, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [perm, [Atom]]).\n    conflict( [perm, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, [Atom]],  [perm, [neg, Atom]]).\n    conflict([bp, Atom], [neg, bp, Atom]).\n    conflict([neg, bp, Atom], [bp, Atom]).\n    conflict([sup(X, Y)],  [sup(Y, X)]).\n        ');
+    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tbuildArgumentsFromEmptyRules,\n    \tfindall([RuleID, RuleBody, RuleHead], (\n    \t    context_check(rule([RuleID, RuleBody, RuleHead])),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n    \tbuildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                context_check(premise([PremiseID, Premise])),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromEmptyRules :-\n        findall(\n            _,\n            (\n                emptyRule([RuleID, RulePrem, RuleHead]),\n                checkStrict(RuleID, DefRule),\n                ground(RuleHead),\n                context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, [], RuleHead]) :-\n        context_check(rule([RuleID, [], RuleHead])).\n    emptyRule([RuleID, [[unless, X]], RuleHead]) :-\n        context_check(rule([RuleID, [[unless, X]], RuleHead])).\n    emptyRule([RuleID, [[prolog(Check)]], RuleHead]) :-\n        context_check(rule([RuleID, [[prolog(Check)]], RuleHead])),\n        (callable(Check) -> call(Check); Check).\n    buildArgumentsFromRules(Rules, [], n).\n    buildArgumentsFromRules(Rules, [], y) :- buildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromRules(Rules, [H|T], _) :-\n        copy_term(H, HH),\n        buildArgumentsFromRule(HH),\n        buildArgumentsFromRules(Rules, T, y), !.\n    buildArgumentsFromRules(Rules, [_|T], X) :-\n        buildArgumentsFromRules(Rules, T, X).\n    buildArgumentsFromRule([RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleBody, [], [], SupportRules, ArgSupports),\n    \t\\+ member(RuleID, SupportRules),\n    \tground(RuleHead),\n    \tutils::sort([RuleID|SupportRules], SortedPremises),\n    \t\\+ context_check(argument([SortedPremises, RuleID, RuleHead, RuleBody, _])),\n    \tbuildArgumentInfo(ArgSupports, RuleID, Info),\n        NewArgument = [SortedPremises, RuleID, RuleHead, RuleBody, Info],\n    \tcontext_assert(argument(NewArgument)),\n    \tsupports(NewArgument, ArgSupports).\n    supports(Argument, Supports) :-\n        findall(_, (\n            member(S, Supports),\n            context_assert(support(S, Argument))\n        ), _).\n    checkStrict(Id, [Id]) :- \\+ context_check(strict(Id)).\n    checkStrict(Id, []) :- context_check(strict(Id)).\n    buildArgumentInfo(Supports, RuleId, [LastDefRules, DefRules, DefPrem]) :-\n        defeasibleRules(RuleId, Supports, DefRules),\n        ordinaryPremises(Supports, DefPrem),\n        lastDefeasibleRules(Supports, RuleId, LastDefRules).\n    ordinaryPremises(Supports, DefPrem) :-\n        findall(Def, member([_, _, _, _, [_, _, Def]], Supports), Prem),\n        utils::appendLists(Prem, TempPrem),\n        utils::sortDistinct(TempPrem, DefPrem).\n    defeasibleRules(RuleId, Supports, DefRules) :-\n    \tfindall(Def, member([_, _, _, _, [_, Def, _]], Supports), UnsortedRules),\n    \tcheckStrict(RuleId, DefRule),\n    \tutils::appendLists([DefRule|UnsortedRules], TempRules),\n    \tutils::sortDistinct(TempRules, DefRules).\n    lastDefeasibleRules(_, TopRule, [TopRule]) :-\n        TopRule \\== none, \\+ context_check(strict(TopRule)).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tcontext_check(strict(TopRule)),\n    \tfindall(Def, member([_, _, _, _, [Def, _, _]], Supports), Res),\n    \tutils::appendLists(Res, TempLastRules),\n    \tutils::sortDistinct(TempLastRules, LastRules).\n    ruleBodyIsSupported([], ResultPremises, ResultSupports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [unless, _] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [prolog(Check)] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([Statement|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n        context_check(argument([ArgumentID, RuleID, Statement, Body, Info])),\n    \tappend(ArgumentID, Premises, NewPremises),\n    \truleBodyIsSupported(Others, NewPremises, [[ArgumentID, RuleID, Statement, Body, Info]|Supports], ResultPremises, ResultSupports).\n    findPossibleAttackers([_, _, Head, _, _], [_, _, Conf, _, _]) :-\n        conflict(Head, Conf).\n    findPossibleAttackers([_, _, _, Prem, _], [_, _, Conf, _, _]) :-\n        member([unless, Conf], Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [_, _, [undercut(RuleID)], _, _]).\n    buildAttacks :-\n        findall(X, context_check(argument(X)), Args),\n    \tbuildDirectAttacks(Args),\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks([]).\n    buildDirectAttacks([H|T]) :-\n        findall(_, buildDirectAttack(H), _),\n        buildDirectAttacks(T).\n    buildDirectAttack(A) :-\n    \tcontext_check(argument(B)),\n    \tA \\== B,\n        attacks(T, B, A),\n    \t\\+ context_check(attack(T, B, A, A)),\n    \tcontext_assert(attack(T, B, A, A)).\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    conflict( [Atom], [neg, Atom]).\n    conflict( [neg, Atom], [Atom]).\n    conflict( [obl, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, Lit],  [neg, obl, Lit]).\n    conflict( [neg, obl, Lit],  [obl, Lit]).\n    conflict( [perm, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [perm, [Atom]]).\n    conflict( [perm, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, [Atom]],  [perm, [neg, Atom]]).\n    conflict([bp, Atom], [neg, bp, Atom]).\n    conflict([neg, bp, Atom], [bp, Atom]).\n    conflict([sup(X, Y)],  [sup(Y, X)]).\n        ');
   }
   ArgumentationGraph.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4861,7 +5065,7 @@
   }
   function QueryMode_0() {
     QueryMode_instance_0 = this;
-    this.theoryCode = trimIndent('\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        \\+ queryMode,\n        abstract:::computeGlobalAcceptance,\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        queryMode,\n        argumentLabellingMode(grounded),\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(_, query(X, _), _),\n        (ambiguityBlocking ->\n            statement_binary:::statementLabelling;\n            statementLabellingMode(Y),\n            Y:::statementLabelling\n        ),\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    mineResults(Goal, YesResult, NoResult, UndResult) :-\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(Goal, context_check(statIn(X)), In),\n        findall(Goal, context_check(statOut(X)), Out),\n        findall(Goal, context_check(statUnd(X)), Und),\n        utils::sort(In, YesResult),\n        utils::sort(Out, NoResult),\n        utils::sort(Und, UndResult).\n    query(Query, Res) :-\n        buildArgument(Query, Argument),\n        once(defend(Argument, [], Res)).\n    query(Query, und) :- \\+ buildArgument(Query, _).\n    defend(Argument, _, no) :- context_check(out(Argument)).\n    defend(Argument, _, und) :- context_check(und(Argument)).\n    defend(Argument, _, yes) :- context_check(in(Argument)).\n    defend(Argument, QueryChain, no) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == yes,\n        bufferResult(Argument, no), !.\n    defend(Argument, QueryChain, Res) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == und,\n        ambiguityCheck(Argument, Attacker, Res),\n        bufferResult(Argument, Res), !.\n    complementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n        standard_af::conflict(ConclusionA, ConclusionB).\n    ambiguityCheck(A, B, no) :- ambiguityBlocking,\n        \\+ complementary(A, B),\n        context_check(attack(direct, B, A, _)), !.\n    ambiguityCheck(_, _, und).\n    defend(Argument, QueryChain, und) :-\n        findAttacker(Argument, QueryChain, Attacker, no),\n        bufferResult(Argument, und), !.\n    defend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\n    bufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\n    bufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\n    bufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\n    bufferResult(_, _).\n    findAttacker(Target, QueryChain, Attacker, IsValid) :-\n        attacker(Target, Attacker, Type),\n        bufferAttacker(Attacker, Target, Type),\n        detectCycle(Attacker, QueryChain, IsValid).\n    bufferAttacker(Attacker, Target, Type) :-\n        \\+ context_check(attack(Type, Attacker, Target, none)),\n        context_assert(attack(Type, Attacker, Target, none)), !.\n    bufferAttacker(_, _, _).\n    detectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\n    detectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Rules),\n        \\+ context_check(strict(X)),\n        attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Groundings),\n        attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attackerOnRule(Rule, _, Argument, undercut) :-\n        buildArgument([undercut(Rule)], Argument).\n    attackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n        Term \\= [unless, _],\n        \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n        (graphExtension(rebutRestriction) ->\n            (\n                buildSubArgument(Term, TargetRules, SubArgument),\n                rebutRestriction(SubArgument)\n            );\n            true\n        ),\n        standard_af::conflict(Term, X),\n        buildArgument(X, Attacker),\n        (graphExtension(standardPref) ->\n            (ground(SubArgument) ->\n                true;\n                buildSubArgument(Term, TargetRules, SubArgument)\n            ),\n            \\+ superiorArgument(SubArgument, Attacker);\n            true\n        ).\n    attackerOnTerm([unless, X], _, Attacker, contrary) :-\n        buildArgument(X, Attacker).\n    strict([_, _, _, _, [_, [], []]]).\n    rebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction).\n    rebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction),\n        TopRule \\= none,\n        rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\n    rebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\n    superiorArgument(SubArgument, Attacker) :-\n        superiority::superiorArgument(SubArgument, Attacker).\n    buildSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n        buildArgument(Term, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]),\n        contained(SubRules, Rules).\n    contained([], _).\n    contained([H|T], Target) :- member(H, Target), contained(T, Target).\n    buildArgument(Query, Argument) :-\n        \\+ context_check(explored(Query)),\n        findall(_, (\n            buildSingleArgument(Query, Argument),\n            context_assert(argument(Argument))\n        ), _),\n        context_assert(explored(Query)),\n        fail.\n    buildArgument(Query, [R, T, Query, B, I]) :- context_check(argument([R, T, Query, B, I])).\n    buildSingleArgument(Query, Argument) :-\n        build(Query, Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n        utils::deduplicate(DefRules, CDefRules),\n        utils::deduplicate(DefPremises, CDefPremises),\n        utils::deduplicate(Groundings, CGroundings),\n        Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\n    build(Conclusion, [Conclusion], Rules) :-\n        context_check(premise([Id, Conclusion])),\n        premiseRules(Id, Rules).\n    build(Conclusion, [Conclusion|Conclusions], Rules) :-\n        context_check(rule([Id, Premises, Conclusion])),\n        buildPremises(Premises, Conclusions, ResRules),\n        ruleRules(Id, ResRules, Rules).\n    build([prolog(Check)], [], []) :- (callable(Check) -> call(Check); Check).\n    build([unless, Atom], [[unless, Atom]], []).\n    buildPremises([], [], [[], [], [], []]).\n    buildPremises([H|T], Conclusions, Rules) :-\n        build(H, HConclusions, HRules),\n        buildPremises(T, TConclusions, TRules),\n        utils::appendLists([HConclusions, TConclusions], Conclusions),\n        mergeRules(HRules, TRules, Rules).\n    premiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ context_check(strict(Id)).\n    premiseRules(Id, [[Id], none, [], [], []]) :- context_check(strict(Id)).\n    ruleRules(Id, [AllRules, _, DefRules, DefPremises], \n        [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ context_check(strict(Id)).\n    ruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises], \n        [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- context_check(strict(Id)).\n    mergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]).\n    mergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n       utils::appendLists([HAR, TAR], AR),\n       utils::appendLists([HLDR, TLDR], LDR),\n       utils::appendLists([HDR, TDR], DR),\n       utils::appendLists([HDP, TDP], DP).\n        ');
+    this.theoryCode = trimIndent('\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        \\+ queryMode,\n        abstract:::computeGlobalAcceptance,\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        queryMode,\n        argumentLabellingMode(grounded),\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(_, query(X, _), _),\n        (ambiguityBlocking ->\n            statement_binary:::statementLabelling;\n            statementLabellingMode(Y),\n            Y:::statementLabelling\n        ),\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    mineResults(Goal, YesResult, NoResult, UndResult) :-\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(Goal, context_check(statIn(X)), In),\n        findall(Goal, context_check(statOut(X)), Out),\n        findall(Goal, context_check(statUnd(X)), Und),\n        utils::sort(In, YesResult),\n        utils::sort(Out, NoResult),\n        utils::sort(Und, UndResult).\n    query(Query, Res) :-\n        buildArgument(Query, Argument),\n        once(defend(Argument, [], Res)).\n    query(Query, und) :- \\+ buildArgument(Query, _).\n    defend(Argument, _, no) :- context_check(out(Argument)).\n    defend(Argument, _, und) :- context_check(und(Argument)).\n    defend(Argument, _, yes) :- context_check(in(Argument)).\n    defend(Argument, QueryChain, no) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == yes,\n        bufferResult(Argument, no), !.\n    defend(Argument, QueryChain, Res) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == und,\n        ambiguityCheck(Argument, Attacker, Res),\n        bufferResult(Argument, Res), !.\n    complementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n        standard_af::conflict(ConclusionA, ConclusionB).\n    ambiguityCheck(A, B, no) :- ambiguityBlocking,\n        \\+ complementary(A, B),\n        context_check(attack(direct, B, A, _)), !.\n    ambiguityCheck(_, _, und).\n    defend(Argument, QueryChain, und) :-\n        findAttacker(Argument, QueryChain, Attacker, no),\n        bufferResult(Argument, und), !.\n    defend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\n    bufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\n    bufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\n    bufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\n    bufferResult(_, _).\n    findAttacker(Target, QueryChain, Attacker, IsValid) :-\n        attacker(Target, Attacker, Type),\n        bufferAttacker(Attacker, Target, Type),\n        detectCycle(Attacker, QueryChain, IsValid).\n    bufferAttacker(Attacker, Target, Type) :-\n        \\+ context_check(attack(Type, Attacker, Target, none)),\n        context_assert(attack(Type, Attacker, Target, none)), !.\n    bufferAttacker(_, _, _).\n    detectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\n    detectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Rules),\n        \\+ context_check(strict(X)),\n        attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Groundings),\n        attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attackerOnRule(Rule, _, Argument, undercut) :-\n        buildArgument([undercut(Rule)], Argument).\n    attackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n        Term \\= [unless, _],\n        \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n        (graphExtension(rebutRestriction) ->\n            (\n                buildSubArgument(Term, TargetRules, SubArgument),\n                rebutRestriction(SubArgument)\n            );\n            true\n        ),\n        standard_af::conflict(Term, X),\n        buildArgument(X, Attacker),\n        (graphExtension(standardPref) ->\n            (ground(SubArgument) ->\n                true;\n                buildSubArgument(Term, TargetRules, SubArgument)\n            ),\n            \\+ superiorArgument(SubArgument, Attacker);\n            true\n        ).\n    attackerOnTerm([unless, X], _, Attacker, contrary) :-\n        buildArgument(X, Attacker).\n    strict([_, _, _, _, [_, [], []]]).\n    rebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction).\n    rebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction),\n        TopRule \\= none,\n        rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\n    rebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\n    superiorArgument(SubArgument, Attacker) :-\n        superiority::superiorArgument(SubArgument, Attacker).\n    buildSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n        buildArgument(Term, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]),\n        contained(SubRules, Rules).\n    contained([], _).\n    contained([H|T], Target) :- member(H, Target), contained(T, Target).\n    buildArgument(Query, Argument) :-\n        \\+ context_check(explored(Query)),\n        findall(_, (\n            buildSingleArgument(Query, Argument),\n            context_assert(argument(Argument))\n        ), _),\n        context_assert(explored(Query)),\n        fail.\n    buildArgument(Query, [R, T, Query, B, I]) :- context_check(argument([R, T, Query, B, I])).\n    buildSingleArgument(Query, Argument) :-\n        build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n        utils::deduplicate(DefRules, CDefRules),\n        utils::deduplicate(DefPremises, CDefPremises),\n        utils::deduplicate(Groundings, CGroundings),\n        Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\n    build(Conclusion, _, [Conclusion], Rules) :-\n        context_check(premise([Id, Conclusion])),\n        premiseRules(Id, Rules).\n    build(Conclusion, Ids, [Conclusion|Conclusions], Rules) :-\n        context_check(rule([Id, Premises, Conclusion])),\n        \\+ member(Id, Ids),\n        buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n        ruleRules(Id, ResRules, Rules).\n    build([prolog(Check)], _, [], []) :- (callable(Check) -> call(Check); Check).\n    build([unless, Atom], _, [[unless, Atom]], []).\n    buildPremises([], _, [], [[], [], [], []]).\n    buildPremises([H|T], Ids, Conclusions, Rules) :-\n        build(H, Ids, HConclusions, HRules),\n        buildPremises(T, Ids, TConclusions, TRules),\n        utils::appendLists([HConclusions, TConclusions], Conclusions),\n        mergeRules(HRules, TRules, Rules).\n    premiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ context_check(strict(Id)).\n    premiseRules(Id, [[Id], none, [], [], []]) :- context_check(strict(Id)).\n    ruleRules(Id, [AllRules, _, DefRules, DefPremises], \n        [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ context_check(strict(Id)).\n    ruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises], \n        [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- context_check(strict(Id)).\n    mergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]).\n    mergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n       utils::appendLists([HAR, TAR], AR),\n       utils::appendLists([HLDR, TLDR], LDR),\n       utils::appendLists([HDR, TDR], DR),\n       utils::appendLists([HDP, TDP], DP).\n        ');
   }
   QueryMode_0.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4876,7 +5080,7 @@
   }
   function RuleTranslator() {
     RuleTranslator_instance = this;
-    this.theoryCode = trimIndent("\n    /*\n     *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n     *  or (Name : Effects) and then if:\n     *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n     *  - It is a bp rule, translate it to (abstractBp([Effects]))\n     *  During the process, clean them from the unallowed symbols (-, o, p).\n     */\n    convertAllRules(ArgRules) :-\n        defeasibleRules(DefeasibleRules),\n        strictRules(StrictRules, RulesIds),\n        ordinaryPremises(Premises),\n        axiomPremises(Axioms, AxiomsIds),\n        specialRules(SpecialRules),\n        utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms, SpecialRules], L),\n        convertAllRules(L, Rules), !,\n        findall(sup(X, Y), sup(X, Y), Sups),\n        utils::appendLists([Rules, AxiomsIds, RulesIds, Sups], ArgRules),\n        findall(_, (member(X, ArgRules), context_assert(X)), _).\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        append(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(CtrRules, Ids) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n        prologStrictRules(StrictRulesNew),\n        append(StrictRulesOld, StrictRulesNew, StrictRules),\n        transpose(StrictRules, StrictRules, CtrRules),\n        findall(strict(RN), member([RN, _, _], CtrRules), Ids).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        append(PremisesOld, PremisesNew, Premises).\n    axiomPremises(Axioms, Ids) :-\n        findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n        prologAxioms(AxiomsNew),\n        append(AxiomsOld, AxiomsNew, Axioms),\n        findall(strict(RN), member([RN, _], Axioms), Ids).\n    specialRules(SpecialRules) :-\n        bpsNew(SpecialRules).\n    transpose(_, CtrRules, CtrRules) :- \\+ autoTransposition. \n    transpose([], CtrRules, CtrRules).\n    transpose([H|T], TempCtrRules, CtrRules) :-\n        transpose(T, TempCtrRules, CR),\n        findall(TrH, transposition(H, TrH), Tran),\n        mergeCtrRules(CR, Tran, CtrRules).\n    mergeCtrRules(All, ToMerge, X) :-\n        append(All, ToMerge, XT),\n        deduplicate(XT, X).\n    deduplicate([], []).\n    deduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \n    transposition([Id, Prec, Effect], [Id, Prec, Effect]).\n    transposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n        compound(Prec),\n        tuple_to_list(Prec, LPrec),!,\n        transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\n    transposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n        \\+ compound(Prec),\n        Prec \\== [],\n        prologEscape(Prec),\n        negate(Prec, XNegated),\n        negate(Effect, EffectNegated),\n        atom_concat(Id, '_i', NewId).\n    transposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\n    transposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        prologEscape(X),\n        append(Skipped, T, CleanedPrec),\n        negate(X, XNegated),\n        negate(Effect, EffectNegated),\n        list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n        newIdentifier(Skipped, Id, NewId).\n    newIdentifier(List, OldId, NewId) :-\n        modifier(List, Mod),\n        atom_concat(OldId, Mod, NewId).\n    modifier([], '_i').\n    modifier([_|Tail], Index):-\n        modifier(Tail, Index1),\n        atom_concat(Index1, 'i', Index).\n    negate(X, Arg) :-\n        functor(X, '-', _) -> (\n            arg(1, X, Arg));\n        functor(X, 'p', _) -> (\n            arg(1, X, PX),\n            (functor(PX, '-', _) -> (\n                arg(1, PX, PNX),\n                Arg = o(PNX)\n            );\n            Arg = o(-(PX))));\n        Arg = -(X).\n    prologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n    /*\n     *   Standard rules (RuleName : Preconditions => Effects)\n     *   Special rules (RuleName : Effects)\n     */\n    convertAllRules([], []).\n    convertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\n    convertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n    /*\n     *   Convert the given rule to the standard format\n     *   Example:\n     *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n     *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n     */\n    convertRule(RuleName, Preconditions, Effects, rule(List)) :-\n        tuple_to_list(Preconditions, Lprecond),\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n        List = [RuleName, LprecondChecked, LeffectsCheckedFlattened].\n    /*\n     *   Convert the given special rule\n     *   Example:\n     *   bp(-liable(X)).\n     *   abastractBp([[neg, liable(X_e4149)]]).\n     */\n    convertRule(bps, Effects, abstractBp(Checked)) :-\n        functor(Effects, 'bp', _),\n        Effects =.. L,\n        removehead(L, LC),\n        check_modifiers_in_list(effects, LC, Checked).\n    convertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n    /*\n     *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n     *   raplace them with the assigned literal (neg, obl, perm)\n     */\n    check_modifiers_in_list(MODE, [], []).\n    check_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [].\n    check_modifiers_in_list(MODE, [H|T], L) :- H \\== [],\n                                check_modifiers(H, LH),\n                                check_admissibility(MODE, H, LH),\n                                check_modifiers_in_list(MODE, T, LT),\n                                append([LH], LT, L).\n    check_admissibility(preconditions, H, LH) :-\n        \\+ defeasible_admissible(LH),\n        throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(effects, H, LH) :-\n        \\+ admissible(LH),\n        throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(_, _, _).\n    check_modifiers([], []).\n    check_modifiers(H, List) :-\n        functor(H, '-', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lobl),\n            append([neg], Lobl, Lf),\n            List = Lf);\n        functor(H, 'o', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lobl),\n            List = [obl|[Lobl]]);\n        functor(H, 'p', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lper),\n            List = [perm|[Lper]]);\n        functor(H, '~', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lper),\n            List = [unless|[Lper]]);\n        functor(H, 'bp', _) -> (\n            H =.. [_|Arg],\n            check_modifiers_in_list(effects, Arg, Lper),\n            List = [bp|[Lper]]);\n        List = [H].\n    /*\n     *   Convert the given tuple to list\n     */\n    tuple_to_list((A,B),L) :- tuple_to_list(A, La), tuple_to_list(B, Lb), append(La, Lb,L).\n    tuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _).\n    list_to_tuple([H], (H)).\n    list_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n    /*\n     *   Replace all the occurences of a given element with the given argument\n     */\n    replace(_, _, [],[]).\n    replace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2).\n    replace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\n    flatten_first_level([X], X).\n    flatten_first_level.\n    removehead([_|Tail], Tail).\n    in(A, A) :- nonvar(A), A \\= (_ , _).\n    in(A, (A, _)).\n    in(A, (_ , Cs)) :- in(A, Cs).\n    defeasible_admissible([unless, Term]) :- admissible(Term).\n    defeasible_admissible(Term) :- admissible(Term).\n    admissible([neg, bp, Term]) :- admissible_terms_complete(Term).\n    admissible([bp, Term]) :- admissible_terms_complete(Term).\n    admissible([neg, Term]) :- admissible_term(Term).\n    admissible([obl, [Term]]) :- admissible_term(Term).\n    admissible([obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([perm, [Term]]) :- admissible_term(Term).\n    admissible([perm, [neg, Term]]) :- admissible_term(Term).\n    admissible([Term]) :- admissible_term(Term).\n    admissible_term(Term) :-\n        atomic(Term),\n        Term \\== neg,\n        Term \\== obl,\n        Term \\== perm,\n        Term \\== unless,\n        Term \\== bp.\n    admissible_term(Term) :- var(Term).\n    admissible_term(Term) :-\n        compound(Term),\n        \\+ functor(Term, 'o', _),\n        \\+ functor(Term, 'p', _),\n        \\+ functor(Term, '-', _),\n        \\+ functor(Term, '~', _),\n        \\+ functor(Term, 'bp', _),\n        Term =.. [_|Args],\n        admissible_terms(Args).\n    admissible_terms([]).\n    admissible_terms([H|T]) :-\n        admissible_term(H),\n        admissible_terms(T).\n    admissible_terms_complete([]).\n    admissible_terms_complete([H|T]) :-\n        admissible(H),\n        admissible_terms_complete(T).\n        ");
+    this.theoryCode = trimIndent("\n    /*\n     *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n     *  or (Name : Effects) and then if:\n     *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n     *  - It is a bp rule, translate it to (abstractBp([Effects]))\n     *  During the process, clean them from the unallowed symbols (-, o, p).\n     */\n    convertAllRules(ArgRules) :-\n        defeasibleRules(DefeasibleRules),\n        strictRules(StrictRules, RulesIds),\n        ordinaryPremises(Premises),\n        axiomPremises(Axioms, AxiomsIds),\n        specialRules(SpecialRules),\n        utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms, SpecialRules], L),\n        convertAllRules(L, Rules),\n        findall(sup(X, Y), sup(X, Y), Sup),\n        utils::appendLists([Rules, AxiomsIds, RulesIds, Sup], ArgRules),\n        utils::assert_all(ArgRules), !.\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(CtrRules, Ids) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n        prologStrictRules(StrictRulesNew),\n        utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n        transpose(StrictRules, StrictRules, CtrRules),\n        extract_id(CtrRules, Ids).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        utils::append_fast(PremisesOld, PremisesNew, Premises).\n    axiomPremises(Axioms, Ids) :-\n        findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n        prologAxioms(AxiomsNew),\n        utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n        extract_id(Axioms, Ids).\n    specialRules(SpecialRules) :-\n        bpsNew(SpecialRules).\n    transpose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\n    transpose([], CtrRules, CtrRules).\n    transpose([H|T], TempCtrRules, CtrRules) :-\n        transpose(T, TempCtrRules, CR),\n        findall(TrH, transposition(H, TrH), Tran),\n        mergeCtrRules(CR, Tran, CtrRules).\n    mergeCtrRules(All, ToMerge, X) :-\n        utils::append_fast(All, ToMerge, XT),\n        deduplicate(XT, X).\n    deduplicate([], []).\n    deduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \n    transposition([Id, Prec, Effect], [Id, Prec, Effect]).\n    transposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n        compound(Prec),\n        tuple_to_list(Prec, LPrec),!,\n        transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\n    transposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n        \\+ compound(Prec),\n        Prec \\== [],\n        prologEscape(Prec),\n        negate(Prec, XNegated),\n        negate(Effect, EffectNegated),\n        atom_concat(Id, '_i', NewId).\n    transposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\n    transposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        prologEscape(X),\n        utils::append_fast(Skipped, T, CleanedPrec),\n        negate(X, XNegated),\n        negate(Effect, EffectNegated),\n        list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n        newIdentifier(Skipped, Id, NewId).\n    newIdentifier(List, OldId, NewId) :-\n        modifier(List, Mod),\n        atom_concat(OldId, Mod, NewId).\n    modifier([], '_i').\n    modifier([_|Tail], Index):-\n        modifier(Tail, Index1),\n        atom_concat(Index1, 'i', Index).\n    negate(X, Arg) :-\n        functor(X, '-', _) -> (\n            arg(1, X, Arg));\n        functor(X, 'p', _) -> (\n            arg(1, X, PX),\n            (functor(PX, '-', _) -> (\n                arg(1, PX, PNX),\n                Arg = o(PNX)\n            );\n            Arg = o(-(PX))));\n        Arg = -(X).\n    prologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n    /*\n     *   Standard rules (RuleName : Preconditions => Effects)\n     *   Special rules (RuleName : Effects)\n     */\n    convertAllRules([], []).\n    convertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\n    convertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n    /*\n     *   Convert the given rule to the standard format\n     *   Example:\n     *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n     *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n     */\n    convertRule(RuleName, Preconditions, Effects, rule(List)) :-\n        tuple_to_list(Preconditions, Lprecond),\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n        List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n    /*\n     *   Convert the given special rule\n     *   Example:\n     *   bp(-liable(X)).\n     *   abastractBp([[neg, liable(X_e4149)]]).\n     */\n    convertRule(bps, Effects, abstractBp(Checked)) :-\n        functor(Effects, 'bp', _),\n        Effects =.. L,\n        removehead(L, LC),\n        check_modifiers_in_list(effects, LC, Checked), !.\n    convertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n    /*\n     *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n     *   raplace them with the assigned literal (neg, obl, perm)\n     */\n    check_modifiers_in_list(MODE, [], []) :- !.\n    check_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\n    check_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n                                check_modifiers_once(H, LH),\n                                check_modifiers_in_list(MODE, T, LT),\n                                utils::append_fast([LH], LT, L),\n                                R = L.\n    check_modifiers_once(H, List) :- once(check_modifiers(H, List)).\n    check_modifiers([], []).\n    check_modifiers(H, List) :-\n        functor(H, '-', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lobl),\n            utils::append_fast([neg], Lobl, Lf),\n            List = Lf);\n        functor(H, 'o', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lobl),\n            List = [obl|[Lobl]]);\n        functor(H, 'p', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lper),\n            List = [perm|[Lper]]);\n        functor(H, '~', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lper),\n            List = [unless|[Lper]]);\n        functor(H, 'bp', _) -> (\n            H =.. [_|Arg],\n            check_modifiers_in_list(effects, Arg, Lper),\n            List = [bp|[Lper]]);\n        List = [H].\n    /*\n     *   Convert the given tuple to list\n     */\n    tuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\n    tuple_to_list((A,B),L) :-\n        tuple_to_list(A, La),\n        tuple_to_list(B, Lb),\n        utils::append_fast(La, Lb,L).\n    list_to_tuple([H], (H)) :- !.\n    list_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n    /*\n     *   Replace all the occurences of a given element with the given argument\n     */\n    replace(_, _, [],[]) :- !.\n    replace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\n    replace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\n    flatten_first_level([X], X) :- !.\n    flatten_first_level.\n    removehead([_|Tail], Tail).\n    in(A, A) :- nonvar(A), A \\= (_ , _), !.\n    in(A, (A, _)) :- !.\n    in(A, (_ , Cs)) :- in(A, Cs).\n    check_admissibility(preconditions, H, LH) :-\n        \\+ defeasible_admissible(LH),\n        throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(effects, H, LH) :-\n        \\+ admissible(LH),\n        throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(_, _, _).\n    defeasible_admissible([unless, Term]) :- admissible(Term).\n    defeasible_admissible(Term) :- admissible(Term).\n    admissible([neg, bp, Term]) :- admissible_terms_complete(Term).\n    admissible([bp, Term]) :- admissible_terms_complete(Term).\n    admissible([neg, Term]) :- admissible_term(Term).\n    admissible([obl, [Term]]) :- admissible_term(Term).\n    admissible([obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([perm, [Term]]) :- admissible_term(Term).\n    admissible([perm, [neg, Term]]) :- admissible_term(Term).\n    admissible([Term]) :- admissible_term(Term).\n    admissible_term(Term) :-\n        atomic(Term),\n        Term \\== neg,\n        Term \\== obl,\n        Term \\== perm,\n        Term \\== unless,\n        Term \\== bp.\n    admissible_term(Term) :- var(Term).\n    admissible_term(Term) :-\n        compound(Term),\n        \\+ functor(Term, 'o', _),\n        \\+ functor(Term, 'p', _),\n        \\+ functor(Term, '-', _),\n        \\+ functor(Term, '~', _),\n        \\+ functor(Term, 'bp', _),\n        Term =.. [_|Args],\n        admissible_terms(Args).\n    admissible_terms([]).\n    admissible_terms([H|T]) :-\n        admissible_term(H),\n        admissible_terms(T).\n    admissible_terms_complete([]).\n    admissible_terms_complete([H|T]) :-\n        admissible(H),\n        admissible_terms_complete(T).\n        ");
   }
   RuleTranslator.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4921,7 +5125,7 @@
   }
   function Utils() {
     Utils_instance = this;
-    this.theoryCode = trimIndent('\n    writeList([]) :- nl.\n    writeList([X|Others]) :-\n    \twrite(X),\n    \twriteList(Others).\n    writeListNl([]).\n    writeListNl([X|Others]) :-\n    \twrite(X),nl,\n    \twriteListNl(Others).\n    sortDistinct(List, Sorted) :-\n        deduplicate(List, Deduplicated),\n        sort(Deduplicated, Sorted).\n    deduplicate([], []).\n    deduplicate(List, Output) :-\n        List \\== [],\n        setof(X, member(X, List), Output).\n    sort(List,Sorted) :- q_sort(List, [], Sorted).\n    q_sort([], Acc, Acc).\n    q_sort([H|T], Acc, Sorted) :-\n    \tpivoting(H, T, L1, L2),\n    \tq_sort(L1, Acc, Sorted1),\n    \tq_sort(L2, [H|Sorted1], Sorted).\n    pivoting(H,[],[],[]).\n    pivoting(H, [X|T], [X|L], G) :-\n        H @>= X,\n        pivoting(H, T, L, G).\n    pivoting(H, [X|T], L, [X|G]) :-\n        X @> H,\n        pivoting(H, T, L, G).\n    subtract([], _, []).\n    subtract([Head|Tail], L2, L3) :-\n            member(Head, L2), !,\n            subtract(Tail, L2, L3).\n    subtract([Head|Tail1], L2, [Head|Tail3]) :-\n            subtract(Tail1, L2, Tail3).\n    isEmptyList([]).\n    appendLists([], []).\n    appendLists([H|T], R) :-\n        appendLists(T, AT),\n        append(H, AT, R).\n    search(F, L, S) :-\n       between(1, L, N),\n       functor(S, F, N),\n       call(S).\n    between(N, M, K) :- N < M, K = N.\n    between(N, M, K) :- N == M, !, K = N.\n    between(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\n    recoverGraph(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).\n    recoverArgumentLabelling(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).\n    recoverStatementLabelling(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).\n        ');
+    this.theoryCode = trimIndent('\n    writeList([]) :- nl.\n    writeList([X|Others]) :-\n    \twrite(X),\n    \twriteList(Others).\n    writeListNl([]).\n    writeListNl([X|Others]) :-\n    \twrite(X),nl,\n    \twriteListNl(Others).\n    sortDistinct(List, Sorted) :-\n        deduplicate(List, Deduplicated),\n        sort(Deduplicated, Sorted).\n    deduplicate([], []).\n    deduplicate(List, Output) :-\n        List \\== [],\n        setof(X, member(X, List), Output).\n    sort(List,Sorted) :- q_sort(List, [], Sorted).\n    q_sort([], Acc, Acc).\n    q_sort([H|T], Acc, Sorted) :-\n    \tpivoting(H, T, L1, L2),\n    \tq_sort(L1, Acc, Sorted1),\n    \tq_sort(L2, [H|Sorted1], Sorted).\n    pivoting(H,[],[],[]).\n    pivoting(H, [X|T], [X|L], G) :-\n        H @>= X,\n        pivoting(H, T, L, G).\n    pivoting(H, [X|T], L, [X|G]) :-\n        X @> H,\n        pivoting(H, T, L, G).\n    subtract([], _, []).\n    subtract([Head|Tail], L2, L3) :-\n            member(Head, L2), !,\n            subtract(Tail, L2, L3).\n    subtract([Head|Tail1], L2, [Head|Tail3]) :-\n            subtract(Tail1, L2, Tail3).\n    isEmptyList([]).\n    appendLists([], []).\n    appendLists([H|T], R) :-\n        appendLists(T, AT),\n        append_fast(H, AT, R).\n    search(F, L, S) :-\n       between(1, L, N),\n       functor(S, F, N),\n       call(S).\n    between(N, M, K) :- N < M, K = N.\n    between(N, M, K) :- N == M, !, K = N.\n    between(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\n    recoverGraph(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).\n    recoverArgumentLabelling(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).\n    recoverStatementLabelling(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).\n        ');
   }
   Utils.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5144,6 +5348,9 @@
   Object.defineProperty(package$language, 'Bps', {
     get: Bps_getInstance
   });
+  Object.defineProperty(package$language, 'ExtractStrictIds', {
+    get: ExtractStrictIds_getInstance
+  });
   var package$structured = package$libs.structured || (package$libs.structured = {});
   package$structured.StructuredModeBase = StructuredModeBase;
   Object.defineProperty(package$structured, 'QueryMode', {
@@ -5162,6 +5369,12 @@
     get: OrderingComparator_getInstance
   });
   package$utils.UtilsBase = UtilsBase;
+  Object.defineProperty(package$utils, 'AppendOptimized', {
+    get: AppendOptimized_getInstance
+  });
+  Object.defineProperty(package$utils, 'AssertAll', {
+    get: AssertAll_getInstance
+  });
   var package$meta = package$core.meta || (package$core.meta = {});
   Object.defineProperty(package$meta, 'MetaInterpreterLib', {
     get: MetaInterpreterLib_getInstance