@tuprolog/arg2p-core 0.7.1 → 0.7.2

package/arg2p-core.js

@@ -1,22 +1,926 @@
 (function (root, factory) {
   if (typeof define === 'function' && define.amd)
-    define(['exports', './kt-math.js', './2p-solve-classic.js'], factory);
+    define(['exports', './kotlin-kotlin-stdlib-js-ir.js', './2p-core.js', './2p-theory.js', './2p-parser-theory.js', './2p-solve.js', './2p-unify.js', './kt-math.js', './2p-solve-classic.js'], factory);
   else if (typeof exports === 'object')
-    factory(module.exports, require('./kt-math.js'), require('./2p-solve-classic.js'));
+    factory(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'), require('./2p-core.js'), require('./2p-theory.js'), require('./2p-parser-theory.js'), require('./2p-solve.js'), require('./2p-unify.js'), require('./kt-math.js'), require('./2p-solve-classic.js'));
   else {
+    if (typeof this['kotlin-kotlin-stdlib-js-ir'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency 'kotlin-kotlin-stdlib-js-ir' was not found. Please, check whether 'kotlin-kotlin-stdlib-js-ir' is loaded prior to 'arg2p-core'.");
+    }
+    if (typeof this['2p-core'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to 'arg2p-core'.");
+    }
+    if (typeof this['2p-theory'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-theory' was not found. Please, check whether '2p-theory' is loaded prior to 'arg2p-core'.");
+    }
+    if (typeof this['2p-parser-theory'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-parser-theory' was not found. Please, check whether '2p-parser-theory' is loaded prior to 'arg2p-core'.");
+    }
+    if (typeof this['2p-solve'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-solve' was not found. Please, check whether '2p-solve' is loaded prior to 'arg2p-core'.");
+    }
+    if (typeof this['2p-unify'] === 'undefined') {
+      throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-unify' was not found. Please, check whether '2p-unify' is loaded prior to 'arg2p-core'.");
+    }
     if (typeof this['kt-math'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency 'kt-math' was not found. Please, check whether 'kt-math' is loaded prior to 'arg2p-core'.");
     }
     if (typeof this['2p-solve-classic'] === 'undefined') {
       throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-solve-classic' was not found. Please, check whether '2p-solve-classic' is loaded prior to 'arg2p-core'.");
     }
-    root['arg2p-core'] = factory(typeof this['arg2p-core'] === 'undefined' ? {} : this['arg2p-core'], this['kt-math'], this['2p-solve-classic']);
+    root['arg2p-core'] = factory(typeof this['arg2p-core'] === 'undefined' ? {} : this['arg2p-core'], this['kotlin-kotlin-stdlib-js-ir'], this['2p-core'], this['2p-theory'], this['2p-parser-theory'], this['2p-solve'], this['2p-unify'], this['kt-math'], this['2p-solve-classic']);
   }
-}(this, function (_, kotlin_io_github_gciatto_kt_math, kotlin_it_unibo_tuprolog_solve_classic) {
+}(this, function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_unify, kotlin_io_github_gciatto_kt_math, kotlin_it_unibo_tuprolog_solve_classic) {
   'use strict';
+  //region block: imports
+  var protoOf = kotlin_kotlin.$_$.q5;
+  var classMeta = kotlin_kotlin.$_$.u4;
+  var VOID = kotlin_kotlin.$_$.s9;
+  var setMetadataFor = kotlin_kotlin.$_$.r5;
+  var listOf = kotlin_kotlin.$_$.b3;
+  var plus = kotlin_kotlin.$_$.s3;
+  var objectMeta = kotlin_kotlin.$_$.p5;
+  var emptyList = kotlin_kotlin.$_$.l2;
+  var defineProp = kotlin_kotlin.$_$.w4;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.f;
+  var interfaceMeta = kotlin_kotlin.$_$.c5;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_theory.$_$.b;
+  var parseTheoryWithOperators = kotlin_it_unibo_tuprolog_parser_theory.$_$.a;
+  var lazy = kotlin_kotlin.$_$.k9;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_solve.$_$.i1;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_theory.$_$.a;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_unify.$_$.a;
+  var Unknown_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.b1;
+  var Unit_getInstance = kotlin_kotlin.$_$.o1;
+  var to = kotlin_kotlin.$_$.r9;
+  var mutableMapOf = kotlin_kotlin.$_$.m3;
+  var Specifier_XFX_getInstance = kotlin_it_unibo_tuprolog_core.$_$.a;
+  var Operator = kotlin_it_unibo_tuprolog_core.$_$.z;
+  var OperatorSet_init_$Create$ = kotlin_it_unibo_tuprolog_core.$_$.c;
+  //endregion
   //region block: pre-declaration
+  setMetadataFor(Arg2pSolver$Companion$of$1, VOID, classMeta);
+  setMetadataFor(Companion, 'Companion', objectMeta);
+  setMetadataFor(Arg2pSolverFactory, 'Arg2pSolverFactory', objectMeta);
+  function get_theoryOperators() {
+    return Companion_getInstance().DEFAULT;
+  }
+  setMetadataFor(ArgLibrary, 'ArgLibrary', interfaceMeta);
+  setMetadataFor(LazyRawPrologContent, 'LazyRawPrologContent', classMeta, VOID, [ArgLibrary]);
+  setMetadataFor(Cache, 'Cache', classMeta, VOID, [ArgLibrary]);
+  setMetadataFor(Context, 'Context', classMeta, VOID, [ArgLibrary]);
+  setMetadataFor(Companion_0, 'Companion', objectMeta);
+  setMetadataFor(DynamicLoader, 'DynamicLoader', classMeta, VOID, [ArgLibrary]);
+  setMetadataFor(EngineInterfaceBase, 'EngineInterfaceBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(MetaInterpreter, 'MetaInterpreter', objectMeta, VOID, [ArgLibrary]);
+  setMetadataFor(ModuleCalls, 'ModuleCalls', objectMeta, VOID, [ArgLibrary]);
+  setMetadataFor(AbstractModeBase, 'AbstractModeBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(ArgumentationGraphBuilderBase, 'ArgumentationGraphBuilderBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(AttackRestrictionHandlerBase, 'AttackRestrictionHandlerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(BpMetaGraphHandlerBase, 'BpMetaGraphHandlerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(DefeasiblePreferencesHandlerBase, 'DefeasiblePreferencesHandlerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(GenericDefeasiblePreferencesHandlerBase, 'GenericDefeasiblePreferencesHandlerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(StrictPreferencesHandlerBase, 'StrictPreferencesHandlerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(BinaryStatementLabeller, 'BinaryStatementLabeller', objectMeta, VOID, [ArgLibrary]);
+  setMetadataFor(BpCompleteLabellerBase, 'BpCompleteLabellerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(BpLabellerBase, 'BpLabellerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(BpPartialLabellerBase, 'BpPartialLabellerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(CompleteLabellerBase, 'CompleteLabellerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(GroundedLabellerBase, 'GroundedLabellerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(GroundedLabellerOptimizedBase, 'GroundedLabellerOptimizedBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(PassThroughStatementLabeller, 'PassThroughStatementLabeller', objectMeta, VOID, [ArgLibrary]);
+  setMetadataFor(StatementLabellerBase, 'StatementLabellerBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(Companion_1, 'Companion', objectMeta);
+  setMetadataFor(RuleParserBase, 'RuleParserBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(StructuredModeBase, 'StructuredModeBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(DebugBase, 'DebugBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(SuperiorityRelationBase, 'SuperiorityRelationBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(UtilsBase, 'UtilsBase', classMeta, LazyRawPrologContent, [ArgLibrary, LazyRawPrologContent]);
+  setMetadataFor(EngineInterface, 'EngineInterface', objectMeta, EngineInterfaceBase);
+  setMetadataFor(AbstractMode, 'AbstractMode', objectMeta, AbstractModeBase);
+  setMetadataFor(ArgumentationGraphBuilder, 'ArgumentationGraphBuilder', objectMeta, ArgumentationGraphBuilderBase);
+  setMetadataFor(AttackRestrictionHandler, 'AttackRestrictionHandler', objectMeta, AttackRestrictionHandlerBase);
+  setMetadataFor(BpMetaGraphHandler, 'BpMetaGraphHandler', objectMeta, BpMetaGraphHandlerBase);
+  setMetadataFor(DefeasiblePreferencesHandler, 'DefeasiblePreferencesHandler', objectMeta, DefeasiblePreferencesHandlerBase);
+  setMetadataFor(GenericDefeasiblePreferencesHandler, 'GenericDefeasiblePreferencesHandler', objectMeta, GenericDefeasiblePreferencesHandlerBase);
+  setMetadataFor(StrictPreferencesHandler, 'StrictPreferencesHandler', objectMeta, StrictPreferencesHandlerBase);
+  setMetadataFor(BpCompleteLabeller, 'BpCompleteLabeller', objectMeta, BpCompleteLabellerBase);
+  setMetadataFor(BpLabeller, 'BpLabeller', objectMeta, BpLabellerBase);
+  setMetadataFor(BpPartialLabeller, 'BpPartialLabeller', objectMeta, BpPartialLabellerBase);
+  setMetadataFor(CompleteLabeller, 'CompleteLabeller', objectMeta, CompleteLabellerBase);
+  setMetadataFor(GroundedLabeller, 'GroundedLabeller', objectMeta, GroundedLabellerBase);
+  setMetadataFor(GroundedLabellerOptimized, 'GroundedLabellerOptimized', objectMeta, GroundedLabellerOptimizedBase);
+  setMetadataFor(StatementLabeller, 'StatementLabeller', objectMeta, StatementLabellerBase);
+  setMetadataFor(RuleParser, 'RuleParser', objectMeta, RuleParserBase);
+  setMetadataFor(AbstractMode_0, 'AbstractMode', objectMeta);
+  setMetadataFor(ArgumentationEngineInterface, 'ArgumentationEngineInterface', objectMeta);
+  setMetadataFor(ArgumentationGraph, 'ArgumentationGraph', objectMeta);
+  setMetadataFor(AttackRestriction, 'AttackRestriction', objectMeta);
+  setMetadataFor(Bp, 'Bp', objectMeta);
+  setMetadataFor(BpGrounded, 'BpGrounded', objectMeta);
+  setMetadataFor(BpGroundedComplete, 'BpGroundedComplete', objectMeta);
+  setMetadataFor(BpGroundedPartial, 'BpGroundedPartial', objectMeta);
+  setMetadataFor(Complete, 'Complete', objectMeta);
+  setMetadataFor(Debug, 'Debug', objectMeta);
+  setMetadataFor(DefPreferences, 'DefPreferences', objectMeta);
+  setMetadataFor(GenericDefPreferences, 'GenericDefPreferences', objectMeta);
+  setMetadataFor(Grounded, 'Grounded', objectMeta);
+  setMetadataFor(GroundedOptimized, 'GroundedOptimized', objectMeta);
+  setMetadataFor(Preferences, 'Preferences', objectMeta);
+  setMetadataFor(QueryMode, 'QueryMode', objectMeta);
+  setMetadataFor(RuleTranslator, 'RuleTranslator', objectMeta);
+  setMetadataFor(StatementLabelling, 'StatementLabelling', objectMeta);
+  setMetadataFor(SuperiorityRelation, 'SuperiorityRelation', objectMeta);
+  setMetadataFor(Utils, 'Utils', objectMeta);
+  setMetadataFor(StructuredMode, 'StructuredMode', objectMeta, StructuredModeBase);
+  setMetadataFor(Debug_0, 'Debug', objectMeta, DebugBase);
+  setMetadataFor(SuperiorityRelation_0, 'SuperiorityRelation', objectMeta, SuperiorityRelationBase);
+  setMetadataFor(Utils_0, 'Utils', objectMeta, UtilsBase);
+  //endregion
+  function Arg2pSolver$Companion$of$1($staticLibs, $dynamicLibs) {
+    this.x34_1 = $staticLibs;
+    this.y34_1 = $dynamicLibs;
+    this.v34_1 = new DynamicLoader(this);
+    this.w34_1 = new Context();
+  }
+  function Companion() {
+    Companion_instance = this;
+  }
+  protoOf(Companion).z34 = function (staticLibs, dynamicLibs) {
+    return new Arg2pSolver$Companion$of$1(staticLibs, dynamicLibs);
+  };
+  protoOf(Companion).a35 = function (staticLibs, dynamicLibs) {
+    return this.z34(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_getInstance(), ModuleCalls_getInstance(), ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance(), GroundedLabellerOptimized_getInstance()]), dynamicLibs));
+  };
+  var Companion_instance;
+  function Companion_getInstance_4() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Arg2pSolverFactory() {
+    Arg2pSolverFactory_instance = this;
+  }
+  protoOf(Arg2pSolverFactory).of = function (staticLibs, dynamicLibs) {
+    return Companion_getInstance_4().z34(staticLibs, dynamicLibs);
+  };
+  protoOf(Arg2pSolverFactory).a35 = function (staticLibs, dynamicLibs) {
+    return Companion_getInstance_4().a35(staticLibs, dynamicLibs);
+  };
+  protoOf(Arg2pSolverFactory).default = function (staticLibs, dynamicLibs, $super) {
+    staticLibs = staticLibs === VOID ? emptyList() : staticLibs;
+    dynamicLibs = dynamicLibs === VOID ? emptyList() : dynamicLibs;
+    return this.a35(staticLibs, dynamicLibs);
+  };
+  var Arg2pSolverFactory_instance;
+  function Arg2pSolverFactory_getInstance() {
+    if (Arg2pSolverFactory_instance == null)
+      new Arg2pSolverFactory();
+    return Arg2pSolverFactory_instance;
+  }
+  function ArgLibrary() {
+  }
+  function LazyRawPrologContent$prologTheory$delegate$lambda(this$0) {
+    return function () {
+      return parseTheoryWithOperators(Companion_getInstance_0(), this$0.d35(), this$0.b35());
+    };
+  }
+  function LazyRawPrologContent() {
+    var tmp = this;
+    tmp.c35_1 = lazy(LazyRawPrologContent$prologTheory$delegate$lambda(this));
+  }
+  function Cache() {
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    var tmp0_also = Companion_getInstance_1().d1u().rawMutableSolverOf(VOID, VOID, VOID, Companion_getInstance_0().emptyWithDefaultUnificator(), Companion_getInstance_2().empty(Companion_getInstance_3().c1i()));
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.argumentation.core.libs.basic.Cache.solver.<anonymous>' call
+    tmp0_also.setFlag(Unknown_getInstance().x25_1, Unknown_getInstance().w25_1);
+    tmp$ret$0 = tmp0_also;
+    tmp.e35_1 = tmp$ret$0;
+    this.f35_1 = 'prolog.argumentation.cache';
+  }
+  function Context() {
+    this.g35_1 = 1;
+    this.h35_1 = 0;
+    var tmp = this;
+    var tmp$ret$0;
+    // Inline function 'kotlin.also' call
+    var tmp0_also = Companion_getInstance_1().d1u().mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_getInstance_0().emptyWithDefaultUnificator(), Companion_getInstance_2().empty(Companion_getInstance_3().c1i()));
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.argumentation.core.libs.basic.Context.dynamicSolver.<anonymous>' call
+    tmp0_also.setFlag(Unknown_getInstance().x25_1, Unknown_getInstance().w25_1);
+    tmp$ret$0 = tmp0_also;
+    tmp.i35_1 = mutableMapOf([to(0, tmp$ret$0)]);
+    this.j35_1 = 'prolog.argumentation.context';
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+  }
+  protoOf(Companion_0).k35 = function () {
+    return OperatorSet_init_$Create$([new Operator('::', Specifier_XFX_getInstance(), 700), new Operator(':::', Specifier_XFX_getInstance(), 700)]);
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_5() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function DynamicLoader(solver) {
+    Companion_getInstance_5();
+    this.l35_1 = solver;
+    this.m35_1 = 'prolog.argumentation.loader';
+    this.n35_1 = Companion_getInstance_5().k35();
+  }
+  function EngineInterfaceBase() {
+    LazyRawPrologContent.call(this);
+    this.p35_1 = 'prolog.argumentation.interface';
+    this.q35_1 = Companion_getInstance_6().k35().plusOperatorSet(Companion_getInstance_5().k35()).plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(EngineInterfaceBase).b35 = function () {
+    return this.q35_1;
+  };
+  function MetaInterpreter() {
+    MetaInterpreter_instance = this;
+    this.r35_1 = 'prolog.argumentation.meta.crossjustice';
+  }
+  var MetaInterpreter_instance;
+  function MetaInterpreter_getInstance() {
+    if (MetaInterpreter_instance == null)
+      new MetaInterpreter();
+    return MetaInterpreter_instance;
+  }
+  function ModuleCalls() {
+    ModuleCalls_instance = this;
+    this.s35_1 = 'prolog.argumentation.modularity';
+  }
+  var ModuleCalls_instance;
+  function ModuleCalls_getInstance() {
+    if (ModuleCalls_instance == null)
+      new ModuleCalls();
+    return ModuleCalls_instance;
+  }
+  function AbstractModeBase() {
+    LazyRawPrologContent.call(this);
+    this.u35_1 = 'prolog.argumentation.abstract';
+    this.v35_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(AbstractModeBase).b35 = function () {
+    return this.v35_1;
+  };
+  function ArgumentationGraphBuilderBase() {
+    LazyRawPrologContent.call(this);
+    this.x35_1 = 'prolog.argumentation.graph';
+    this.y35_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(ArgumentationGraphBuilderBase).b35 = function () {
+    return this.y35_1;
+  };
+  function AttackRestrictionHandlerBase() {
+    LazyRawPrologContent.call(this);
+    this.a36_1 = 'prolog.argumentation.graph.rebutrestriction';
+    this.b36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(AttackRestrictionHandlerBase).b35 = function () {
+    return this.b36_1;
+  };
+  function BpMetaGraphHandlerBase() {
+    LazyRawPrologContent.call(this);
+    this.d36_1 = 'prolog.argumentation.graph.meta.bp';
+    this.e36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(BpMetaGraphHandlerBase).b35 = function () {
+    return this.e36_1;
+  };
+  function DefeasiblePreferencesHandlerBase() {
+    LazyRawPrologContent.call(this);
+    this.g36_1 = 'prolog.argumentation.graph.preferences.defeasible';
+    this.h36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(DefeasiblePreferencesHandlerBase).b35 = function () {
+    return this.h36_1;
+  };
+  function GenericDefeasiblePreferencesHandlerBase() {
+    LazyRawPrologContent.call(this);
+    this.j36_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
+    this.k36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(GenericDefeasiblePreferencesHandlerBase).b35 = function () {
+    return this.k36_1;
+  };
+  function StrictPreferencesHandlerBase() {
+    LazyRawPrologContent.call(this);
+    this.m36_1 = 'prolog.argumentation.graph.preferences.strict';
+    this.n36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(StrictPreferencesHandlerBase).b35 = function () {
+    return this.n36_1;
+  };
+  function BinaryStatementLabeller() {
+    BinaryStatementLabeller_instance = this;
+    this.o36_1 = 'prolog.argumentation.graph.labelling.statement.binary';
+    this.p36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  var BinaryStatementLabeller_instance;
+  function BinaryStatementLabeller_getInstance() {
+    if (BinaryStatementLabeller_instance == null)
+      new BinaryStatementLabeller();
+    return BinaryStatementLabeller_instance;
+  }
+  function BpCompleteLabellerBase() {
+    LazyRawPrologContent.call(this);
+    this.r36_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
+    this.s36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(BpCompleteLabellerBase).b35 = function () {
+    return this.s36_1;
+  };
+  function BpLabellerBase() {
+    LazyRawPrologContent.call(this);
+    this.u36_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
+    this.v36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(BpLabellerBase).b35 = function () {
+    return this.v36_1;
+  };
+  function BpPartialLabellerBase() {
+    LazyRawPrologContent.call(this);
+    this.x36_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
+    this.y36_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(BpPartialLabellerBase).b35 = function () {
+    return this.y36_1;
+  };
+  function CompleteLabellerBase() {
+    LazyRawPrologContent.call(this);
+    this.a37_1 = 'prolog.argumentation.graph.labelling.complete';
+    this.b37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(CompleteLabellerBase).b35 = function () {
+    return this.b37_1;
+  };
+  function GroundedLabellerBase() {
+    LazyRawPrologContent.call(this);
+    this.d37_1 = 'prolog.argumentation.graph.labelling.grounded';
+    this.e37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(GroundedLabellerBase).b35 = function () {
+    return this.e37_1;
+  };
+  function GroundedLabellerOptimizedBase() {
+    LazyRawPrologContent.call(this);
+    this.g37_1 = 'prolog.argumentation.graph.labelling.grounded.optimized';
+    this.h37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(GroundedLabellerOptimizedBase).b35 = function () {
+    return this.h37_1;
+  };
+  function PassThroughStatementLabeller() {
+    PassThroughStatementLabeller_instance = this;
+    this.i37_1 = 'prolog.argumentation.graph.labelling.statement.pt';
+    this.j37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  var PassThroughStatementLabeller_instance;
+  function PassThroughStatementLabeller_getInstance() {
+    if (PassThroughStatementLabeller_instance == null)
+      new PassThroughStatementLabeller();
+    return PassThroughStatementLabeller_instance;
+  }
+  function StatementLabellerBase() {
+    LazyRawPrologContent.call(this);
+    this.l37_1 = 'prolog.argumentation.graph.labelling.statement';
+    this.m37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(StatementLabellerBase).b35 = function () {
+    return this.m37_1;
+  };
+  function Companion_1() {
+    Companion_instance_1 = this;
+  }
+  protoOf(Companion_1).k35 = function () {
+    return OperatorSet_init_$Create$([new Operator('=>', Specifier_XFX_getInstance(), 1199), new Operator(':=>', Specifier_XFX_getInstance(), 1199), new Operator(':->', Specifier_XFX_getInstance(), 1199), new Operator(':', Specifier_XFX_getInstance(), 1001), new Operator(':=', Specifier_XFX_getInstance(), 1199)]);
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_6() {
+    if (Companion_instance_1 == null)
+      new Companion_1();
+    return Companion_instance_1;
+  }
+  function RuleParserBase() {
+    Companion_getInstance_6();
+    LazyRawPrologContent.call(this);
+    this.o37_1 = 'prolog.argumentation.parser';
+    this.p37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance_6().k35()).plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(RuleParserBase).b35 = function () {
+    return this.p37_1;
+  };
+  function StructuredModeBase() {
+    LazyRawPrologContent.call(this);
+    this.r37_1 = 'prolog.argumentation.structured';
+    this.s37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(StructuredModeBase).b35 = function () {
+    return this.s37_1;
+  };
+  function DebugBase() {
+    LazyRawPrologContent.call(this);
+    this.u37_1 = 'prolog.argumentation.debug';
+    this.v37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(DebugBase).b35 = function () {
+    return this.v37_1;
+  };
+  function SuperiorityRelationBase() {
+    LazyRawPrologContent.call(this);
+    this.x37_1 = 'prolog.argumentation.superiority';
+    this.y37_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(SuperiorityRelationBase).b35 = function () {
+    return this.y37_1;
+  };
+  function UtilsBase() {
+    LazyRawPrologContent.call(this);
+    this.a38_1 = 'prolog.argumentation.utils';
+    this.b38_1 = Companion_getInstance_5().k35().plusOperatorSet(Companion_getInstance().DEFAULT);
+  }
+  protoOf(UtilsBase).b35 = function () {
+    return this.b38_1;
+  };
+  function EngineInterface() {
+    EngineInterface_instance = this;
+    EngineInterfaceBase.call(this);
+  }
+  protoOf(EngineInterface).d35 = function () {
+    return ArgumentationEngineInterface_getInstance().f38_1;
+  };
+  var EngineInterface_instance;
+  function EngineInterface_getInstance() {
+    if (EngineInterface_instance == null)
+      new EngineInterface();
+    return EngineInterface_instance;
+  }
+  function AbstractMode() {
+    AbstractMode_instance = this;
+    AbstractModeBase.call(this);
+  }
+  protoOf(AbstractMode).d35 = function () {
+    return AbstractMode_getInstance_0().j38_1;
+  };
+  var AbstractMode_instance;
+  function AbstractMode_getInstance() {
+    if (AbstractMode_instance == null)
+      new AbstractMode();
+    return AbstractMode_instance;
+  }
+  function ArgumentationGraphBuilder() {
+    ArgumentationGraphBuilder_instance = this;
+    ArgumentationGraphBuilderBase.call(this);
+  }
+  protoOf(ArgumentationGraphBuilder).d35 = function () {
+    return ArgumentationGraph_getInstance().n38_1;
+  };
+  var ArgumentationGraphBuilder_instance;
+  function ArgumentationGraphBuilder_getInstance() {
+    if (ArgumentationGraphBuilder_instance == null)
+      new ArgumentationGraphBuilder();
+    return ArgumentationGraphBuilder_instance;
+  }
+  function AttackRestrictionHandler() {
+    AttackRestrictionHandler_instance = this;
+    AttackRestrictionHandlerBase.call(this);
+  }
+  protoOf(AttackRestrictionHandler).d35 = function () {
+    return AttackRestriction_getInstance().r38_1;
+  };
+  var AttackRestrictionHandler_instance;
+  function AttackRestrictionHandler_getInstance() {
+    if (AttackRestrictionHandler_instance == null)
+      new AttackRestrictionHandler();
+    return AttackRestrictionHandler_instance;
+  }
+  function BpMetaGraphHandler() {
+    BpMetaGraphHandler_instance = this;
+    BpMetaGraphHandlerBase.call(this);
+  }
+  protoOf(BpMetaGraphHandler).d35 = function () {
+    return Bp_getInstance().v38_1;
+  };
+  var BpMetaGraphHandler_instance;
+  function BpMetaGraphHandler_getInstance() {
+    if (BpMetaGraphHandler_instance == null)
+      new BpMetaGraphHandler();
+    return BpMetaGraphHandler_instance;
+  }
+  function DefeasiblePreferencesHandler() {
+    DefeasiblePreferencesHandler_instance = this;
+    DefeasiblePreferencesHandlerBase.call(this);
+  }
+  protoOf(DefeasiblePreferencesHandler).d35 = function () {
+    return DefPreferences_getInstance().z38_1;
+  };
+  var DefeasiblePreferencesHandler_instance;
+  function DefeasiblePreferencesHandler_getInstance() {
+    if (DefeasiblePreferencesHandler_instance == null)
+      new DefeasiblePreferencesHandler();
+    return DefeasiblePreferencesHandler_instance;
+  }
+  function GenericDefeasiblePreferencesHandler() {
+    GenericDefeasiblePreferencesHandler_instance = this;
+    GenericDefeasiblePreferencesHandlerBase.call(this);
+  }
+  protoOf(GenericDefeasiblePreferencesHandler).d35 = function () {
+    return GenericDefPreferences_getInstance().d39_1;
+  };
+  var GenericDefeasiblePreferencesHandler_instance;
+  function GenericDefeasiblePreferencesHandler_getInstance() {
+    if (GenericDefeasiblePreferencesHandler_instance == null)
+      new GenericDefeasiblePreferencesHandler();
+    return GenericDefeasiblePreferencesHandler_instance;
+  }
+  function StrictPreferencesHandler() {
+    StrictPreferencesHandler_instance = this;
+    StrictPreferencesHandlerBase.call(this);
+  }
+  protoOf(StrictPreferencesHandler).d35 = function () {
+    return Preferences_getInstance().h39_1;
+  };
+  var StrictPreferencesHandler_instance;
+  function StrictPreferencesHandler_getInstance() {
+    if (StrictPreferencesHandler_instance == null)
+      new StrictPreferencesHandler();
+    return StrictPreferencesHandler_instance;
+  }
+  function BpCompleteLabeller() {
+    BpCompleteLabeller_instance = this;
+    BpCompleteLabellerBase.call(this);
+  }
+  protoOf(BpCompleteLabeller).d35 = function () {
+    return BpGroundedComplete_getInstance().l39_1;
+  };
+  var BpCompleteLabeller_instance;
+  function BpCompleteLabeller_getInstance() {
+    if (BpCompleteLabeller_instance == null)
+      new BpCompleteLabeller();
+    return BpCompleteLabeller_instance;
+  }
+  function BpLabeller() {
+    BpLabeller_instance = this;
+    BpLabellerBase.call(this);
+  }
+  protoOf(BpLabeller).d35 = function () {
+    return BpGrounded_getInstance().p39_1;
+  };
+  var BpLabeller_instance;
+  function BpLabeller_getInstance() {
+    if (BpLabeller_instance == null)
+      new BpLabeller();
+    return BpLabeller_instance;
+  }
+  function BpPartialLabeller() {
+    BpPartialLabeller_instance = this;
+    BpPartialLabellerBase.call(this);
+  }
+  protoOf(BpPartialLabeller).d35 = function () {
+    return BpGroundedPartial_getInstance().t39_1;
+  };
+  var BpPartialLabeller_instance;
+  function BpPartialLabeller_getInstance() {
+    if (BpPartialLabeller_instance == null)
+      new BpPartialLabeller();
+    return BpPartialLabeller_instance;
+  }
+  function CompleteLabeller() {
+    CompleteLabeller_instance = this;
+    CompleteLabellerBase.call(this);
+  }
+  protoOf(CompleteLabeller).d35 = function () {
+    return Complete_getInstance().x39_1;
+  };
+  var CompleteLabeller_instance;
+  function CompleteLabeller_getInstance() {
+    if (CompleteLabeller_instance == null)
+      new CompleteLabeller();
+    return CompleteLabeller_instance;
+  }
+  function GroundedLabeller() {
+    GroundedLabeller_instance = this;
+    GroundedLabellerBase.call(this);
+  }
+  protoOf(GroundedLabeller).d35 = function () {
+    return Grounded_getInstance().b3a_1;
+  };
+  var GroundedLabeller_instance;
+  function GroundedLabeller_getInstance() {
+    if (GroundedLabeller_instance == null)
+      new GroundedLabeller();
+    return GroundedLabeller_instance;
+  }
+  function GroundedLabellerOptimized() {
+    GroundedLabellerOptimized_instance = this;
+    GroundedLabellerOptimizedBase.call(this);
+  }
+  protoOf(GroundedLabellerOptimized).d35 = function () {
+    return GroundedOptimized_getInstance().f3a_1;
+  };
+  var GroundedLabellerOptimized_instance;
+  function GroundedLabellerOptimized_getInstance() {
+    if (GroundedLabellerOptimized_instance == null)
+      new GroundedLabellerOptimized();
+    return GroundedLabellerOptimized_instance;
+  }
+  function StatementLabeller() {
+    StatementLabeller_instance = this;
+    StatementLabellerBase.call(this);
+  }
+  protoOf(StatementLabeller).d35 = function () {
+    return StatementLabelling_getInstance().j3a_1;
+  };
+  var StatementLabeller_instance;
+  function StatementLabeller_getInstance() {
+    if (StatementLabeller_instance == null)
+      new StatementLabeller();
+    return StatementLabeller_instance;
+  }
+  function RuleParser() {
+    RuleParser_instance = this;
+    RuleParserBase.call(this);
+  }
+  protoOf(RuleParser).d35 = function () {
+    return RuleTranslator_getInstance().n3a_1;
+  };
+  var RuleParser_instance;
+  function RuleParser_getInstance() {
+    if (RuleParser_instance == null)
+      new RuleParser();
+    return RuleParser_instance;
+  }
+  function AbstractMode_0() {
+    AbstractMode_instance_0 = this;
+    this.j38_1 = 'computeGlobalAcceptance :-\n    buildGraph,\n    modifyGraph,\n    buildArgumentLabelling,\n    buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n    computeGlobalAcceptance,\n    utils::recoverGraph(Arguments, Attacks, Supports),\n    utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n    utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n    graphBuildMode(X),\n    X:::buildArgumentationGraph.\nmodifyGraph :-\n    findall(X, graphExtension(X), Ext),\n    modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n    modifyGraph(Ext),\n    X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n    argumentLabellingMode(X),\n    X:::argumentLabelling.\nbuildStatementLabelling :-\n    statementLabellingMode(X),\n    X:::statementLabelling.';
+  }
+  var AbstractMode_instance_0;
+  function AbstractMode_getInstance_0() {
+    if (AbstractMode_instance_0 == null)
+      new AbstractMode_0();
+    return AbstractMode_instance_0;
+  }
+  function ArgumentationEngineInterface() {
+    ArgumentationEngineInterface_instance = this;
+    this.f38_1 = 'argTuProlog.\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n    buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n    debug::printArgumentationGraph(Arguments, Attacks, Supports),\n    debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n    debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n    context_reset,\n    parser:::convertAllRules(_),\n    structured:::query(Goal, Res).\nbuildLabelSetsSilent :-\n    context_reset,\n    parser:::convertAllRules(ArgRules),\n    abstract::computeGlobalAcceptance.';
+  }
+  var ArgumentationEngineInterface_instance;
+  function ArgumentationEngineInterface_getInstance() {
+    if (ArgumentationEngineInterface_instance == null)
+      new ArgumentationEngineInterface();
+    return ArgumentationEngineInterface_instance;
+  }
+  function ArgumentationGraph() {
+    ArgumentationGraph_instance = this;
+    this.n38_1 = 'buildArgumentationGraph :-\n    buildArguments,\n    buildAttacks.\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            ground(Premise),\n            context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n            context_assert(conc(Premise) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n            context_assert(newConc(a, Premise)),\n            utils::hash(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]), Id),\n            context_assert(arg(Id) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n        ),\n        _\n    ).\nbuildArgumentsFromEmptyRules :-\n    findall(\n        _,\n        (\n            emptyRule([RuleID, RulePrem, RuleHead]),\n            checkStrict(RuleID, DefRule),\n            ground(RuleHead),\n            context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n            context_assert(conc(RuleHead) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n            context_assert(newConc(a, RuleHead)),\n            utils::hash(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]), Id),\n            context_assert(arg(Id) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n        ),\n        _\n    ).\nemptyRule([RuleID, Body, RuleHead]) :-\n    parser::classic_rule(RuleID, Body, RuleHead),\n    \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n    checkPrologClauses(Body).\ncheckPrologClauses([]) :- !.\ncheckPrologClauses([~(_)|T]) :- checkPrologClauses(T), !.\ncheckPrologClauses([prolog(Check)|T]) :-\n    (callable(Check) -> call(Check); Check),\n    checkPrologClauses(T).\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).\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    context_assert(newConc(Tn, RuleHead)).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\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    ground(RuleHead),\n    \\+ context_check(clause(conc(RuleHead), argument([_, RuleID, RuleHead, RuleBody, _]))),\n    utils::appendLists(TAll, All),\n    \\+ utils::contains(RuleID, All),\n    utils::appendLists(TLDef, LDef),\n    utils::appendLists(TDef, Def),\n    utils::appendLists(TPrem, Prem),\n    argumentInfo(RuleID, LDef, Def, Prem, Info),\n    utils::sort([RuleID|All], Rules),\n    Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n    context_assert(conc(RuleHead) :- argument(Argument)),\n    context_assert(argument(Argument)),\n    utils::hash(argument(Argument), Id),\n    context_assert(arg(Id) :- argument(Argument)).\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\tcontext_assert(support([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument)).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n    conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n    member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nbuildAttacks :-\n\tbuildDirectAttacks,\n\tbuildTransitiveAttacks.\nbuildDirectAttacks :-\n    findall(_, buildDirectAttack, _).\nbuildDirectAttack :-\n    context_check(argument(A)),\n    findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tA \\== B,\n    attacks(T, B, A),\n\t\\+ context_check(attack(T, B, A, A)),\n\tcontext_assert(attack(T, B, A, A)),\n\tutils::hash(argument(A), IdA),\n\tutils::hash(argument(B), IdB),\n\tcontext_assert(att(IdB, IdA) :- attack(T, B, A, A)),\n\tfail.\nbuildDirectAttack.\nbuildTransitiveAttacks :-\n\tcontext_check(attack(T, A, B, D)),\n\tcontext_check(support(B, C)),\n\t\\+ context_check(attack(T, A, C, D)), !,\n\tcontext_assert(attack(T, A, C, D)),\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(C), IdC),\n    context_assert(att(IdA, IdC) :- attack(T, B, C, D)),\n    buildTransitiveAttacks.\nbuildTransitiveAttacks.\nattacks(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    conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n    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], _, _]]).\ncheck(-Atom).\nconflict([Atom], [-Atom]) :- \\+ check(Atom).\nconflict([-Atom], [Atom]).\nconflict([o(Atom)], [o(-Atom)]) :- \\+ check(Atom).\nconflict([o(-Atom)], [o(Atom)]).\nconflict([p(Atom)], [o(-Atom)]) :- \\+ check(Atom).\nconflict([o(-Atom)], [p(Atom)]).\nconflict([p(-Atom)], [o(Atom)]).\nconflict([o(Atom)], [p(-Atom)]) :- \\+ check(Atom).\nconflict([sup(X, Y)], [sup(Y, X)]).';
+  }
+  var ArgumentationGraph_instance;
+  function ArgumentationGraph_getInstance() {
+    if (ArgumentationGraph_instance == null)
+      new ArgumentationGraph();
+    return ArgumentationGraph_instance;
+  }
+  function AttackRestriction() {
+    AttackRestriction_instance = this;
+    this.r38_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    context_retract(attack(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() {
+    if (AttackRestriction_instance == null)
+      new AttackRestriction();
+    return AttackRestriction_instance;
+  }
+  function Bp() {
+    Bp_instance = this;
+    this.v38_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    context_assert(argument(Conflict)),\n    context_assert(support(Original, Conflict)),\n    liftBpAttacks(Original, Conflict),\n    createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n    findall(_, (\n        context_check(attack(T, A, Template, O)),\n        context_assert(attack(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),\n    context_checkout(X),\n    context_assert(Attack),\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() {
+    if (Bp_instance == null)
+      new Bp();
+    return Bp_instance;
+  }
+  function BpGrounded() {
+    BpGrounded_instance = this;
+    this.p39_1 = 'argumentLabelling :-\n    reifyBurdenOfProofs,\n    filterBpDefeats,\n    findall(X, context_check(argument(X)), Arguments),\n    bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    grounded::allAttacksOUT(A), !,\n    context_assert(in(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    member(A, Arguments),\n    \\+ isArgumentInBurdenOfProof(A),\n    grounded::oneAttackIN(A), !,\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n    context_active(Branch),\n    mostGroundedBpUnd(Arguments, A),\n    context_branch(Branch, _),\n    context_assert(out(A)),\n    utils::subtract(Arguments, [A], NewArguments),\n    bpLabelling(NewArguments).\nbpLabelling(Args) :-\n    notLabelled(Args),\n    findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n    \\+ (\n        member(A, Args),\n        (\n            context_check(in(A));\n            context_check(out(A));\n            context_check(und(A))\n        )\n    ).\nisInBurdenOfProof(Conclusion) :-\n    context_check(reifiedBp(Literals)),\n    member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n    isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n    findall(_, (\n        context_check(attack(T, A, B, C)),\n        filterBpDefeat(T, A, B, C)\n    ), _).\nfilterBpDefeat(T, B, A, C) :-\n    (T = rebut; T = undermine),\n    isArgumentInBurdenOfProof(B),\n    \\+ superiority::superiorArgument(B, C),\n    context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n    member(Arg, Arguments),\n    isArgumentInBurdenOfProof(Arg),\n    \\+ (\n        member(A, Arguments), Arg \\= A,\n        isArgumentInBurdenOfProof(A),\n        argumentChain(A, Arg)\n    ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n    A \\== B,\n    context_check(attack(_, A, C, _)),\n    argumentChain(C, B).\nreifyBurdenOfProofs :-\n    findall(_, (\n        context_check(abstractBp(AbstractBp)),\n        fillTemplate(AbstractBp, R),\n        \\+ context_check(reifiedBp(R)),\n        context_assert(reifiedBp(R))\n    ), _).\n/*\n    Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n    context_check(argument([_ , _, [P], _, _])),\n    fillTemplate(T, R).';
+  }
+  var BpGrounded_instance;
+  function BpGrounded_getInstance() {
+    if (BpGrounded_instance == null)
+      new BpGrounded();
+    return BpGrounded_instance;
+  }
+  function BpGroundedComplete() {
+    BpGroundedComplete_instance = this;
+    this.l39_1 = 'argumentLabelling :-\n    bp_grounded::reifyBurdenOfProofs,\n    findall(X, context_check(argument(X)), Arguments),\n    completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n    bp_grounded_partial::partialBpLabelling(Arguments), !,\n    findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n    grounded::groundedLabelling(NewArgs),\n    findall(X, context_check(und(X)), LeftArguments),\n    stopCondition(Stop, Arguments, LeftArguments),\n    completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n    utils::sort(Args, SortedArgs),\n    utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
+  }
+  var BpGroundedComplete_instance;
+  function BpGroundedComplete_getInstance() {
+    if (BpGroundedComplete_instance == null)
+      new BpGroundedComplete();
+    return BpGroundedComplete_instance;
+  }
+  function BpGroundedPartial() {
+    BpGroundedPartial_instance = this;
+    this.t39_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    standard_af::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() {
+    if (BpGroundedPartial_instance == null)
+      new BpGroundedPartial();
+    return BpGroundedPartial_instance;
+  }
+  function Complete() {
+    Complete_instance = this;
+    this.x39_1 = 'argumentLabelling :-\n    cache_retract(complete(_,_,_)),\n    grounded:::argumentLabelling,\n    context_active(Branch),\n    completeLabelling(Branch).\ncompleteLabelling(_) :-\n    admissibleSet,\n    utils::recoverArgumentLabelling(In, Out, Und),\n    \\+ cache_check(complete(In, Out, Und)),\n    cache_assert(complete(In, Out, Und)).\ncompleteLabelling(Branch) :-\n    context_check(und(X)),\n    context_branch(Branch, NewBranch),\n    findall(Y, (context_check(und(Y)), Y \\= X), Arguments),\n    context_retract(und(_)),\n    context_assert(in(X)),\n    grounded::groundedLabelling(Arguments),\n    completeLabelling(NewBranch).\nadmissibleSet :-\n    \\+ (context_check(in(H)), \\+ admissible(H)).\nadmissible(H) :-\n    \\+ (\n        context_check(attack(_, Attacker, H, _)),\n        \\+ (\n            context_check(attack(_, Defendant, Attacker, _)),\n            context_check(in(Defendant))\n        )\n    ).';
+  }
+  var Complete_instance;
+  function Complete_getInstance() {
+    if (Complete_instance == null)
+      new Complete();
+    return Complete_instance;
+  }
+  function Debug() {
+    Debug_instance = this;
+    this.o3a_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() {
+    if (Debug_instance == null)
+      new Debug();
+    return Debug_instance;
+  }
+  function DefPreferences() {
+    DefPreferences_instance = this;
+    this.z38_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    context_assert(attack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C)),\n    context_retract(attack(T, A, B, C)).\ngenerateDirectAttackArgument(T, A, B, B) :-\n    RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n    \\+ context_check(argument(RArgument)),\n    context_assert(argument(RArgument)),\n    context_assert(support(A, RArgument)),\n    context_assert(attack(T, RArgument, B, B)),\n    context_retract(attack(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    Attack = attack(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    \\+ context_check(Attack),\n    context_assert(Attack),\n    fail.\nbuildPrefAttacks.';
+  }
+  var DefPreferences_instance;
+  function DefPreferences_getInstance() {
+    if (DefPreferences_instance == null)
+      new DefPreferences();
+    return DefPreferences_instance;
+  }
+  function GenericDefPreferences() {
+    GenericDefPreferences_instance = this;
+    this.d39_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    write(Arg), nl,\n    Attack = attack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n    \\+ context_check(Attack),\n    context_assert(Attack),\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, [mergedPreference], [], [[pref], MergedId, []]],\n    \\+ context_check(argument(Argument)),\n    context_assert(argument(Argument)),\n    findall(_, (\n        member(A, SupportArguments),\n        \\+ context_check(support(A, Argument)),\n        context_assert(support(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() {
+    if (GenericDefPreferences_instance == null)
+      new GenericDefPreferences();
+    return GenericDefPreferences_instance;
+  }
+  function Grounded() {
+    Grounded_instance = this;
+    this.b3a_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() {
+    if (Grounded_instance == null)
+      new Grounded();
+    return Grounded_instance;
+  }
+  function GroundedOptimized() {
+    GroundedOptimized_instance = this;
+    this.f3a_1 = 'argumentLabelling :-\n    groundedLabelling.\ngroundedLabelling :-\n    findall(t, evaluateIn, I),\n    findall(t, evaluateOut, O),\n    finalize(I, O).\nevaluateIn :-\n    argument_to_evaluate(A, IdA),\n    allAttacksOUT(IdA),\n    context_assert(in(A)),\n    context_assert(inId(IdA)).\nevaluateOut :-\n    argument_to_evaluate(A, IdA),\n    oneAttackIN(IdA),\n    context_assert(out(A)),\n    context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n    argument_to_evaluate(A, _),\n    context_assert(und(A)),\n    fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n    context_check(clause(arg(IdX), argument(X))),\n    \\+ context_check(outId(IdX)),\n    \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n    \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n    context_check(clause(att(B, A), _)),\n    context_check(inId(B)), !.\noneAttackIN(A) :-\n    context_check(clause(att(A, B), _)),\n    context_check(inId(B)), !.';
+  }
+  var GroundedOptimized_instance;
+  function GroundedOptimized_getInstance() {
+    if (GroundedOptimized_instance == null)
+      new GroundedOptimized();
+    return GroundedOptimized_instance;
+  }
+  function Preferences() {
+    Preferences_instance = this;
+    this.h39_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    context_retract(attack(T, A, B, C)),\n    hashed_attack(attack(T, A, B, C), Y),\n    context_retract(Y).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).\nhashed_attack(attack(T, A, B, C), att(IdA, IdB) :- attack(T, A, B, C)) :-\n    utils::hash(argument(A), IdA),\n    utils::hash(argument(B), IdB).';
+  }
+  var Preferences_instance;
+  function Preferences_getInstance() {
+    if (Preferences_instance == null)
+      new Preferences();
+    return Preferences_instance;
+  }
+  function QueryMode() {
+    QueryMode_instance = this;
+    this.p3a_1 = 'computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    \\+ queryMode,\n    abstract:::computeGlobalAcceptance,\n    mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n    queryMode,\n    argumentLabellingMode(grounded),\n    findall(_, query(Goal, _), _),\n    (ambiguityBlocking ->\n        statement_binary:::statementLabelling;\n        statementLabellingMode(Y),\n        Y:::statementLabelling\n    ),\n    mineResults(Goal, YesResult, NoResult, UndResult).\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n    findall(Goal, context_check(statIn([Goal])), In),\n    findall(Goal, context_check(statOut([Goal])), Out),\n    findall(Goal, context_check(statUnd([Goal])), Und),\n    utils::sort(In, YesResult),\n    utils::sort(Out, NoResult),\n    utils::sort(Und, UndResult).\nquery(Query, Res) :-\n    buildArgument(Query, Argument),\n    once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == yes,\n    bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n    findAttacker(Argument, QueryChain, Attacker, yes),\n    once(defend(Attacker, [Argument|QueryChain], X)),\n    X == und,\n    ambiguityCheck(Argument, Attacker, Res),\n    bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n    standard_af::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    standard_af::conflict(Term, [X]),\n    buildArgument(X, Attacker),\n    (graphExtension(standardPref) ->\n        (\n            once(getSubArgument(Term, TargetRules, SubArgument)),\n            \\+ superiorArgument(SubArgument, Attacker)\n        );\n        true\n    ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n    parser::contrary(Unless, X),\n    buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n    graphExtension(rebutRestriction),\n    TopRule \\= none,\n    rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n    superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n    context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n    contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n    \\+ context_check(explored(Query)),\n    findall(_, (\n        buildSingleArgument([Query], Argument),\n        context_assert(argument(Argument))\n    ), _),\n    context_assert(explored(Query)),\n    fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n    build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    utils::deduplicate(DefRules, CDefRules),\n    utils::deduplicate(DefPremises, CDefPremises),\n    utils::deduplicate(Groundings, CGroundings),\n    Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::premise(Id, Conclusion),\n    premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n    parser::rule(Id, Premises, Conclusion),\n    \\+ member(Id, Ids),\n    buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n    ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n    context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n    build([H], Ids, HConclusions, HRules),\n    buildPremises(T, Ids, TConclusions, TRules),\n    utils::appendLists([HConclusions, TConclusions], Conclusions),\n    mergeRules(HRules, TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n    [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n    [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n   utils::appendLists([HAR, TAR], AR),\n   utils::appendLists([HLDR, TLDR], LDR),\n   utils::appendLists([HDR, TDR], DR),\n   utils::appendLists([HDP, TDP], DP).';
+  }
+  var QueryMode_instance;
+  function QueryMode_getInstance() {
+    if (QueryMode_instance == null)
+      new QueryMode();
+    return QueryMode_instance;
+  }
+  function RuleTranslator() {
+    RuleTranslator_instance = this;
+    this.n3a_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, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).";
+  }
+  var RuleTranslator_instance;
+  function RuleTranslator_getInstance() {
+    if (RuleTranslator_instance == null)
+      new RuleTranslator();
+    return RuleTranslator_instance;
+  }
+  function StatementLabelling() {
+    StatementLabelling_instance = this;
+    this.j3a_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() {
+    if (StatementLabelling_instance == null)
+      new StatementLabelling();
+    return StatementLabelling_instance;
+  }
+  function SuperiorityRelation() {
+    SuperiorityRelation_instance = this;
+    this.q3a_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() {
+    if (SuperiorityRelation_instance == null)
+      new SuperiorityRelation();
+    return SuperiorityRelation_instance;
+  }
+  function Utils() {
+    Utils_instance = this;
+    this.r3a_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nsortDistinct(List, Sorted) :-\n    deduplicate(List, Deduplicated),\n    sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n    List \\== [],\n    setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n    H @>= X,\n    pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n    X @> H,\n    pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n        member(Head, L2), !,\n        subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n        subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n    appendLists(T, AT),\n    append_fast(H, AT, R).\nsearch(F, L, S) :-\n   between(1, L, N),\n   functor(S, F, N),\n   call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n        findall(X, context_check(argument(X)), TempArgs),\n        findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n        findall((A, B), context_check(support(A, B)), TempSupports),\n        utils::sort(TempArgs, Args),\n        utils::sort(TempAttacks, Attacks),\n        utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n        findall(X, context_check(in(X)), TempArgsIn),\n        findall(X, context_check(out(X)), TempArgsOut),\n        findall(X, context_check(und(X)), TempArgsUnd),\n        utils::sort(TempArgsIn, ArgsIn),\n        utils::sort(TempArgsOut, ArgsOut),\n        utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n        findall(X, context_check(statIn(X)), TempIn),\n        findall(X, context_check(statOut(X)), TempOut),\n        findall(X, context_check(statUnd(X)), TempUnd),\n        utils::sort(TempIn, In),\n        utils::sort(TempOut, Out),\n        utils::sort(TempUnd, Und).';
+  }
+  var Utils_instance;
+  function Utils_getInstance() {
+    if (Utils_instance == null)
+      new Utils();
+    return Utils_instance;
+  }
+  function StructuredMode() {
+    StructuredMode_instance = this;
+    StructuredModeBase.call(this);
+  }
+  protoOf(StructuredMode).d35 = function () {
+    return QueryMode_getInstance().p3a_1;
+  };
+  var StructuredMode_instance;
+  function StructuredMode_getInstance() {
+    if (StructuredMode_instance == null)
+      new StructuredMode();
+    return StructuredMode_instance;
+  }
+  function Debug_0() {
+    Debug_instance_0 = this;
+    DebugBase.call(this);
+  }
+  protoOf(Debug_0).d35 = function () {
+    return Debug_getInstance().o3a_1;
+  };
+  var Debug_instance_0;
+  function Debug_getInstance_0() {
+    if (Debug_instance_0 == null)
+      new Debug_0();
+    return Debug_instance_0;
+  }
+  function SuperiorityRelation_0() {
+    SuperiorityRelation_instance_0 = this;
+    SuperiorityRelationBase.call(this);
+  }
+  protoOf(SuperiorityRelation_0).d35 = function () {
+    return SuperiorityRelation_getInstance().q3a_1;
+  };
+  var SuperiorityRelation_instance_0;
+  function SuperiorityRelation_getInstance_0() {
+    if (SuperiorityRelation_instance_0 == null)
+      new SuperiorityRelation_0();
+    return SuperiorityRelation_instance_0;
+  }
+  function Utils_0() {
+    Utils_instance_0 = this;
+    UtilsBase.call(this);
+  }
+  protoOf(Utils_0).d35 = function () {
+    return Utils_getInstance().r3a_1;
+  };
+  var Utils_instance_0;
+  function Utils_getInstance_0() {
+    if (Utils_instance_0 == null)
+      new Utils_0();
+    return Utils_instance_0;
+  }
+  //region block: post-declaration
+  protoOf(LazyRawPrologContent).b35 = get_theoryOperators;
   //endregion
   //region block: exports
+  function $jsExportAll$(_) {
+    var $it = _.it || (_.it = {});
+    var $it$unibo = $it.unibo || ($it.unibo = {});
+    var $it$unibo$tuprolog = $it$unibo.tuprolog || ($it$unibo.tuprolog = {});
+    var $it$unibo$tuprolog$argumentation = $it$unibo$tuprolog.argumentation || ($it$unibo$tuprolog.argumentation = {});
+    var $it$unibo$tuprolog$argumentation$core = $it$unibo$tuprolog$argumentation.core || ($it$unibo$tuprolog$argumentation.core = {});
+    defineProp($it$unibo$tuprolog$argumentation$core, 'Arg2pSolverFactory', Arg2pSolverFactory_getInstance);
+  }
+  $jsExportAll$(_);
   kotlin_io_github_gciatto_kt_math.$jsExportAll$(_);
   kotlin_it_unibo_tuprolog_solve_classic.$jsExportAll$(_);
   //endregion