@tuprolog/arg2p 0.11.3 → 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/2p-dsl-core.js +135 -135
  2. package/2p-dsl-core.js.map +1 -1
  3. package/2p-dsl-solve.js +6 -6
  4. package/2p-dsl-theory.js +6 -6
  5. package/2p-dsl-unify.js +9 -9
  6. package/2p-solve.js +1 -1
  7. package/arg2p-causality-solver.js +118 -100
  8. package/arg2p-causality-solver.js.map +1 -1
  9. package/arg2p-core.js +1004 -987
  10. package/arg2p-core.js.map +1 -1
  11. package/arg2p.js +35 -35
  12. package/kotlin-kotlin-stdlib.js +15 -15
  13. package/kotlin-kotlin-stdlib.js.map +1 -1
  14. package/package.json +1 -1
package/arg2p-core.js CHANGED
@@ -1,8 +1,8 @@
1
1
  (function (factory) {
2
2
  if (typeof define === 'function' && define.amd)
3
- define(['exports', './kotlin-kotlin-stdlib.js', './2p-solve.js', './2p-core.js', './2p-parser-core.js', './2p-solve-classic.js', './2p-theory.js', './2p-parser-theory.js', './2p-dsl-solve.js', './2p-dsl-core.js', './2p-dsl-unify.js', './2p-unify.js', './2p-dsl-theory.js'], factory);
3
+ define(['exports', './kotlin-kotlin-stdlib.js', './2p-solve.js', './2p-solve-classic.js', './2p-theory.js', './2p-parser-theory.js', './2p-dsl-solve.js', './2p-dsl-core.js', './2p-core.js', './2p-dsl-unify.js', './2p-unify.js', './2p-dsl-theory.js', './2p-parser-core.js'], factory);
4
4
  else if (typeof exports === 'object')
5
- factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-solve.js'), require('./2p-core.js'), require('./2p-parser-core.js'), require('./2p-solve-classic.js'), require('./2p-theory.js'), require('./2p-parser-theory.js'), require('./2p-dsl-solve.js'), require('./2p-dsl-core.js'), require('./2p-dsl-unify.js'), require('./2p-unify.js'), require('./2p-dsl-theory.js'));
5
+ factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-solve.js'), require('./2p-solve-classic.js'), require('./2p-theory.js'), require('./2p-parser-theory.js'), require('./2p-dsl-solve.js'), require('./2p-dsl-core.js'), require('./2p-core.js'), require('./2p-dsl-unify.js'), require('./2p-unify.js'), require('./2p-dsl-theory.js'), require('./2p-parser-core.js'));
6
6
  else {
7
7
  if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
8
8
  throw new Error("Error loading module 'arg2p-core'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'arg2p-core'.");
@@ -10,12 +10,6 @@
10
10
  if (typeof globalThis['2p-solve'] === 'undefined') {
11
11
  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'.");
12
12
  }
13
- if (typeof globalThis['2p-core'] === 'undefined') {
14
- 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'.");
15
- }
16
- if (typeof globalThis['2p-parser-core'] === 'undefined') {
17
- throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-parser-core' was not found. Please, check whether '2p-parser-core' is loaded prior to 'arg2p-core'.");
18
- }
19
13
  if (typeof globalThis['2p-solve-classic'] === 'undefined') {
20
14
  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'.");
21
15
  }
@@ -31,6 +25,9 @@
31
25
  if (typeof globalThis['2p-dsl-core'] === 'undefined') {
32
26
  throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-dsl-core' was not found. Please, check whether '2p-dsl-core' is loaded prior to 'arg2p-core'.");
33
27
  }
28
+ if (typeof globalThis['2p-core'] === 'undefined') {
29
+ 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'.");
30
+ }
34
31
  if (typeof globalThis['2p-dsl-unify'] === 'undefined') {
35
32
  throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-dsl-unify' was not found. Please, check whether '2p-dsl-unify' is loaded prior to 'arg2p-core'.");
36
33
  }
@@ -40,9 +37,12 @@
40
37
  if (typeof globalThis['2p-dsl-theory'] === 'undefined') {
41
38
  throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-dsl-theory' was not found. Please, check whether '2p-dsl-theory' is loaded prior to 'arg2p-core'.");
42
39
  }
43
- globalThis['arg2p-core'] = factory(typeof globalThis['arg2p-core'] === 'undefined' ? {} : globalThis['arg2p-core'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-solve'], globalThis['2p-core'], globalThis['2p-parser-core'], globalThis['2p-solve-classic'], globalThis['2p-theory'], globalThis['2p-parser-theory'], globalThis['2p-dsl-solve'], globalThis['2p-dsl-core'], globalThis['2p-dsl-unify'], globalThis['2p-unify'], globalThis['2p-dsl-theory']);
40
+ if (typeof globalThis['2p-parser-core'] === 'undefined') {
41
+ throw new Error("Error loading module 'arg2p-core'. Its dependency '2p-parser-core' was not found. Please, check whether '2p-parser-core' is loaded prior to 'arg2p-core'.");
42
+ }
43
+ globalThis['arg2p-core'] = factory(typeof globalThis['arg2p-core'] === 'undefined' ? {} : globalThis['arg2p-core'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-solve'], globalThis['2p-solve-classic'], globalThis['2p-theory'], globalThis['2p-parser-theory'], globalThis['2p-dsl-solve'], globalThis['2p-dsl-core'], globalThis['2p-core'], globalThis['2p-dsl-unify'], globalThis['2p-unify'], globalThis['2p-dsl-theory'], globalThis['2p-parser-core']);
44
44
  }
45
- }(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_parser_core, kotlin_it_unibo_tuprolog_solve_classic, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_dsl_solve, kotlin_it_unibo_tuprolog_dsl_core, kotlin_it_unibo_tuprolog_dsl_unify, kotlin_it_unibo_tuprolog_unify, kotlin_it_unibo_tuprolog_dsl_theory) {
45
+ }(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_solve_classic, kotlin_it_unibo_tuprolog_theory, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_dsl_solve, kotlin_it_unibo_tuprolog_dsl_core, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_dsl_unify, kotlin_it_unibo_tuprolog_unify, kotlin_it_unibo_tuprolog_dsl_theory, kotlin_it_unibo_tuprolog_parser_core) {
46
46
  'use strict';
47
47
  //region block: imports
48
48
  var imul = Math.imul;
@@ -59,14 +59,10 @@
59
59
  var Unit_instance = kotlin_kotlin.$_$.k1;
60
60
  var UnsupportedOperationException_init_$Create$ = kotlin_kotlin.$_$.c1;
61
61
  var initMetadataForInterface = kotlin_kotlin.$_$.z5;
62
- var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.u;
63
- var parseStruct = kotlin_it_unibo_tuprolog_parser_core.$_$.d;
64
- var filter = kotlin_kotlin.$_$.t7;
65
- var map = kotlin_kotlin.$_$.f8;
66
62
  var listOf_0 = kotlin_kotlin.$_$.b3;
67
63
  var plus_0 = kotlin_kotlin.$_$.u3;
68
64
  var ClassicSolverFactory_instance = kotlin_it_unibo_tuprolog_solve_classic.$_$.a;
69
- var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_solve.$_$.d1;
65
+ var Companion_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.d1;
70
66
  var Unknown_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.g1;
71
67
  var TrackVariables_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.f1;
72
68
  var Companion_instance_0 = kotlin_it_unibo_tuprolog_theory.$_$.b;
@@ -84,21 +80,22 @@
84
80
  var matchAny = kotlin_it_unibo_tuprolog_dsl_unify.$_$.a;
85
81
  var unifyAny = kotlin_it_unibo_tuprolog_dsl_unify.$_$.c;
86
82
  var solverOf = kotlin_it_unibo_tuprolog_dsl_solve.$_$.a;
83
+ var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
87
84
  var LogicProgrammingScopeWithPrologStandardLibrary = kotlin_it_unibo_tuprolog_dsl_core.$_$.h4;
88
- var LogicProgrammingScopeWithOperators = kotlin_it_unibo_tuprolog_dsl_core.$_$.w1;
89
85
  var MinimalLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.c5;
90
- var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
91
- var LogicProgrammingScopeWithSubstitutions = kotlin_it_unibo_tuprolog_dsl_core.$_$.o4;
92
- var BaseLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.e;
93
- var LogicProgrammingScopeWithResolution = kotlin_it_unibo_tuprolog_dsl_solve.$_$.c;
94
86
  var LogicProgrammingScopeWithUnification = kotlin_it_unibo_tuprolog_dsl_unify.$_$.j;
95
87
  var LogicProgrammingScopeWithTheories = kotlin_it_unibo_tuprolog_dsl_theory.$_$.h;
96
- var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_core.$_$.i;
88
+ var BaseLogicProgrammingScope = kotlin_it_unibo_tuprolog_dsl_core.$_$.e;
89
+ var LogicProgrammingScopeWithOperators = kotlin_it_unibo_tuprolog_dsl_core.$_$.w1;
90
+ var LogicProgrammingScopeWithResolution = kotlin_it_unibo_tuprolog_dsl_solve.$_$.c;
91
+ var LogicProgrammingScopeWithSubstitutions = kotlin_it_unibo_tuprolog_dsl_core.$_$.o4;
92
+ var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.i;
97
93
  var lazy = kotlin_kotlin.$_$.ra;
98
94
  var KProperty1 = kotlin_kotlin.$_$.g7;
99
95
  var getPropertyCallableRef = kotlin_kotlin.$_$.u5;
100
96
  var CoroutineImpl = kotlin_kotlin.$_$.p4;
101
97
  var SequenceScope = kotlin_kotlin.$_$.h7;
98
+ var map = kotlin_kotlin.$_$.f8;
102
99
  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.o4;
103
100
  var initMetadataForLambda = kotlin_kotlin.$_$.a6;
104
101
  var Signature = kotlin_it_unibo_tuprolog_solve.$_$.u2;
@@ -106,33 +103,37 @@
106
103
  var Primitive = kotlin_it_unibo_tuprolog_solve.$_$.w1;
107
104
  var sequence = kotlin_kotlin.$_$.n8;
108
105
  var Companion_instance_2 = kotlin_it_unibo_tuprolog_theory.$_$.a;
109
- var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_unify.$_$.b;
110
- var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_solve.$_$.h1;
106
+ var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_unify.$_$.b;
107
+ var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_solve.$_$.h1;
111
108
  var mapCapacity = kotlin_kotlin.$_$.d3;
112
109
  var coerceAtLeast = kotlin_kotlin.$_$.a7;
113
110
  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.e;
114
111
  var ensureNotNull = kotlin_kotlin.$_$.pa;
115
- var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.v;
116
- var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.q;
112
+ var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.v;
113
+ var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.q;
117
114
  var first = kotlin_kotlin.$_$.v7;
118
115
  var to = kotlin_kotlin.$_$.ya;
119
116
  var mutableMapOf = kotlin_kotlin.$_$.n3;
120
- var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_solve.$_$.o1;
117
+ var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_solve.$_$.o1;
118
+ var filter = kotlin_kotlin.$_$.t7;
121
119
  var Companion_instance_3 = kotlin_it_unibo_tuprolog_solve.$_$.b1;
122
120
  var Expected_LIST_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.b;
123
121
  var Atom = kotlin_it_unibo_tuprolog_core.$_$.f1;
124
122
  var isInterface = kotlin_kotlin.$_$.e6;
125
123
  var Expected_CALLABLE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.a;
126
124
  var Struct = kotlin_it_unibo_tuprolog_core.$_$.s1;
127
- var Companion_instance_4 = kotlin_it_unibo_tuprolog_solve.$_$.v;
128
- var Companion_instance_5 = kotlin_it_unibo_tuprolog_solve.$_$.w;
129
- var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.d;
130
125
  var logicProgramming = kotlin_it_unibo_tuprolog_dsl_core.$_$.d5;
131
126
  var Specifier_XFX_getInstance = kotlin_it_unibo_tuprolog_core.$_$.a;
132
127
  var Operator = kotlin_it_unibo_tuprolog_core.$_$.e1;
133
128
  var OperatorSet_init_$Create$ = kotlin_it_unibo_tuprolog_core.$_$.f;
134
- var Companion_getInstance_7 = kotlin_it_unibo_tuprolog_core.$_$.l;
129
+ var LinkedHashMap_init_$Create$_0 = kotlin_kotlin.$_$.f;
130
+ var Companion_instance_4 = kotlin_it_unibo_tuprolog_solve.$_$.v;
131
+ var Companion_instance_5 = kotlin_it_unibo_tuprolog_solve.$_$.w;
132
+ var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.d;
133
+ var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_core.$_$.l;
135
134
  var parseClause = kotlin_it_unibo_tuprolog_parser_core.$_$.c;
135
+ var Companion_getInstance_7 = kotlin_it_unibo_tuprolog_core.$_$.u;
136
+ var parseStruct = kotlin_it_unibo_tuprolog_parser_core.$_$.d;
136
137
  var toString = kotlin_kotlin.$_$.p6;
137
138
  var getBooleanHashCode = kotlin_kotlin.$_$.t5;
138
139
  var getStringHashCode = kotlin_kotlin.$_$.v5;
@@ -219,12 +220,12 @@
219
220
  initMetadataForClass(Arg2pSolver$Companion$of$1, VOID, VOID, VOID, [Arg2pSolver]);
220
221
  initMetadataForCompanion(Companion);
221
222
  initMetadataForObject(Arg2pSolverFactory, 'Arg2pSolverFactory');
222
- initMetadataForClass(PrologWithArgumentationImpl, 'PrologWithArgumentationImpl', PrologWithArgumentationImpl, VOID, [LogicProgrammingScopeWithPrologStandardLibrary, LogicProgrammingScopeWithOperators, MinimalLogicProgrammingScope, Scope, LogicProgrammingScopeWithSubstitutions, BaseLogicProgrammingScope, LogicProgrammingScopeWithResolution, LogicProgrammingScopeWithUnification, LogicProgrammingScopeWithTheories]);
223
+ initMetadataForClass(PrologWithArgumentationImpl, 'PrologWithArgumentationImpl', PrologWithArgumentationImpl, VOID, [Scope, LogicProgrammingScopeWithPrologStandardLibrary, MinimalLogicProgrammingScope, LogicProgrammingScopeWithUnification, LogicProgrammingScopeWithTheories, BaseLogicProgrammingScope, LogicProgrammingScopeWithOperators, LogicProgrammingScopeWithResolution, LogicProgrammingScopeWithSubstitutions]);
223
224
  function get_theoryOperators() {
224
- return Companion_getInstance_1().DEFAULT;
225
+ return Companion_getInstance_0().DEFAULT;
225
226
  }
226
227
  function content() {
227
- return this.z39();
228
+ return this.y39();
228
229
  }
229
230
  initMetadataForInterface(ArgLibrary, 'ArgLibrary');
230
231
  initMetadataForInterface(Loadable, 'Loadable');
@@ -251,7 +252,7 @@
251
252
  initMetadataForClass(WithLibInNewContext, 'WithLibInNewContext', VOID, AbstractWithLib);
252
253
  initMetadataForCompanion(Companion_0);
253
254
  initMetadataForClass(DynamicLoader, 'DynamicLoader', VOID, VOID, [ArgLibrary]);
254
- initMetadataForClass(EngineInterfaceBase, 'EngineInterfaceBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary]);
255
+ initMetadataForClass(EngineInterfaceBase, 'EngineInterfaceBase', VOID, LazyRawPrologContent, [LazyRawPrologContent, ArgLibrary, Loadable]);
255
256
  initMetadataForCompanion(Companion_1);
256
257
  initMetadataForClass(FlagsBuilder$create$1, VOID, VOID, VOID, [ArgLibrary]);
257
258
  initMetadataForClass(FlagsBuilder, 'FlagsBuilder', FlagsBuilder);
@@ -385,7 +386,7 @@
385
386
  return new Arg2pSolver$Companion$of$1(staticLibs, dynamicLibs);
386
387
  };
387
388
  protoOf(Companion).f39 = function (staticLibs, dynamicLibs) {
388
- return this.e39(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_instance, ModuleCalls_instance, ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), AttackRelation_getInstance_0(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance(), GroundedLabellerOptimized_getInstance()]), dynamicLibs));
389
+ return this.e39(plus(listOf([EngineInterface_getInstance(), new Cache()]), staticLibs), plus(listOf([EngineInterface_getInstance(), Utils_getInstance_0(), Debug_getInstance_0(), RuleParser_getInstance(), MetaInterpreter_instance, ModuleCalls_instance, ArgumentationGraphBuilder_getInstance(), AttackRestrictionHandler_getInstance(), BpMetaGraphHandler_getInstance(), DefeasiblePreferencesHandler_getInstance(), GenericDefeasiblePreferencesHandler_getInstance(), StrictPreferencesHandler_getInstance(), BpLabeller_getInstance(), CompleteLabeller_getInstance(), GroundedLabeller_getInstance(), StatementLabeller_getInstance(), AbstractMode_getInstance(), StructuredMode_getInstance(), AttackRelation_getInstance_0(), SuperiorityRelation_getInstance_0(), BpPartialLabeller_getInstance(), BpCompleteLabeller_getInstance(), PassThroughStatementLabeller_getInstance(), BinaryStatementLabeller_getInstance(), GroundedLabellerOptimized_getInstance()]), dynamicLibs));
389
390
  };
390
391
  protoOf(Companion).g39 = function (staticLibs, dynamicLibs, $super) {
391
392
  staticLibs = staticLibs === VOID ? emptyList() : staticLibs;
@@ -398,39 +399,19 @@
398
399
  }
399
400
  function Arg2pSolver() {
400
401
  }
401
- function Arg2pSolverFactory$evaluate$lambda$lambda(it) {
402
- return it.d1u();
403
- }
404
- function Arg2pSolverFactory$evaluate$lambda$lambda_0($solver) {
405
- return function (it) {
406
- return mineActiveGraph($solver);
407
- };
408
- }
409
- function Arg2pSolverFactory$evaluate$lambda($kb, $flags) {
410
- return function ($this$arg2pScope) {
411
- // Inline function 'kotlin.let' call
412
- var solver = Arg2pSolverFactory_instance.v39($kb, $flags.u39());
413
- var tmp = solver.solve(parseStruct(Companion_getInstance(), 'buildLabelSetsSilent'));
414
- var tmp_0 = filter(tmp, Arg2pSolverFactory$evaluate$lambda$lambda);
415
- return map(tmp_0, Arg2pSolverFactory$evaluate$lambda$lambda_0(solver));
416
- };
417
- }
418
402
  function Arg2pSolverFactory() {
419
403
  }
420
- protoOf(Arg2pSolverFactory).w39 = function (theory, settings, staticLibs, dynamicLibs) {
404
+ protoOf(Arg2pSolverFactory).j39 = function (theory, settings, staticLibs, dynamicLibs) {
421
405
  // Inline function 'kotlin.let' call
422
406
  var it = Companion_instance_7.f39(plus_0(staticLibs, listOf_0(settings)), dynamicLibs);
423
- return ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, it.c39(), Companion_getInstance_0().z1v_1.setNotable(Unknown_getInstance(), Unknown_getInstance().f27_1).setNotable(TrackVariables_getInstance(), TrackVariables_getInstance().z26_1), parseTheoryWithOperators(Companion_instance_0, theory, it.d39()));
407
+ return ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, it.c39(), Companion_getInstance().z1v_1.setNotable(Unknown_getInstance(), Unknown_getInstance().f27_1).setNotable(TrackVariables_getInstance(), TrackVariables_getInstance().z26_1), parseTheoryWithOperators(Companion_instance_0, theory, it.d39()));
424
408
  };
425
- protoOf(Arg2pSolverFactory).v39 = function (theory, settings, staticLibs, dynamicLibs, $super) {
409
+ protoOf(Arg2pSolverFactory).k39 = function (theory, settings, staticLibs, dynamicLibs, $super) {
426
410
  theory = theory === VOID ? '' : theory;
427
- settings = settings === VOID ? (new FlagsBuilder()).u39() : settings;
411
+ settings = settings === VOID ? (new FlagsBuilder()).w39() : settings;
428
412
  staticLibs = staticLibs === VOID ? emptyList() : staticLibs;
429
413
  dynamicLibs = dynamicLibs === VOID ? emptyList() : dynamicLibs;
430
- return $super === VOID ? this.w39(theory, settings, staticLibs, dynamicLibs) : $super.w39.call(this, theory, settings, staticLibs, dynamicLibs);
431
- };
432
- protoOf(Arg2pSolverFactory).x39 = function (kb, flags) {
433
- return arg2pScope(Arg2pSolverFactory$evaluate$lambda(kb, flags));
414
+ return $super === VOID ? this.j39(theory, settings, staticLibs, dynamicLibs) : $super.j39.call(this, theory, settings, staticLibs, dynamicLibs);
434
415
  };
435
416
  var Arg2pSolverFactory_instance;
436
417
  function Arg2pSolverFactory_getInstance() {
@@ -440,910 +421,910 @@
440
421
  return function_0(new PrologWithArgumentationImpl());
441
422
  }
442
423
  function PrologWithArgumentationImpl() {
443
- this.y39_1 = Companion_instance_1.ofSolverFactory(ClassicSolverFactory_instance);
424
+ this.x39_1 = Companion_instance_1.ofSolverFactory(ClassicSolverFactory_instance);
444
425
  }
445
426
  protoOf(PrologWithArgumentationImpl).call1 = function (goal) {
446
- return this.y39_1.call1(goal);
427
+ return this.x39_1.call1(goal);
447
428
  };
448
429
  protoOf(PrologWithArgumentationImpl).stringInvoke = function (_this__u8e3s4, term, terms) {
449
- return this.y39_1.stringInvoke(_this__u8e3s4, term, terms);
430
+ return this.x39_1.stringInvoke(_this__u8e3s4, term, terms);
450
431
  };
451
432
  protoOf(PrologWithArgumentationImpl).structOfAny = function (functor, args) {
452
- return this.y39_1.structOfAny(functor, args);
433
+ return this.x39_1.structOfAny(functor, args);
453
434
  };
454
435
  protoOf(PrologWithArgumentationImpl).structOf = function (functor, args) {
455
- return this.y39_1.structOf(functor, args);
436
+ return this.x39_1.structOf(functor, args);
456
437
  };
457
438
  protoOf(PrologWithArgumentationImpl).structOfSequence = function (functor, args) {
458
- return this.y39_1.structOfSequence(functor, args);
439
+ return this.x39_1.structOfSequence(functor, args);
459
440
  };
460
441
  protoOf(PrologWithArgumentationImpl).structOfIterable = function (functor, args) {
461
- return this.y39_1.structOfIterable(functor, args);
442
+ return this.x39_1.structOfIterable(functor, args);
462
443
  };
463
444
  protoOf(PrologWithArgumentationImpl).structOfList = function (functor, args) {
464
- return this.y39_1.structOfList(functor, args);
445
+ return this.x39_1.structOfList(functor, args);
465
446
  };
466
447
  protoOf(PrologWithArgumentationImpl).tupleOfAny = function (terms) {
467
- return this.y39_1.tupleOfAny(terms);
448
+ return this.x39_1.tupleOfAny(terms);
468
449
  };
469
450
  protoOf(PrologWithArgumentationImpl).tupleOf = function (terms) {
470
- return this.y39_1.tupleOf(terms);
451
+ return this.x39_1.tupleOf(terms);
471
452
  };
472
453
  protoOf(PrologWithArgumentationImpl).tupleOfIterable = function (terms) {
473
- return this.y39_1.tupleOfIterable(terms);
454
+ return this.x39_1.tupleOfIterable(terms);
474
455
  };
475
456
  protoOf(PrologWithArgumentationImpl).tupleOfSequence = function (terms) {
476
- return this.y39_1.tupleOfSequence(terms);
457
+ return this.x39_1.tupleOfSequence(terms);
477
458
  };
478
459
  protoOf(PrologWithArgumentationImpl).logicListOfAny = function (terms) {
479
- return this.y39_1.logicListOfAny(terms);
460
+ return this.x39_1.logicListOfAny(terms);
480
461
  };
481
462
  protoOf(PrologWithArgumentationImpl).logicListOf = function (terms) {
482
- return this.y39_1.logicListOf(terms);
463
+ return this.x39_1.logicListOf(terms);
483
464
  };
484
465
  protoOf(PrologWithArgumentationImpl).logicListOfIterable = function (terms) {
485
- return this.y39_1.logicListOfIterable(terms);
466
+ return this.x39_1.logicListOfIterable(terms);
486
467
  };
487
468
  protoOf(PrologWithArgumentationImpl).logicListOfSequence = function (terms) {
488
- return this.y39_1.logicListOfSequence(terms);
469
+ return this.x39_1.logicListOfSequence(terms);
489
470
  };
490
471
  protoOf(PrologWithArgumentationImpl).blockOfAny = function (terms) {
491
- return this.y39_1.blockOfAny(terms);
472
+ return this.x39_1.blockOfAny(terms);
492
473
  };
493
474
  protoOf(PrologWithArgumentationImpl).blockOf = function (terms) {
494
- return this.y39_1.blockOf(terms);
475
+ return this.x39_1.blockOf(terms);
495
476
  };
496
477
  protoOf(PrologWithArgumentationImpl).blockOfIterable = function (terms) {
497
- return this.y39_1.blockOfIterable(terms);
478
+ return this.x39_1.blockOfIterable(terms);
498
479
  };
499
480
  protoOf(PrologWithArgumentationImpl).blockOfSequence = function (terms) {
500
- return this.y39_1.blockOfSequence(terms);
481
+ return this.x39_1.blockOfSequence(terms);
501
482
  };
502
483
  protoOf(PrologWithArgumentationImpl).factOfAny = function (term) {
503
- return this.y39_1.factOfAny(term);
484
+ return this.x39_1.factOfAny(term);
504
485
  };
505
486
  protoOf(PrologWithArgumentationImpl).factOf = function (head) {
506
- return this.y39_1.factOf(head);
487
+ return this.x39_1.factOf(head);
507
488
  };
508
489
  protoOf(PrologWithArgumentationImpl).consOfAny = function (head, tail) {
509
- return this.y39_1.consOfAny(head, tail);
490
+ return this.x39_1.consOfAny(head, tail);
510
491
  };
511
492
  protoOf(PrologWithArgumentationImpl).consOf = function (head, tail) {
512
- return this.y39_1.consOf(head, tail);
493
+ return this.x39_1.consOf(head, tail);
513
494
  };
514
495
  protoOf(PrologWithArgumentationImpl).directiveOfAny = function (term, terms) {
515
- return this.y39_1.directiveOfAny(term, terms);
496
+ return this.x39_1.directiveOfAny(term, terms);
516
497
  };
517
498
  protoOf(PrologWithArgumentationImpl).directiveOf = function (body1, body) {
518
- return this.y39_1.directiveOf(body1, body);
499
+ return this.x39_1.directiveOf(body1, body);
519
500
  };
520
501
  protoOf(PrologWithArgumentationImpl).withScope = function (function_0) {
521
- return this.y39_1.withScope(function_0);
502
+ return this.x39_1.withScope(function_0);
522
503
  };
523
504
  protoOf(PrologWithArgumentationImpl).a1g = function () {
524
- return this.y39_1.a1g();
505
+ return this.x39_1.a1g();
525
506
  };
526
507
  protoOf(PrologWithArgumentationImpl).r2x = function (items, tail) {
527
- return this.y39_1.r2x(items, tail);
508
+ return this.x39_1.r2x(items, tail);
528
509
  };
529
510
  protoOf(PrologWithArgumentationImpl).rule = function (function_0) {
530
- return this.y39_1.rule(function_0);
511
+ return this.x39_1.rule(function_0);
531
512
  };
532
513
  protoOf(PrologWithArgumentationImpl).clause2 = function (head, body) {
533
- return this.y39_1.clause2(head, body);
514
+ return this.x39_1.clause2(head, body);
534
515
  };
535
516
  protoOf(PrologWithArgumentationImpl).directive = function (function_0) {
536
- return this.y39_1.directive(function_0);
517
+ return this.x39_1.directive(function_0);
537
518
  };
538
519
  protoOf(PrologWithArgumentationImpl).fact = function (function_0) {
539
- return this.y39_1.fact(function_0);
520
+ return this.x39_1.fact(function_0);
540
521
  };
541
522
  protoOf(PrologWithArgumentationImpl).convertToTerm = function (_this__u8e3s4) {
542
- return this.y39_1.convertToTerm(_this__u8e3s4);
523
+ return this.x39_1.convertToTerm(_this__u8e3s4);
543
524
  };
544
525
  protoOf(PrologWithArgumentationImpl).convertToSpecificSubTypeOfTerm = function (_this__u8e3s4, type, converter) {
545
- return this.y39_1.convertToSpecificSubTypeOfTerm(_this__u8e3s4, type, converter);
526
+ return this.x39_1.convertToSpecificSubTypeOfTerm(_this__u8e3s4, type, converter);
546
527
  };
547
528
  protoOf(PrologWithArgumentationImpl).newScope = function () {
548
- return this.y39_1.newScope();
529
+ return this.x39_1.newScope();
549
530
  };
550
531
  protoOf(PrologWithArgumentationImpl).l2x = function () {
551
- return this.y39_1.l2x();
532
+ return this.x39_1.l2x();
552
533
  };
553
534
  protoOf(PrologWithArgumentationImpl).containsVar = function (variable) {
554
- return this.y39_1.containsVar(variable);
535
+ return this.x39_1.containsVar(variable);
555
536
  };
556
537
  protoOf(PrologWithArgumentationImpl).contains = function (variable) {
557
- return this.y39_1.contains(variable);
538
+ return this.x39_1.contains(variable);
558
539
  };
559
540
  protoOf(PrologWithArgumentationImpl).substitutionContains = function (_this__u8e3s4, term) {
560
- return this.y39_1.substitutionContains(_this__u8e3s4, term);
541
+ return this.x39_1.substitutionContains(_this__u8e3s4, term);
561
542
  };
562
543
  protoOf(PrologWithArgumentationImpl).get = function (variable) {
563
- return this.y39_1.get(variable);
544
+ return this.x39_1.get(variable);
564
545
  };
565
546
  protoOf(PrologWithArgumentationImpl).substitutionGet = function (_this__u8e3s4, term) {
566
- return this.y39_1.substitutionGet(_this__u8e3s4, term);
547
+ return this.x39_1.substitutionGet(_this__u8e3s4, term);
567
548
  };
568
549
  protoOf(PrologWithArgumentationImpl).where = function (lambda) {
569
- return this.y39_1.where(lambda);
550
+ return this.x39_1.where(lambda);
570
551
  };
571
552
  protoOf(PrologWithArgumentationImpl).with = function (lambda) {
572
- return this.y39_1.with(lambda);
553
+ return this.x39_1.with(lambda);
573
554
  };
574
555
  protoOf(PrologWithArgumentationImpl).varOf = function (name) {
575
- return this.y39_1.varOf(name);
556
+ return this.x39_1.varOf(name);
576
557
  };
577
558
  protoOf(PrologWithArgumentationImpl).varOfChar = function (name) {
578
- return this.y39_1.varOfChar(name);
559
+ return this.x39_1.varOfChar(name);
579
560
  };
580
561
  protoOf(PrologWithArgumentationImpl).atomOf = function (value) {
581
- return this.y39_1.atomOf(value);
562
+ return this.x39_1.atomOf(value);
582
563
  };
583
564
  protoOf(PrologWithArgumentationImpl).atomOfChar = function (value) {
584
- return this.y39_1.atomOfChar(value);
565
+ return this.x39_1.atomOfChar(value);
585
566
  };
586
567
  protoOf(PrologWithArgumentationImpl).xz = function (terms, last) {
587
- return this.y39_1.xz(terms, last);
568
+ return this.x39_1.xz(terms, last);
588
569
  };
589
570
  protoOf(PrologWithArgumentationImpl).yz = function (terms, last) {
590
- return this.y39_1.yz(terms, last);
571
+ return this.x39_1.yz(terms, last);
591
572
  };
592
573
  protoOf(PrologWithArgumentationImpl).zz = function (terms, last) {
593
- return this.y39_1.zz(terms, last);
574
+ return this.x39_1.zz(terms, last);
594
575
  };
595
576
  protoOf(PrologWithArgumentationImpl).ruleOf = function (head, body1, body) {
596
- return this.y39_1.ruleOf(head, body1, body);
577
+ return this.x39_1.ruleOf(head, body1, body);
597
578
  };
598
579
  protoOf(PrologWithArgumentationImpl).clauseOf = function (head, body) {
599
- return this.y39_1.clauseOf(head, body);
580
+ return this.x39_1.clauseOf(head, body);
600
581
  };
601
582
  protoOf(PrologWithArgumentationImpl).indicatorOf = function (name, arity) {
602
- return this.y39_1.indicatorOf(name, arity);
583
+ return this.x39_1.indicatorOf(name, arity);
603
584
  };
604
585
  protoOf(PrologWithArgumentationImpl).indicatorOfStringInt = function (name, arity) {
605
- return this.y39_1.indicatorOfStringInt(name, arity);
586
+ return this.x39_1.indicatorOfStringInt(name, arity);
606
587
  };
607
588
  protoOf(PrologWithArgumentationImpl).anonymous = function () {
608
- return this.y39_1.anonymous();
589
+ return this.x39_1.anonymous();
609
590
  };
610
591
  protoOf(PrologWithArgumentationImpl).whatever = function () {
611
- return this.y39_1.whatever();
592
+ return this.x39_1.whatever();
612
593
  };
613
594
  protoOf(PrologWithArgumentationImpl).numOfBigDecimal = function (value) {
614
- return this.y39_1.numOfBigDecimal(value);
595
+ return this.x39_1.numOfBigDecimal(value);
615
596
  };
616
597
  protoOf(PrologWithArgumentationImpl).numOfDouble = function (value) {
617
- return this.y39_1.numOfDouble(value);
598
+ return this.x39_1.numOfDouble(value);
618
599
  };
619
600
  protoOf(PrologWithArgumentationImpl).numOfFloat = function (value) {
620
- return this.y39_1.numOfFloat(value);
601
+ return this.x39_1.numOfFloat(value);
621
602
  };
622
603
  protoOf(PrologWithArgumentationImpl).numOfBigInteger = function (value) {
623
- return this.y39_1.numOfBigInteger(value);
604
+ return this.x39_1.numOfBigInteger(value);
624
605
  };
625
606
  protoOf(PrologWithArgumentationImpl).numOfInt = function (value) {
626
- return this.y39_1.numOfInt(value);
607
+ return this.x39_1.numOfInt(value);
627
608
  };
628
609
  protoOf(PrologWithArgumentationImpl).numOfLong = function (value) {
629
- return this.y39_1.numOfLong(value);
610
+ return this.x39_1.numOfLong(value);
630
611
  };
631
612
  protoOf(PrologWithArgumentationImpl).numOfShort = function (value) {
632
- return this.y39_1.numOfShort(value);
613
+ return this.x39_1.numOfShort(value);
633
614
  };
634
615
  protoOf(PrologWithArgumentationImpl).numOfByte = function (value) {
635
- return this.y39_1.numOfByte(value);
616
+ return this.x39_1.numOfByte(value);
636
617
  };
637
618
  protoOf(PrologWithArgumentationImpl).parseNum = function (value) {
638
- return this.y39_1.parseNum(value);
619
+ return this.x39_1.parseNum(value);
639
620
  };
640
621
  protoOf(PrologWithArgumentationImpl).numOf = function (value) {
641
- return this.y39_1.numOf(value);
622
+ return this.x39_1.numOf(value);
642
623
  };
643
624
  protoOf(PrologWithArgumentationImpl).intOfBigInteger = function (value) {
644
- return this.y39_1.intOfBigInteger(value);
625
+ return this.x39_1.intOfBigInteger(value);
645
626
  };
646
627
  protoOf(PrologWithArgumentationImpl).intOf = function (value) {
647
- return this.y39_1.intOf(value);
628
+ return this.x39_1.intOf(value);
648
629
  };
649
630
  protoOf(PrologWithArgumentationImpl).intOfLong = function (value) {
650
- return this.y39_1.intOfLong(value);
631
+ return this.x39_1.intOfLong(value);
651
632
  };
652
633
  protoOf(PrologWithArgumentationImpl).intOfShort = function (value) {
653
- return this.y39_1.intOfShort(value);
634
+ return this.x39_1.intOfShort(value);
654
635
  };
655
636
  protoOf(PrologWithArgumentationImpl).intOfByte = function (value) {
656
- return this.y39_1.intOfByte(value);
637
+ return this.x39_1.intOfByte(value);
657
638
  };
658
639
  protoOf(PrologWithArgumentationImpl).parseInt = function (value) {
659
- return this.y39_1.parseInt(value);
640
+ return this.x39_1.parseInt(value);
660
641
  };
661
642
  protoOf(PrologWithArgumentationImpl).parseIntRadix = function (value, radix) {
662
- return this.y39_1.parseIntRadix(value, radix);
643
+ return this.x39_1.parseIntRadix(value, radix);
663
644
  };
664
645
  protoOf(PrologWithArgumentationImpl).realOfBigDecimal = function (value) {
665
- return this.y39_1.realOfBigDecimal(value);
646
+ return this.x39_1.realOfBigDecimal(value);
666
647
  };
667
648
  protoOf(PrologWithArgumentationImpl).realOf = function (value) {
668
- return this.y39_1.realOf(value);
649
+ return this.x39_1.realOf(value);
669
650
  };
670
651
  protoOf(PrologWithArgumentationImpl).realOfFloat = function (value) {
671
- return this.y39_1.realOfFloat(value);
652
+ return this.x39_1.realOfFloat(value);
672
653
  };
673
654
  protoOf(PrologWithArgumentationImpl).parseReal = function (value) {
674
- return this.y39_1.parseReal(value);
655
+ return this.x39_1.parseReal(value);
675
656
  };
676
657
  protoOf(PrologWithArgumentationImpl).truthOf = function (value) {
677
- return this.y39_1.truthOf(value);
658
+ return this.x39_1.truthOf(value);
678
659
  };
679
660
  protoOf(PrologWithArgumentationImpl).unifierOf = function (assignments) {
680
- return this.y39_1.unifierOf(assignments);
661
+ return this.x39_1.unifierOf(assignments);
681
662
  };
682
663
  protoOf(PrologWithArgumentationImpl).unifierOfIterable = function (assignments) {
683
- return this.y39_1.unifierOfIterable(assignments);
664
+ return this.x39_1.unifierOfIterable(assignments);
684
665
  };
685
666
  protoOf(PrologWithArgumentationImpl).unifierOfSequence = function (assignments) {
686
- return this.y39_1.unifierOfSequence(assignments);
667
+ return this.x39_1.unifierOfSequence(assignments);
687
668
  };
688
669
  protoOf(PrologWithArgumentationImpl).substitutionOf = function (assignments) {
689
- return this.y39_1.substitutionOf(assignments);
670
+ return this.x39_1.substitutionOf(assignments);
690
671
  };
691
672
  protoOf(PrologWithArgumentationImpl).substitutionOfIterable = function (assignments) {
692
- return this.y39_1.substitutionOfIterable(assignments);
673
+ return this.x39_1.substitutionOfIterable(assignments);
693
674
  };
694
675
  protoOf(PrologWithArgumentationImpl).substitutionOfSequence = function (assignments) {
695
- return this.y39_1.substitutionOfSequence(assignments);
676
+ return this.x39_1.substitutionOfSequence(assignments);
696
677
  };
697
678
  protoOf(PrologWithArgumentationImpl).vz = function () {
698
- return this.y39_1.vz();
679
+ return this.x39_1.vz();
699
680
  };
700
681
  protoOf(PrologWithArgumentationImpl).wz = function () {
701
- return this.y39_1.wz();
682
+ return this.x39_1.wz();
702
683
  };
703
684
  protoOf(PrologWithArgumentationImpl).varTo = function (_this__u8e3s4, termObject) {
704
- return this.y39_1.varTo(_this__u8e3s4, termObject);
685
+ return this.x39_1.varTo(_this__u8e3s4, termObject);
705
686
  };
706
687
  protoOf(PrologWithArgumentationImpl).stringTo = function (_this__u8e3s4, termObject) {
707
- return this.y39_1.stringTo(_this__u8e3s4, termObject);
688
+ return this.x39_1.stringTo(_this__u8e3s4, termObject);
708
689
  };
709
690
  protoOf(PrologWithArgumentationImpl).substitutionContainsKey = function (_this__u8e3s4, term) {
710
- return this.y39_1.substitutionContainsKey(_this__u8e3s4, term);
691
+ return this.x39_1.substitutionContainsKey(_this__u8e3s4, term);
711
692
  };
712
693
  protoOf(PrologWithArgumentationImpl).substitutionContainsValue = function (_this__u8e3s4, term) {
713
- return this.y39_1.substitutionContainsValue(_this__u8e3s4, term);
694
+ return this.x39_1.substitutionContainsValue(_this__u8e3s4, term);
714
695
  };
715
696
  protoOf(PrologWithArgumentationImpl).at_end_of_stream1 = function (alias) {
716
- return this.y39_1.at_end_of_stream1(alias);
697
+ return this.x39_1.at_end_of_stream1(alias);
717
698
  };
718
699
  protoOf(PrologWithArgumentationImpl).catch3 = function (goal, error, continuation) {
719
- return this.y39_1.catch3(goal, error, continuation);
700
+ return this.x39_1.catch3(goal, error, continuation);
720
701
  };
721
702
  protoOf(PrologWithArgumentationImpl).throw1 = function (error) {
722
- return this.y39_1.throw1(error);
703
+ return this.x39_1.throw1(error);
723
704
  };
724
705
  protoOf(PrologWithArgumentationImpl).not1 = function (goal) {
725
- return this.y39_1.not1(goal);
706
+ return this.x39_1.not1(goal);
726
707
  };
727
708
  protoOf(PrologWithArgumentationImpl).naf1 = function (goal) {
728
- return this.y39_1.naf1(goal);
709
+ return this.x39_1.naf1(goal);
729
710
  };
730
711
  protoOf(PrologWithArgumentationImpl).assert1 = function (clause) {
731
- return this.y39_1.assert1(clause);
712
+ return this.x39_1.assert1(clause);
732
713
  };
733
714
  protoOf(PrologWithArgumentationImpl).asserta1 = function (clause) {
734
- return this.y39_1.asserta1(clause);
715
+ return this.x39_1.asserta1(clause);
735
716
  };
736
717
  protoOf(PrologWithArgumentationImpl).assertz1 = function (clause) {
737
- return this.y39_1.assertz1(clause);
718
+ return this.x39_1.assertz1(clause);
738
719
  };
739
720
  protoOf(PrologWithArgumentationImpl).arg3 = function (index, compound, argument) {
740
- return this.y39_1.arg3(index, compound, argument);
721
+ return this.x39_1.arg3(index, compound, argument);
741
722
  };
742
723
  protoOf(PrologWithArgumentationImpl).atom1 = function (atom) {
743
- return this.y39_1.atom1(atom);
724
+ return this.x39_1.atom1(atom);
744
725
  };
745
726
  protoOf(PrologWithArgumentationImpl).atomic1 = function (atomic) {
746
- return this.y39_1.atomic1(atomic);
727
+ return this.x39_1.atomic1(atomic);
747
728
  };
748
729
  protoOf(PrologWithArgumentationImpl).between3 = function (min, max, number) {
749
- return this.y39_1.between3(min, max, number);
730
+ return this.x39_1.between3(min, max, number);
750
731
  };
751
732
  protoOf(PrologWithArgumentationImpl).callable1 = function (goal) {
752
- return this.y39_1.callable1(goal);
733
+ return this.x39_1.callable1(goal);
753
734
  };
754
735
  protoOf(PrologWithArgumentationImpl).compound1 = function (struct) {
755
- return this.y39_1.compound1(struct);
736
+ return this.x39_1.compound1(struct);
756
737
  };
757
738
  protoOf(PrologWithArgumentationImpl).current_op3 = function (precedence, specifier, functor) {
758
- return this.y39_1.current_op3(precedence, specifier, functor);
739
+ return this.x39_1.current_op3(precedence, specifier, functor);
759
740
  };
760
741
  protoOf(PrologWithArgumentationImpl).op3 = function (precedence, specifier, functor) {
761
- return this.y39_1.op3(precedence, specifier, functor);
742
+ return this.x39_1.op3(precedence, specifier, functor);
762
743
  };
763
744
  protoOf(PrologWithArgumentationImpl).findall3 = function (template, goal, bag) {
764
- return this.y39_1.findall3(template, goal, bag);
745
+ return this.x39_1.findall3(template, goal, bag);
765
746
  };
766
747
  protoOf(PrologWithArgumentationImpl).float1 = function (number) {
767
- return this.y39_1.float1(number);
748
+ return this.x39_1.float1(number);
768
749
  };
769
750
  protoOf(PrologWithArgumentationImpl).functor3 = function (struct, functor, arity) {
770
- return this.y39_1.functor3(struct, functor, arity);
751
+ return this.x39_1.functor3(struct, functor, arity);
771
752
  };
772
753
  protoOf(PrologWithArgumentationImpl).ground1 = function (term) {
773
- return this.y39_1.ground1(term);
754
+ return this.x39_1.ground1(term);
774
755
  };
775
756
  protoOf(PrologWithArgumentationImpl).integer1 = function (number) {
776
- return this.y39_1.integer1(number);
757
+ return this.x39_1.integer1(number);
777
758
  };
778
759
  protoOf(PrologWithArgumentationImpl).natural = function (number) {
779
- return this.y39_1.natural(number);
760
+ return this.x39_1.natural(number);
780
761
  };
781
762
  protoOf(PrologWithArgumentationImpl).nonvar1 = function (number) {
782
- return this.y39_1.nonvar1(number);
763
+ return this.x39_1.nonvar1(number);
783
764
  };
784
765
  protoOf(PrologWithArgumentationImpl).number1 = function (number) {
785
- return this.y39_1.number1(number);
766
+ return this.x39_1.number1(number);
786
767
  };
787
768
  protoOf(PrologWithArgumentationImpl).var1 = function (term) {
788
- return this.y39_1.var1(term);
769
+ return this.x39_1.var1(term);
789
770
  };
790
771
  protoOf(PrologWithArgumentationImpl).write1 = function (term) {
791
- return this.y39_1.write1(term);
772
+ return this.x39_1.write1(term);
792
773
  };
793
774
  protoOf(PrologWithArgumentationImpl).univ2 = function (_this__u8e3s4, other) {
794
- return this.y39_1.univ2(_this__u8e3s4, other);
775
+ return this.x39_1.univ2(_this__u8e3s4, other);
795
776
  };
796
777
  protoOf(PrologWithArgumentationImpl).eq2 = function (_this__u8e3s4, right) {
797
- return this.y39_1.eq2(_this__u8e3s4, right);
778
+ return this.x39_1.eq2(_this__u8e3s4, right);
798
779
  };
799
780
  protoOf(PrologWithArgumentationImpl).neq2 = function (_this__u8e3s4, right) {
800
- return this.y39_1.neq2(_this__u8e3s4, right);
781
+ return this.x39_1.neq2(_this__u8e3s4, right);
801
782
  };
802
783
  protoOf(PrologWithArgumentationImpl).id2 = function (_this__u8e3s4, right) {
803
- return this.y39_1.id2(_this__u8e3s4, right);
784
+ return this.x39_1.id2(_this__u8e3s4, right);
804
785
  };
805
786
  protoOf(PrologWithArgumentationImpl).nid2 = function (_this__u8e3s4, right) {
806
- return this.y39_1.nid2(_this__u8e3s4, right);
787
+ return this.x39_1.nid2(_this__u8e3s4, right);
807
788
  };
808
789
  protoOf(PrologWithArgumentationImpl).arithEq2 = function (_this__u8e3s4, right) {
809
- return this.y39_1.arithEq2(_this__u8e3s4, right);
790
+ return this.x39_1.arithEq2(_this__u8e3s4, right);
810
791
  };
811
792
  protoOf(PrologWithArgumentationImpl).arithNeq2 = function (_this__u8e3s4, right) {
812
- return this.y39_1.arithNeq2(_this__u8e3s4, right);
793
+ return this.x39_1.arithNeq2(_this__u8e3s4, right);
813
794
  };
814
795
  protoOf(PrologWithArgumentationImpl).member2 = function (item, list) {
815
- return this.y39_1.member2(item, list);
796
+ return this.x39_1.member2(item, list);
816
797
  };
817
798
  protoOf(PrologWithArgumentationImpl).retract1 = function (clause) {
818
- return this.y39_1.retract1(clause);
799
+ return this.x39_1.retract1(clause);
819
800
  };
820
801
  protoOf(PrologWithArgumentationImpl).retract = function (clause) {
821
- return this.y39_1.retract(clause);
802
+ return this.x39_1.retract(clause);
822
803
  };
823
804
  protoOf(PrologWithArgumentationImpl).retractByHead = function (fact) {
824
- return this.y39_1.retractByHead(fact);
805
+ return this.x39_1.retractByHead(fact);
825
806
  };
826
807
  protoOf(PrologWithArgumentationImpl).append3 = function (left, right, result) {
827
- return this.y39_1.append3(left, right, result);
808
+ return this.x39_1.append3(left, right, result);
828
809
  };
829
810
  protoOf(PrologWithArgumentationImpl).retractall1 = function (clause) {
830
- return this.y39_1.retractall1(clause);
811
+ return this.x39_1.retractall1(clause);
831
812
  };
832
813
  protoOf(PrologWithArgumentationImpl).abolish1 = function (indicator) {
833
- return this.y39_1.abolish1(indicator);
814
+ return this.x39_1.abolish1(indicator);
834
815
  };
835
816
  protoOf(PrologWithArgumentationImpl).atom_chars2 = function (atom, chars) {
836
- return this.y39_1.atom_chars2(atom, chars);
817
+ return this.x39_1.atom_chars2(atom, chars);
837
818
  };
838
819
  protoOf(PrologWithArgumentationImpl).atom_codes2 = function (atom, codes) {
839
- return this.y39_1.atom_codes2(atom, codes);
820
+ return this.x39_1.atom_codes2(atom, codes);
840
821
  };
841
822
  protoOf(PrologWithArgumentationImpl).atom_concat3 = function (first, second, result) {
842
- return this.y39_1.atom_concat3(first, second, result);
823
+ return this.x39_1.atom_concat3(first, second, result);
843
824
  };
844
825
  protoOf(PrologWithArgumentationImpl).atom_length2 = function (atom, length) {
845
- return this.y39_1.atom_length2(atom, length);
826
+ return this.x39_1.atom_length2(atom, length);
846
827
  };
847
828
  protoOf(PrologWithArgumentationImpl).char_code2 = function (char, code) {
848
- return this.y39_1.char_code2(char, code);
829
+ return this.x39_1.char_code2(char, code);
849
830
  };
850
831
  protoOf(PrologWithArgumentationImpl).copy_term2 = function (term, copy) {
851
- return this.y39_1.copy_term2(term, copy);
832
+ return this.x39_1.copy_term2(term, copy);
852
833
  };
853
834
  protoOf(PrologWithArgumentationImpl).current_flag2 = function (name, value) {
854
- return this.y39_1.current_flag2(name, value);
835
+ return this.x39_1.current_flag2(name, value);
855
836
  };
856
837
  protoOf(PrologWithArgumentationImpl).current_prolog_flag2 = function (name, value) {
857
- return this.y39_1.current_prolog_flag2(name, value);
838
+ return this.x39_1.current_prolog_flag2(name, value);
858
839
  };
859
840
  protoOf(PrologWithArgumentationImpl).sub_atom5 = function (atom, before, length, after, sub_atom) {
860
- return this.y39_1.sub_atom5(atom, before, length, after, sub_atom);
841
+ return this.x39_1.sub_atom5(atom, before, length, after, sub_atom);
861
842
  };
862
843
  protoOf(PrologWithArgumentationImpl).number_chars2 = function (first, second) {
863
- return this.y39_1.number_chars2(first, second);
844
+ return this.x39_1.number_chars2(first, second);
864
845
  };
865
846
  protoOf(PrologWithArgumentationImpl).number_codes2 = function (first, second) {
866
- return this.y39_1.number_codes2(first, second);
847
+ return this.x39_1.number_codes2(first, second);
867
848
  };
868
849
  protoOf(PrologWithArgumentationImpl).bagof3 = function (template, goal, bag) {
869
- return this.y39_1.bagof3(template, goal, bag);
850
+ return this.x39_1.bagof3(template, goal, bag);
870
851
  };
871
852
  protoOf(PrologWithArgumentationImpl).setof3 = function (template, goal, bag) {
872
- return this.y39_1.setof3(template, goal, bag);
853
+ return this.x39_1.setof3(template, goal, bag);
873
854
  };
874
855
  protoOf(PrologWithArgumentationImpl).consult1 = function (url) {
875
- return this.y39_1.consult1(url);
856
+ return this.x39_1.consult1(url);
876
857
  };
877
858
  protoOf(PrologWithArgumentationImpl).set_flag2 = function (name, value) {
878
- return this.y39_1.set_flag2(name, value);
859
+ return this.x39_1.set_flag2(name, value);
879
860
  };
880
861
  protoOf(PrologWithArgumentationImpl).set_prolog_flag2 = function (name, value) {
881
- return this.y39_1.set_prolog_flag2(name, value);
862
+ return this.x39_1.set_prolog_flag2(name, value);
882
863
  };
883
864
  protoOf(PrologWithArgumentationImpl).dynamic1 = function (indicator) {
884
- return this.y39_1.dynamic1(indicator);
865
+ return this.x39_1.dynamic1(indicator);
885
866
  };
886
867
  protoOf(PrologWithArgumentationImpl).static1 = function (indicator) {
887
- return this.y39_1.static1(indicator);
868
+ return this.x39_1.static1(indicator);
888
869
  };
889
870
  protoOf(PrologWithArgumentationImpl).solve1 = function (goal) {
890
- return this.y39_1.solve1(goal);
871
+ return this.x39_1.solve1(goal);
891
872
  };
892
873
  protoOf(PrologWithArgumentationImpl).solveWithTimeout = function (goal, timeout) {
893
- return this.y39_1.solveWithTimeout(goal, timeout);
874
+ return this.x39_1.solveWithTimeout(goal, timeout);
894
875
  };
895
876
  protoOf(PrologWithArgumentationImpl).solve = function (goal) {
896
- return this.y39_1.solve(goal);
877
+ return this.x39_1.solve(goal);
897
878
  };
898
879
  protoOf(PrologWithArgumentationImpl).solveWithOptions = function (goal, options) {
899
- return this.y39_1.solveWithOptions(goal, options);
880
+ return this.x39_1.solveWithOptions(goal, options);
900
881
  };
901
882
  protoOf(PrologWithArgumentationImpl).initialization1 = function (goal) {
902
- return this.y39_1.initialization1(goal);
883
+ return this.x39_1.initialization1(goal);
903
884
  };
904
885
  protoOf(PrologWithArgumentationImpl).load1 = function (url) {
905
- return this.y39_1.load1(url);
886
+ return this.x39_1.load1(url);
906
887
  };
907
888
  protoOf(PrologWithArgumentationImpl).include1 = function (url) {
908
- return this.y39_1.include1(url);
889
+ return this.x39_1.include1(url);
909
890
  };
910
891
  protoOf(PrologWithArgumentationImpl).termPlus = function (_this__u8e3s4, other) {
911
- return this.y39_1.termPlus(_this__u8e3s4, other);
892
+ return this.x39_1.termPlus(_this__u8e3s4, other);
912
893
  };
913
894
  protoOf(PrologWithArgumentationImpl).number = function (_this__u8e3s4, other) {
914
- return this.y39_1.number(_this__u8e3s4, other);
895
+ return this.x39_1.number(_this__u8e3s4, other);
915
896
  };
916
897
  protoOf(PrologWithArgumentationImpl).booleanPlus = function (_this__u8e3s4, other) {
917
- return this.y39_1.booleanPlus(_this__u8e3s4, other);
898
+ return this.x39_1.booleanPlus(_this__u8e3s4, other);
918
899
  };
919
900
  protoOf(PrologWithArgumentationImpl).charPlus = function (_this__u8e3s4, other) {
920
- return this.y39_1.charPlus(_this__u8e3s4, other);
901
+ return this.x39_1.charPlus(_this__u8e3s4, other);
921
902
  };
922
903
  protoOf(PrologWithArgumentationImpl).termMinus = function (_this__u8e3s4, other) {
923
- return this.y39_1.termMinus(_this__u8e3s4, other);
904
+ return this.x39_1.termMinus(_this__u8e3s4, other);
924
905
  };
925
906
  protoOf(PrologWithArgumentationImpl).numberMinus = function (_this__u8e3s4, other) {
926
- return this.y39_1.numberMinus(_this__u8e3s4, other);
907
+ return this.x39_1.numberMinus(_this__u8e3s4, other);
927
908
  };
928
909
  protoOf(PrologWithArgumentationImpl).booleanMinus = function (_this__u8e3s4, other) {
929
- return this.y39_1.booleanMinus(_this__u8e3s4, other);
910
+ return this.x39_1.booleanMinus(_this__u8e3s4, other);
930
911
  };
931
912
  protoOf(PrologWithArgumentationImpl).charMinus = function (_this__u8e3s4, other) {
932
- return this.y39_1.charMinus(_this__u8e3s4, other);
913
+ return this.x39_1.charMinus(_this__u8e3s4, other);
933
914
  };
934
915
  protoOf(PrologWithArgumentationImpl).stringMinus = function (_this__u8e3s4, other) {
935
- return this.y39_1.stringMinus(_this__u8e3s4, other);
916
+ return this.x39_1.stringMinus(_this__u8e3s4, other);
936
917
  };
937
918
  protoOf(PrologWithArgumentationImpl).termTimes = function (_this__u8e3s4, other) {
938
- return this.y39_1.termTimes(_this__u8e3s4, other);
919
+ return this.x39_1.termTimes(_this__u8e3s4, other);
939
920
  };
940
921
  protoOf(PrologWithArgumentationImpl).numberTimes = function (_this__u8e3s4, other) {
941
- return this.y39_1.numberTimes(_this__u8e3s4, other);
922
+ return this.x39_1.numberTimes(_this__u8e3s4, other);
942
923
  };
943
924
  protoOf(PrologWithArgumentationImpl).booleanTimes = function (_this__u8e3s4, other) {
944
- return this.y39_1.booleanTimes(_this__u8e3s4, other);
925
+ return this.x39_1.booleanTimes(_this__u8e3s4, other);
945
926
  };
946
927
  protoOf(PrologWithArgumentationImpl).charTimes = function (_this__u8e3s4, other) {
947
- return this.y39_1.charTimes(_this__u8e3s4, other);
928
+ return this.x39_1.charTimes(_this__u8e3s4, other);
948
929
  };
949
930
  protoOf(PrologWithArgumentationImpl).stringTimes = function (_this__u8e3s4, other) {
950
- return this.y39_1.stringTimes(_this__u8e3s4, other);
931
+ return this.x39_1.stringTimes(_this__u8e3s4, other);
951
932
  };
952
933
  protoOf(PrologWithArgumentationImpl).termDiv = function (_this__u8e3s4, other) {
953
- return this.y39_1.termDiv(_this__u8e3s4, other);
934
+ return this.x39_1.termDiv(_this__u8e3s4, other);
954
935
  };
955
936
  protoOf(PrologWithArgumentationImpl).numberDiv = function (_this__u8e3s4, other) {
956
- return this.y39_1.numberDiv(_this__u8e3s4, other);
937
+ return this.x39_1.numberDiv(_this__u8e3s4, other);
957
938
  };
958
939
  protoOf(PrologWithArgumentationImpl).booleanDiv = function (_this__u8e3s4, other) {
959
- return this.y39_1.booleanDiv(_this__u8e3s4, other);
940
+ return this.x39_1.booleanDiv(_this__u8e3s4, other);
960
941
  };
961
942
  protoOf(PrologWithArgumentationImpl).charDiv = function (_this__u8e3s4, other) {
962
- return this.y39_1.charDiv(_this__u8e3s4, other);
943
+ return this.x39_1.charDiv(_this__u8e3s4, other);
963
944
  };
964
945
  protoOf(PrologWithArgumentationImpl).stringDiv = function (_this__u8e3s4, other) {
965
- return this.y39_1.stringDiv(_this__u8e3s4, other);
946
+ return this.x39_1.stringDiv(_this__u8e3s4, other);
966
947
  };
967
948
  protoOf(PrologWithArgumentationImpl).anyEqualsTo = function (_this__u8e3s4, other) {
968
- return this.y39_1.anyEqualsTo(_this__u8e3s4, other);
949
+ return this.x39_1.anyEqualsTo(_this__u8e3s4, other);
969
950
  };
970
951
  protoOf(PrologWithArgumentationImpl).anyNotEqualsTo = function (_this__u8e3s4, other) {
971
- return this.y39_1.anyNotEqualsTo(_this__u8e3s4, other);
952
+ return this.x39_1.anyNotEqualsTo(_this__u8e3s4, other);
972
953
  };
973
954
  protoOf(PrologWithArgumentationImpl).anyGreaterThan = function (_this__u8e3s4, other) {
974
- return this.y39_1.anyGreaterThan(_this__u8e3s4, other);
955
+ return this.x39_1.anyGreaterThan(_this__u8e3s4, other);
975
956
  };
976
957
  protoOf(PrologWithArgumentationImpl).anyGreaterThanOrEqualsTo = function (_this__u8e3s4, other) {
977
- return this.y39_1.anyGreaterThanOrEqualsTo(_this__u8e3s4, other);
958
+ return this.x39_1.anyGreaterThanOrEqualsTo(_this__u8e3s4, other);
978
959
  };
979
960
  protoOf(PrologWithArgumentationImpl).anyNonLowerThan = function (_this__u8e3s4, other) {
980
- return this.y39_1.anyNonLowerThan(_this__u8e3s4, other);
961
+ return this.x39_1.anyNonLowerThan(_this__u8e3s4, other);
981
962
  };
982
963
  protoOf(PrologWithArgumentationImpl).anyLowerThan = function (_this__u8e3s4, other) {
983
- return this.y39_1.anyLowerThan(_this__u8e3s4, other);
964
+ return this.x39_1.anyLowerThan(_this__u8e3s4, other);
984
965
  };
985
966
  protoOf(PrologWithArgumentationImpl).anyLowerThanOrEqualsTo = function (_this__u8e3s4, other) {
986
- return this.y39_1.anyLowerThanOrEqualsTo(_this__u8e3s4, other);
967
+ return this.x39_1.anyLowerThanOrEqualsTo(_this__u8e3s4, other);
987
968
  };
988
969
  protoOf(PrologWithArgumentationImpl).anyNonGreaterThan = function (_this__u8e3s4, other) {
989
- return this.y39_1.anyNonGreaterThan(_this__u8e3s4, other);
970
+ return this.x39_1.anyNonGreaterThan(_this__u8e3s4, other);
990
971
  };
991
972
  protoOf(PrologWithArgumentationImpl).anyIntDiv = function (_this__u8e3s4, other) {
992
- return this.y39_1.anyIntDiv(_this__u8e3s4, other);
973
+ return this.x39_1.anyIntDiv(_this__u8e3s4, other);
993
974
  };
994
975
  protoOf(PrologWithArgumentationImpl).termRem = function (_this__u8e3s4, other) {
995
- return this.y39_1.termRem(_this__u8e3s4, other);
976
+ return this.x39_1.termRem(_this__u8e3s4, other);
996
977
  };
997
978
  protoOf(PrologWithArgumentationImpl).numberRem = function (_this__u8e3s4, other) {
998
- return this.y39_1.numberRem(_this__u8e3s4, other);
979
+ return this.x39_1.numberRem(_this__u8e3s4, other);
999
980
  };
1000
981
  protoOf(PrologWithArgumentationImpl).booleanRem = function (_this__u8e3s4, other) {
1001
- return this.y39_1.booleanRem(_this__u8e3s4, other);
982
+ return this.x39_1.booleanRem(_this__u8e3s4, other);
1002
983
  };
1003
984
  protoOf(PrologWithArgumentationImpl).charRem = function (_this__u8e3s4, other) {
1004
- return this.y39_1.charRem(_this__u8e3s4, other);
985
+ return this.x39_1.charRem(_this__u8e3s4, other);
1005
986
  };
1006
987
  protoOf(PrologWithArgumentationImpl).stringRem = function (_this__u8e3s4, other) {
1007
- return this.y39_1.stringRem(_this__u8e3s4, other);
988
+ return this.x39_1.stringRem(_this__u8e3s4, other);
1008
989
  };
1009
990
  protoOf(PrologWithArgumentationImpl).anyAnd = function (_this__u8e3s4, other) {
1010
- return this.y39_1.anyAnd(_this__u8e3s4, other);
991
+ return this.x39_1.anyAnd(_this__u8e3s4, other);
1011
992
  };
1012
993
  protoOf(PrologWithArgumentationImpl).anyOr = function (_this__u8e3s4, other) {
1013
- return this.y39_1.anyOr(_this__u8e3s4, other);
994
+ return this.x39_1.anyOr(_this__u8e3s4, other);
1014
995
  };
1015
996
  protoOf(PrologWithArgumentationImpl).anyPow = function (_this__u8e3s4, other) {
1016
- return this.y39_1.anyPow(_this__u8e3s4, other);
997
+ return this.x39_1.anyPow(_this__u8e3s4, other);
1017
998
  };
1018
999
  protoOf(PrologWithArgumentationImpl).anySup = function (_this__u8e3s4, other) {
1019
- return this.y39_1.anySup(_this__u8e3s4, other);
1000
+ return this.x39_1.anySup(_this__u8e3s4, other);
1020
1001
  };
1021
1002
  protoOf(PrologWithArgumentationImpl).anyIs = function (_this__u8e3s4, other) {
1022
- return this.y39_1.anyIs(_this__u8e3s4, other);
1003
+ return this.x39_1.anyIs(_this__u8e3s4, other);
1023
1004
  };
1024
1005
  protoOf(PrologWithArgumentationImpl).anyThen = function (_this__u8e3s4, other) {
1025
- return this.y39_1.anyThen(_this__u8e3s4, other);
1006
+ return this.x39_1.anyThen(_this__u8e3s4, other);
1026
1007
  };
1027
1008
  protoOf(PrologWithArgumentationImpl).anyImpliedBy = function (_this__u8e3s4, other) {
1028
- return this.y39_1.anyImpliedBy(_this__u8e3s4, other);
1009
+ return this.x39_1.anyImpliedBy(_this__u8e3s4, other);
1029
1010
  };
1030
1011
  protoOf(PrologWithArgumentationImpl).anyImpliedByVararg = function (_this__u8e3s4, other) {
1031
- return this.y39_1.anyImpliedByVararg(_this__u8e3s4, other);
1012
+ return this.x39_1.anyImpliedByVararg(_this__u8e3s4, other);
1032
1013
  };
1033
1014
  protoOf(PrologWithArgumentationImpl).anyIf = function (_this__u8e3s4, other) {
1034
- return this.y39_1.anyIf(_this__u8e3s4, other);
1015
+ return this.x39_1.anyIf(_this__u8e3s4, other);
1035
1016
  };
1036
1017
  protoOf(PrologWithArgumentationImpl).anyIfVararg = function (_this__u8e3s4, other) {
1037
- return this.y39_1.anyIfVararg(_this__u8e3s4, other);
1018
+ return this.x39_1.anyIfVararg(_this__u8e3s4, other);
1038
1019
  };
1039
1020
  protoOf(PrologWithArgumentationImpl).b1g = function (scope) {
1040
- return this.y39_1.b1g(scope);
1021
+ return this.x39_1.b1g(scope);
1041
1022
  };
1042
1023
  protoOf(PrologWithArgumentationImpl).t1q = function (unificator) {
1043
- return this.y39_1.t1q(unificator);
1024
+ return this.x39_1.t1q(unificator);
1044
1025
  };
1045
1026
  protoOf(PrologWithArgumentationImpl).q1t = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
1046
- return this.y39_1.q1t(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
1027
+ return this.x39_1.q1t(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
1047
1028
  };
1048
1029
  protoOf(PrologWithArgumentationImpl).copy = function (unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, $super) {
1049
1030
  return this.copy(unificator, libraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings, ($super == null ? true : $super instanceof PrologWithArgumentationImpl) ? $super : THROW_CCE());
1050
1031
  };
1051
1032
  protoOf(PrologWithArgumentationImpl).getValue = function (thisRef, property) {
1052
- return this.y39_1.getValue(thisRef, property);
1033
+ return this.x39_1.getValue(thisRef, property);
1053
1034
  };
1054
1035
  protoOf(PrologWithArgumentationImpl).d1g = function () {
1055
- return this.y39_1.d1g();
1036
+ return this.x39_1.d1g();
1056
1037
  };
1057
1038
  protoOf(PrologWithArgumentationImpl).e1g = function () {
1058
- return this.y39_1.e1g();
1039
+ return this.x39_1.e1g();
1059
1040
  };
1060
1041
  protoOf(PrologWithArgumentationImpl).anyMguWith = function (_this__u8e3s4, other) {
1061
- return this.y39_1.anyMguWith(_this__u8e3s4, other);
1042
+ return this.x39_1.anyMguWith(_this__u8e3s4, other);
1062
1043
  };
1063
1044
  protoOf(PrologWithArgumentationImpl).anyMatches = function (_this__u8e3s4, other) {
1064
- return this.y39_1.anyMatches(_this__u8e3s4, other);
1045
+ return this.x39_1.anyMatches(_this__u8e3s4, other);
1065
1046
  };
1066
1047
  protoOf(PrologWithArgumentationImpl).anyUnifyWith = function (_this__u8e3s4, other) {
1067
- return this.y39_1.anyUnifyWith(_this__u8e3s4, other);
1048
+ return this.x39_1.anyUnifyWith(_this__u8e3s4, other);
1068
1049
  };
1069
1050
  protoOf(PrologWithArgumentationImpl).w2x = function (term1, term2, occurCheckEnabled) {
1070
- return this.y39_1.w2x(term1, term2, occurCheckEnabled);
1051
+ return this.x39_1.w2x(term1, term2, occurCheckEnabled);
1071
1052
  };
1072
1053
  protoOf(PrologWithArgumentationImpl).u1h = function (term1, term2, occurCheckEnabled) {
1073
- return this.y39_1.u1h(term1, term2, occurCheckEnabled);
1054
+ return this.x39_1.u1h(term1, term2, occurCheckEnabled);
1074
1055
  };
1075
1056
  protoOf(PrologWithArgumentationImpl).mgu = function (term1, term2) {
1076
- return this.y39_1.mgu(term1, term2);
1057
+ return this.x39_1.mgu(term1, term2);
1077
1058
  };
1078
1059
  protoOf(PrologWithArgumentationImpl).x2x = function (term1, term2, occurCheckEnabled) {
1079
- return this.y39_1.x2x(term1, term2, occurCheckEnabled);
1060
+ return this.x39_1.x2x(term1, term2, occurCheckEnabled);
1080
1061
  };
1081
1062
  protoOf(PrologWithArgumentationImpl).matchWithOccurCheck = function (term1, term2, occurCheckEnabled) {
1082
- return this.y39_1.matchWithOccurCheck(term1, term2, occurCheckEnabled);
1063
+ return this.x39_1.matchWithOccurCheck(term1, term2, occurCheckEnabled);
1083
1064
  };
1084
1065
  protoOf(PrologWithArgumentationImpl).match = function (term1, term2) {
1085
- return this.y39_1.match(term1, term2);
1066
+ return this.x39_1.match(term1, term2);
1086
1067
  };
1087
1068
  protoOf(PrologWithArgumentationImpl).y2x = function (term1, term2, occurCheckEnabled) {
1088
- return this.y39_1.y2x(term1, term2, occurCheckEnabled);
1069
+ return this.x39_1.y2x(term1, term2, occurCheckEnabled);
1089
1070
  };
1090
1071
  protoOf(PrologWithArgumentationImpl).unifyWithOccurCheck = function (term1, term2, occurCheckEnabled) {
1091
- return this.y39_1.unifyWithOccurCheck(term1, term2, occurCheckEnabled);
1072
+ return this.x39_1.unifyWithOccurCheck(term1, term2, occurCheckEnabled);
1092
1073
  };
1093
1074
  protoOf(PrologWithArgumentationImpl).unify = function (term1, term2) {
1094
- return this.y39_1.unify(term1, term2);
1075
+ return this.x39_1.unify(term1, term2);
1095
1076
  };
1096
1077
  protoOf(PrologWithArgumentationImpl).b1j = function () {
1097
- return this.y39_1.b1j();
1078
+ return this.x39_1.b1j();
1098
1079
  };
1099
1080
  protoOf(PrologWithArgumentationImpl).mergeWithOccurCheck = function (substitution1, substitution2, occurCheckEnabled) {
1100
- return this.y39_1.mergeWithOccurCheck(substitution1, substitution2, occurCheckEnabled);
1081
+ return this.x39_1.mergeWithOccurCheck(substitution1, substitution2, occurCheckEnabled);
1101
1082
  };
1102
1083
  protoOf(PrologWithArgumentationImpl).merge = function (substitution1, substitution2) {
1103
- return this.y39_1.merge(substitution1, substitution2);
1084
+ return this.x39_1.merge(substitution1, substitution2);
1104
1085
  };
1105
1086
  protoOf(PrologWithArgumentationImpl).convertToClause = function (_this__u8e3s4) {
1106
- return this.y39_1.convertToClause(_this__u8e3s4);
1087
+ return this.x39_1.convertToClause(_this__u8e3s4);
1107
1088
  };
1108
1089
  protoOf(PrologWithArgumentationImpl).theory = function (clauseFunctions) {
1109
- return this.y39_1.theory(clauseFunctions);
1090
+ return this.x39_1.theory(clauseFunctions);
1110
1091
  };
1111
1092
  protoOf(PrologWithArgumentationImpl).theoryOfConcatenatedSequences = function (clauses, otherClauses) {
1112
- return this.y39_1.theoryOfConcatenatedSequences(clauses, otherClauses);
1093
+ return this.x39_1.theoryOfConcatenatedSequences(clauses, otherClauses);
1113
1094
  };
1114
1095
  protoOf(PrologWithArgumentationImpl).theoryOfConcatenatedIterables = function (clauses, otherClauses) {
1115
- return this.y39_1.theoryOfConcatenatedIterables(clauses, otherClauses);
1096
+ return this.x39_1.theoryOfConcatenatedIterables(clauses, otherClauses);
1116
1097
  };
1117
1098
  protoOf(PrologWithArgumentationImpl).theoryOfIterableWithUnificator = function (clauses, unificator) {
1118
- return this.y39_1.theoryOfIterableWithUnificator(clauses, unificator);
1099
+ return this.x39_1.theoryOfIterableWithUnificator(clauses, unificator);
1119
1100
  };
1120
1101
  protoOf(PrologWithArgumentationImpl).theoryOfIterable = function (clauses) {
1121
- return this.y39_1.theoryOfIterable(clauses);
1102
+ return this.x39_1.theoryOfIterable(clauses);
1122
1103
  };
1123
1104
  protoOf(PrologWithArgumentationImpl).theoryOfWithUnificator = function (unificator, clauses) {
1124
- return this.y39_1.theoryOfWithUnificator(unificator, clauses);
1105
+ return this.x39_1.theoryOfWithUnificator(unificator, clauses);
1125
1106
  };
1126
1107
  protoOf(PrologWithArgumentationImpl).theoryOf = function (clauses) {
1127
- return this.y39_1.theoryOf(clauses);
1108
+ return this.x39_1.theoryOf(clauses);
1128
1109
  };
1129
1110
  protoOf(PrologWithArgumentationImpl).theoryOfSequenceWithUnificator = function (clauses, unificator) {
1130
- return this.y39_1.theoryOfSequenceWithUnificator(clauses, unificator);
1111
+ return this.x39_1.theoryOfSequenceWithUnificator(clauses, unificator);
1131
1112
  };
1132
1113
  protoOf(PrologWithArgumentationImpl).theoryOfSequence = function (clauses) {
1133
- return this.y39_1.theoryOfSequence(clauses);
1114
+ return this.x39_1.theoryOfSequence(clauses);
1134
1115
  };
1135
1116
  protoOf(PrologWithArgumentationImpl).mutableTheory = function (clauseFunctions) {
1136
- return this.y39_1.mutableTheory(clauseFunctions);
1117
+ return this.x39_1.mutableTheory(clauseFunctions);
1137
1118
  };
1138
1119
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfConcatenatedSequences = function (clauses, otherClauses) {
1139
- return this.y39_1.mutableTheoryOfConcatenatedSequences(clauses, otherClauses);
1120
+ return this.x39_1.mutableTheoryOfConcatenatedSequences(clauses, otherClauses);
1140
1121
  };
1141
1122
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfConcatenatedIterables = function (clauses, otherClauses) {
1142
- return this.y39_1.mutableTheoryOfConcatenatedIterables(clauses, otherClauses);
1123
+ return this.x39_1.mutableTheoryOfConcatenatedIterables(clauses, otherClauses);
1143
1124
  };
1144
1125
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfIterableWithUnificator = function (clauses, unificator) {
1145
- return this.y39_1.mutableTheoryOfIterableWithUnificator(clauses, unificator);
1126
+ return this.x39_1.mutableTheoryOfIterableWithUnificator(clauses, unificator);
1146
1127
  };
1147
1128
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfIterable = function (clauses) {
1148
- return this.y39_1.mutableTheoryOfIterable(clauses);
1129
+ return this.x39_1.mutableTheoryOfIterable(clauses);
1149
1130
  };
1150
1131
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfWithUnificator = function (unificator, clauses) {
1151
- return this.y39_1.mutableTheoryOfWithUnificator(unificator, clauses);
1132
+ return this.x39_1.mutableTheoryOfWithUnificator(unificator, clauses);
1152
1133
  };
1153
1134
  protoOf(PrologWithArgumentationImpl).mutableTheoryOf = function (clauses) {
1154
- return this.y39_1.mutableTheoryOf(clauses);
1135
+ return this.x39_1.mutableTheoryOf(clauses);
1155
1136
  };
1156
1137
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfSequenceWithUnificator = function (clauses, unificator) {
1157
- return this.y39_1.mutableTheoryOfSequenceWithUnificator(clauses, unificator);
1138
+ return this.x39_1.mutableTheoryOfSequenceWithUnificator(clauses, unificator);
1158
1139
  };
1159
1140
  protoOf(PrologWithArgumentationImpl).mutableTheoryOfSequence = function (clauses) {
1160
- return this.y39_1.mutableTheoryOfSequence(clauses);
1141
+ return this.x39_1.mutableTheoryOfSequence(clauses);
1161
1142
  };
1162
1143
  protoOf(PrologWithArgumentationImpl).emptyTheoryWithUnificator = function (unificator) {
1163
- return this.y39_1.emptyTheoryWithUnificator(unificator);
1144
+ return this.x39_1.emptyTheoryWithUnificator(unificator);
1164
1145
  };
1165
1146
  protoOf(PrologWithArgumentationImpl).emptyTheory = function () {
1166
- return this.y39_1.emptyTheory();
1147
+ return this.x39_1.emptyTheory();
1167
1148
  };
1168
1149
  protoOf(PrologWithArgumentationImpl).emptyMutableTheoryWithUnificator = function (unificator) {
1169
- return this.y39_1.emptyMutableTheoryWithUnificator(unificator);
1150
+ return this.x39_1.emptyMutableTheoryWithUnificator(unificator);
1170
1151
  };
1171
1152
  protoOf(PrologWithArgumentationImpl).emptyMutableTheory = function () {
1172
- return this.y39_1.emptyMutableTheory();
1153
+ return this.x39_1.emptyMutableTheory();
1173
1154
  };
1174
1155
  protoOf(PrologWithArgumentationImpl).m1w = function (unificator, otherLibraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings) {
1175
- return this.y39_1.m1w(unificator, otherLibraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
1156
+ return this.x39_1.m1w(unificator, otherLibraries, flags, staticKb, dynamicKb, stdIn, stdOut, stdErr, warnings);
1176
1157
  };
1177
1158
  protoOf(PrologWithArgumentationImpl).staticKbByArray = function (clauses) {
1178
- this.y39_1.staticKbByArray(clauses);
1159
+ this.x39_1.staticKbByArray(clauses);
1179
1160
  };
1180
1161
  protoOf(PrologWithArgumentationImpl).staticKbByIterable = function (clauses) {
1181
- this.y39_1.staticKbByIterable(clauses);
1162
+ this.x39_1.staticKbByIterable(clauses);
1182
1163
  };
1183
1164
  protoOf(PrologWithArgumentationImpl).staticKbBySequence = function (clauses) {
1184
- this.y39_1.staticKbBySequence(clauses);
1165
+ this.x39_1.staticKbBySequence(clauses);
1185
1166
  };
1186
1167
  protoOf(PrologWithArgumentationImpl).staticKbByTheory = function (theory) {
1187
- this.y39_1.staticKbByTheory(theory);
1168
+ this.x39_1.staticKbByTheory(theory);
1188
1169
  };
1189
1170
  protoOf(PrologWithArgumentationImpl).b1t = function () {
1190
- return this.y39_1.b1t();
1171
+ return this.x39_1.b1t();
1191
1172
  };
1192
1173
  protoOf(PrologWithArgumentationImpl).dynamicKbByArray = function (clauses) {
1193
- this.y39_1.dynamicKbByArray(clauses);
1174
+ this.x39_1.dynamicKbByArray(clauses);
1194
1175
  };
1195
1176
  protoOf(PrologWithArgumentationImpl).dynamicKbByIterable = function (clauses) {
1196
- this.y39_1.dynamicKbByIterable(clauses);
1177
+ this.x39_1.dynamicKbByIterable(clauses);
1197
1178
  };
1198
1179
  protoOf(PrologWithArgumentationImpl).dynamicKbBySequence = function (clauses) {
1199
- this.y39_1.dynamicKbBySequence(clauses);
1180
+ this.x39_1.dynamicKbBySequence(clauses);
1200
1181
  };
1201
1182
  protoOf(PrologWithArgumentationImpl).dynamicKbByTheory = function (theory) {
1202
- this.y39_1.dynamicKbByTheory(theory);
1183
+ this.x39_1.dynamicKbByTheory(theory);
1203
1184
  };
1204
1185
  protoOf(PrologWithArgumentationImpl).c1t = function () {
1205
- return this.y39_1.c1t();
1186
+ return this.x39_1.c1t();
1206
1187
  };
1207
1188
  protoOf(PrologWithArgumentationImpl).r2y = function () {
1208
- return this.y39_1.r2y();
1189
+ return this.x39_1.r2y();
1209
1190
  };
1210
1191
  protoOf(PrologWithArgumentationImpl).s2y = function () {
1211
- return this.y39_1.s2y();
1192
+ return this.x39_1.s2y();
1212
1193
  };
1213
1194
  protoOf(PrologWithArgumentationImpl).loadLibrary = function (library) {
1214
- this.y39_1.loadLibrary(library);
1195
+ this.x39_1.loadLibrary(library);
1215
1196
  };
1216
1197
  protoOf(PrologWithArgumentationImpl).unloadLibrary = function (library) {
1217
- this.y39_1.unloadLibrary(library);
1198
+ this.x39_1.unloadLibrary(library);
1218
1199
  };
1219
1200
  protoOf(PrologWithArgumentationImpl).setLibraries = function (libraries) {
1220
- this.y39_1.setLibraries(libraries);
1201
+ this.x39_1.setLibraries(libraries);
1221
1202
  };
1222
1203
  protoOf(PrologWithArgumentationImpl).loadStaticKb = function (theory) {
1223
- this.y39_1.loadStaticKb(theory);
1204
+ this.x39_1.loadStaticKb(theory);
1224
1205
  };
1225
1206
  protoOf(PrologWithArgumentationImpl).loadStaticClauses = function (clauses) {
1226
- this.y39_1.loadStaticClauses(clauses);
1207
+ this.x39_1.loadStaticClauses(clauses);
1227
1208
  };
1228
1209
  protoOf(PrologWithArgumentationImpl).loadStaticClausesIterable = function (clauses) {
1229
- this.y39_1.loadStaticClausesIterable(clauses);
1210
+ this.x39_1.loadStaticClausesIterable(clauses);
1230
1211
  };
1231
1212
  protoOf(PrologWithArgumentationImpl).loadStaticClausesSequence = function (clauses) {
1232
- this.y39_1.loadStaticClausesSequence(clauses);
1213
+ this.x39_1.loadStaticClausesSequence(clauses);
1233
1214
  };
1234
1215
  protoOf(PrologWithArgumentationImpl).appendStaticKb = function (theory) {
1235
- this.y39_1.appendStaticKb(theory);
1216
+ this.x39_1.appendStaticKb(theory);
1236
1217
  };
1237
1218
  protoOf(PrologWithArgumentationImpl).resetStaticKb = function () {
1238
- this.y39_1.resetStaticKb();
1219
+ this.x39_1.resetStaticKb();
1239
1220
  };
1240
1221
  protoOf(PrologWithArgumentationImpl).loadDynamicKb = function (theory) {
1241
- this.y39_1.loadDynamicKb(theory);
1222
+ this.x39_1.loadDynamicKb(theory);
1242
1223
  };
1243
1224
  protoOf(PrologWithArgumentationImpl).loadDynamicClauses = function (clauses) {
1244
- this.y39_1.loadDynamicClauses(clauses);
1225
+ this.x39_1.loadDynamicClauses(clauses);
1245
1226
  };
1246
1227
  protoOf(PrologWithArgumentationImpl).loadDynamicClausesIterable = function (clauses) {
1247
- this.y39_1.loadDynamicClausesIterable(clauses);
1228
+ this.x39_1.loadDynamicClausesIterable(clauses);
1248
1229
  };
1249
1230
  protoOf(PrologWithArgumentationImpl).loadDynamicClausesSequence = function (clauses) {
1250
- this.y39_1.loadDynamicClausesSequence(clauses);
1231
+ this.x39_1.loadDynamicClausesSequence(clauses);
1251
1232
  };
1252
1233
  protoOf(PrologWithArgumentationImpl).appendDynamicKb = function (theory) {
1253
- this.y39_1.appendDynamicKb(theory);
1234
+ this.x39_1.appendDynamicKb(theory);
1254
1235
  };
1255
1236
  protoOf(PrologWithArgumentationImpl).resetDynamicKb = function () {
1256
- this.y39_1.resetDynamicKb();
1237
+ this.x39_1.resetDynamicKb();
1257
1238
  };
1258
1239
  protoOf(PrologWithArgumentationImpl).assertA = function (clause) {
1259
- this.y39_1.assertA(clause);
1240
+ this.x39_1.assertA(clause);
1260
1241
  };
1261
1242
  protoOf(PrologWithArgumentationImpl).assertAFact = function (fact) {
1262
- this.y39_1.assertAFact(fact);
1243
+ this.x39_1.assertAFact(fact);
1263
1244
  };
1264
1245
  protoOf(PrologWithArgumentationImpl).assertZ = function (clause) {
1265
- this.y39_1.assertZ(clause);
1246
+ this.x39_1.assertZ(clause);
1266
1247
  };
1267
1248
  protoOf(PrologWithArgumentationImpl).assertZFact = function (fact) {
1268
- this.y39_1.assertZFact(fact);
1249
+ this.x39_1.assertZFact(fact);
1269
1250
  };
1270
1251
  protoOf(PrologWithArgumentationImpl).retractAll = function (clause) {
1271
- return this.y39_1.retractAll(clause);
1252
+ return this.x39_1.retractAll(clause);
1272
1253
  };
1273
1254
  protoOf(PrologWithArgumentationImpl).retractAllBeHead = function (fact) {
1274
- return this.y39_1.retractAllBeHead(fact);
1255
+ return this.x39_1.retractAllBeHead(fact);
1275
1256
  };
1276
1257
  protoOf(PrologWithArgumentationImpl).setFlag = function (name, value) {
1277
- this.y39_1.setFlag(name, value);
1258
+ this.x39_1.setFlag(name, value);
1278
1259
  };
1279
1260
  protoOf(PrologWithArgumentationImpl).setFlagPair = function (flag) {
1280
- this.y39_1.setFlagPair(flag);
1261
+ this.x39_1.setFlagPair(flag);
1281
1262
  };
1282
1263
  protoOf(PrologWithArgumentationImpl).setFlagNotable = function (flag) {
1283
- this.y39_1.setFlagNotable(flag);
1264
+ this.x39_1.setFlagNotable(flag);
1284
1265
  };
1285
1266
  protoOf(PrologWithArgumentationImpl).setStandardInput = function (stdIn) {
1286
- this.y39_1.setStandardInput(stdIn);
1267
+ this.x39_1.setStandardInput(stdIn);
1287
1268
  };
1288
1269
  protoOf(PrologWithArgumentationImpl).setStandardError = function (stdErr) {
1289
- this.y39_1.setStandardError(stdErr);
1270
+ this.x39_1.setStandardError(stdErr);
1290
1271
  };
1291
1272
  protoOf(PrologWithArgumentationImpl).setStandardOutput = function (stdOut) {
1292
- this.y39_1.setStandardOutput(stdOut);
1273
+ this.x39_1.setStandardOutput(stdOut);
1293
1274
  };
1294
1275
  protoOf(PrologWithArgumentationImpl).setWarnings = function (warnings) {
1295
- this.y39_1.setWarnings(warnings);
1276
+ this.x39_1.setWarnings(warnings);
1296
1277
  };
1297
1278
  protoOf(PrologWithArgumentationImpl).q1q = function () {
1298
- return this.y39_1.q1q();
1279
+ return this.x39_1.q1q();
1299
1280
  };
1300
1281
  protoOf(PrologWithArgumentationImpl).clone = function () {
1301
1282
  return this.q1q();
1302
1283
  };
1303
1284
  protoOf(PrologWithArgumentationImpl).solveListWithTimeout = function (goal, timeout) {
1304
- return this.y39_1.solveListWithTimeout(goal, timeout);
1285
+ return this.x39_1.solveListWithTimeout(goal, timeout);
1305
1286
  };
1306
1287
  protoOf(PrologWithArgumentationImpl).solveList = function (goal) {
1307
- return this.y39_1.solveList(goal);
1288
+ return this.x39_1.solveList(goal);
1308
1289
  };
1309
1290
  protoOf(PrologWithArgumentationImpl).solveListWithOptions = function (goal, options) {
1310
- return this.y39_1.solveListWithOptions(goal, options);
1291
+ return this.x39_1.solveListWithOptions(goal, options);
1311
1292
  };
1312
1293
  protoOf(PrologWithArgumentationImpl).solveOnceWithTimeout = function (goal, timeout) {
1313
- return this.y39_1.solveOnceWithTimeout(goal, timeout);
1294
+ return this.x39_1.solveOnceWithTimeout(goal, timeout);
1314
1295
  };
1315
1296
  protoOf(PrologWithArgumentationImpl).solveOnce = function (goal) {
1316
- return this.y39_1.solveOnce(goal);
1297
+ return this.x39_1.solveOnce(goal);
1317
1298
  };
1318
1299
  protoOf(PrologWithArgumentationImpl).solveOnceWithOptions = function (goal, options) {
1319
- return this.y39_1.solveOnceWithOptions(goal, options);
1300
+ return this.x39_1.solveOnceWithOptions(goal, options);
1320
1301
  };
1321
1302
  protoOf(PrologWithArgumentationImpl).z1s = function () {
1322
- return this.y39_1.z1s();
1303
+ return this.x39_1.z1s();
1323
1304
  };
1324
1305
  protoOf(PrologWithArgumentationImpl).a1t = function () {
1325
- return this.y39_1.a1t();
1306
+ return this.x39_1.a1t();
1326
1307
  };
1327
1308
  protoOf(PrologWithArgumentationImpl).i1t = function () {
1328
- return this.y39_1.i1t();
1309
+ return this.x39_1.i1t();
1329
1310
  };
1330
1311
  protoOf(PrologWithArgumentationImpl).d1t = function () {
1331
- return this.y39_1.d1t();
1312
+ return this.x39_1.d1t();
1332
1313
  };
1333
1314
  protoOf(PrologWithArgumentationImpl).e1t = function () {
1334
- return this.y39_1.e1t();
1315
+ return this.x39_1.e1t();
1335
1316
  };
1336
1317
  protoOf(PrologWithArgumentationImpl).j1t = function () {
1337
- return this.y39_1.j1t();
1318
+ return this.x39_1.j1t();
1338
1319
  };
1339
1320
  protoOf(PrologWithArgumentationImpl).k1t = function () {
1340
- return this.y39_1.k1t();
1321
+ return this.x39_1.k1t();
1341
1322
  };
1342
1323
  protoOf(PrologWithArgumentationImpl).l1t = function () {
1343
- return this.y39_1.l1t();
1324
+ return this.x39_1.l1t();
1344
1325
  };
1345
1326
  protoOf(PrologWithArgumentationImpl).m1t = function () {
1346
- return this.y39_1.m1t();
1327
+ return this.x39_1.m1t();
1347
1328
  };
1348
1329
  function ArgLibrary() {
1349
1330
  }
@@ -1351,20 +1332,20 @@
1351
1332
  }
1352
1333
  function LazyRawPrologContent$prologTheory$delegate$lambda(this$0) {
1353
1334
  return function () {
1354
- return parseTheoryWithOperators(Companion_instance_0, this$0.c3a(), this$0.i39());
1335
+ return parseTheoryWithOperators(Companion_instance_0, this$0.b3a(), this$0.i39());
1355
1336
  };
1356
1337
  }
1357
1338
  function LazyRawPrologContent$_get_prologTheory_$ref_uti0i4() {
1358
1339
  return function (p0) {
1359
- return p0.d3a();
1340
+ return p0.c3a();
1360
1341
  };
1361
1342
  }
1362
1343
  function LazyRawPrologContent() {
1363
1344
  var tmp = this;
1364
- tmp.b3a_1 = lazy(LazyRawPrologContent$prologTheory$delegate$lambda(this));
1345
+ tmp.a3a_1 = lazy(LazyRawPrologContent$prologTheory$delegate$lambda(this));
1365
1346
  }
1366
- protoOf(LazyRawPrologContent).d3a = function () {
1367
- var tmp0 = this.b3a_1;
1347
+ protoOf(LazyRawPrologContent).c3a = function () {
1348
+ var tmp0 = this.a3a_1;
1368
1349
  var tmp = KProperty1;
1369
1350
  // Inline function 'kotlin.getValue' call
1370
1351
  getPropertyCallableRef('prologTheory', 1, tmp, LazyRawPrologContent$_get_prologTheory_$ref_uti0i4(), null);
@@ -1376,9 +1357,9 @@
1376
1357
  };
1377
1358
  }
1378
1359
  function Cache$CacheGet$solve$slambda(this$0, $term, $request, resultContinuation) {
1379
- this.m3a_1 = this$0;
1380
- this.n3a_1 = $term;
1381
- this.o3a_1 = $request;
1360
+ this.l3a_1 = this$0;
1361
+ this.m3a_1 = $term;
1362
+ this.n3a_1 = $request;
1382
1363
  CoroutineImpl.call(this, resultContinuation);
1383
1364
  }
1384
1365
  protoOf(Cache$CacheGet$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1399,8 +1380,8 @@
1399
1380
  case 0:
1400
1381
  this.c8_1 = 2;
1401
1382
  this.b8_1 = 1;
1402
- var tmp_0 = this.m3a_1.q3a_1.solve(this.n3a_1.castToStruct());
1403
- suspendResult = this.p3a_1.sc(map(tmp_0, Cache$CacheGet$solve$slambda$lambda(this.o3a_1)), this);
1383
+ var tmp_0 = this.l3a_1.p3a_1.solve(this.m3a_1.castToStruct());
1384
+ suspendResult = this.o3a_1.sc(map(tmp_0, Cache$CacheGet$solve$slambda$lambda(this.n3a_1)), this);
1404
1385
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
1405
1386
  return suspendResult;
1406
1387
  }
@@ -1423,8 +1404,8 @@
1423
1404
  while (true);
1424
1405
  };
1425
1406
  protoOf(Cache$CacheGet$solve$slambda).d2o = function ($this$sequence, completion) {
1426
- var i = new Cache$CacheGet$solve$slambda(this.m3a_1, this.n3a_1, this.o3a_1, completion);
1427
- i.p3a_1 = $this$sequence;
1407
+ var i = new Cache$CacheGet$solve$slambda(this.l3a_1, this.m3a_1, this.n3a_1, completion);
1408
+ i.o3a_1 = $this$sequence;
1428
1409
  return i;
1429
1410
  };
1430
1411
  function Cache$CacheGet$solve$slambda_0(this$0, $term, $request, resultContinuation) {
@@ -1436,45 +1417,45 @@
1436
1417
  return l;
1437
1418
  }
1438
1419
  function CacheAssert($outer) {
1439
- this.t3a_1 = $outer;
1440
- this.s3a_1 = new Signature('cache_assert', 1);
1420
+ this.s3a_1 = $outer;
1421
+ this.r3a_1 = new Signature('cache_assert', 1);
1441
1422
  }
1442
1423
  protoOf(CacheAssert).m1s = function () {
1443
- return this.s3a_1;
1424
+ return this.r3a_1;
1444
1425
  };
1445
1426
  protoOf(CacheAssert).g2e = function (request) {
1446
1427
  var term = request.arguments.w(0);
1447
- this.t3a_1.q3a_1.assertAFact(term.castToStruct());
1428
+ this.s3a_1.p3a_1.assertAFact(term.castToStruct());
1448
1429
  return sequenceOf(request.replyWithCondition(true, VOID, []));
1449
1430
  };
1450
1431
  protoOf(CacheAssert).solve = function (request) {
1451
1432
  return this.g2e(request);
1452
1433
  };
1453
1434
  function CacheRetract($outer) {
1454
- this.v3a_1 = $outer;
1455
- this.u3a_1 = new Signature('cache_retract', 1);
1435
+ this.u3a_1 = $outer;
1436
+ this.t3a_1 = new Signature('cache_retract', 1);
1456
1437
  }
1457
1438
  protoOf(CacheRetract).m1s = function () {
1458
- return this.u3a_1;
1439
+ return this.t3a_1;
1459
1440
  };
1460
1441
  protoOf(CacheRetract).g2e = function (request) {
1461
1442
  var term = request.arguments.w(0);
1462
- this.v3a_1.q3a_1.retractAllBeHead(term.castToStruct());
1443
+ this.u3a_1.p3a_1.retractAllBeHead(term.castToStruct());
1463
1444
  return sequenceOf(request.replyWithCondition(true, VOID, []));
1464
1445
  };
1465
1446
  protoOf(CacheRetract).solve = function (request) {
1466
1447
  return this.g2e(request);
1467
1448
  };
1468
1449
  function CacheGet($outer) {
1469
- this.x3a_1 = $outer;
1470
- this.w3a_1 = new Signature('cache_check', 1);
1450
+ this.w3a_1 = $outer;
1451
+ this.v3a_1 = new Signature('cache_check', 1);
1471
1452
  }
1472
1453
  protoOf(CacheGet).m1s = function () {
1473
- return this.w3a_1;
1454
+ return this.v3a_1;
1474
1455
  };
1475
1456
  protoOf(CacheGet).g2e = function (request) {
1476
1457
  var term = request.arguments.w(0);
1477
- return sequence(Cache$CacheGet$solve$slambda_0(this.x3a_1, term, request, null));
1458
+ return sequence(Cache$CacheGet$solve$slambda_0(this.w3a_1, term, request, null));
1478
1459
  };
1479
1460
  protoOf(CacheGet).solve = function (request) {
1480
1461
  return this.g2e(request);
@@ -1482,18 +1463,18 @@
1482
1463
  function Cache() {
1483
1464
  var tmp = this;
1484
1465
  // Inline function 'kotlin.also' call
1485
- var this_0 = ClassicSolverFactory_instance.rawMutableSolverOf(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_2().u1i()));
1466
+ var this_0 = ClassicSolverFactory_instance.rawMutableSolverOf(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_1().u1i()));
1486
1467
  this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
1487
- tmp.q3a_1 = this_0;
1488
- this.r3a_1 = 'prolog.argumentation.cache';
1468
+ tmp.p3a_1 = this_0;
1469
+ this.q3a_1 = 'prolog.argumentation.cache';
1489
1470
  }
1490
1471
  protoOf(Cache).y2b = function () {
1491
- return this.r3a_1;
1472
+ return this.q3a_1;
1492
1473
  };
1493
- protoOf(Cache).z39 = function () {
1474
+ protoOf(Cache).y39 = function () {
1494
1475
  // Inline function 'kotlin.let' call
1495
1476
  var primitives = listOf([new CacheAssert(this), new CacheRetract(this), new CacheGet(this)]);
1496
- var tmp = Companion_getInstance_3();
1477
+ var tmp = Companion_getInstance_2();
1497
1478
  // Inline function 'kotlin.collections.associateBy' call
1498
1479
  var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(primitives, 10)), 16);
1499
1480
  // Inline function 'kotlin.collections.associateByTo' call
@@ -1504,16 +1485,16 @@
1504
1485
  var tmp$ret$0 = element.m1s();
1505
1486
  destination.k4(tmp$ret$0, element);
1506
1487
  }
1507
- return tmp.of(this.r3a_1, destination);
1488
+ return tmp.of(this.q3a_1, destination);
1508
1489
  };
1509
1490
  function Context$DynamicCacheAssert$solve$lambda(this$0, $term) {
1510
1491
  return function ($this$arg2pScope) {
1511
- return ensureNotNull(this$0.a3b_1.h2(this$0.z3a_1)).solve($this$arg2pScope.stringInvoke('asserta', $term, []));
1492
+ return ensureNotNull(this$0.z3a_1.h2(this$0.y3a_1)).solve($this$arg2pScope.stringInvoke('asserta', $term, []));
1512
1493
  };
1513
1494
  }
1514
1495
  function Context$DynamicCacheRetract$solve$lambda(this$0, $term) {
1515
1496
  return function ($this$arg2pScope) {
1516
- return ensureNotNull(this$0.a3b_1.h2(this$0.z3a_1)).solve($this$arg2pScope.stringInvoke('retractall', $term, []));
1497
+ return ensureNotNull(this$0.z3a_1.h2(this$0.y3a_1)).solve($this$arg2pScope.stringInvoke('retractall', $term, []));
1517
1498
  };
1518
1499
  }
1519
1500
  function Context$DynamicCacheGet$solve$slambda$lambda($request) {
@@ -1522,9 +1503,9 @@
1522
1503
  };
1523
1504
  }
1524
1505
  function Context$DynamicCacheGet$solve$slambda(this$0, $term, $request, resultContinuation) {
1525
- this.k3b_1 = this$0;
1526
- this.l3b_1 = $term;
1527
- this.m3b_1 = $request;
1506
+ this.j3b_1 = this$0;
1507
+ this.k3b_1 = $term;
1508
+ this.l3b_1 = $request;
1528
1509
  CoroutineImpl.call(this, resultContinuation);
1529
1510
  }
1530
1511
  protoOf(Context$DynamicCacheGet$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1545,8 +1526,8 @@
1545
1526
  case 0:
1546
1527
  this.c8_1 = 2;
1547
1528
  this.b8_1 = 1;
1548
- var tmp_0 = ensureNotNull(this.k3b_1.a3b_1.h2(this.k3b_1.z3a_1)).solve(this.l3b_1.castToStruct());
1549
- suspendResult = this.n3b_1.sc(map(tmp_0, Context$DynamicCacheGet$solve$slambda$lambda(this.m3b_1)), this);
1529
+ var tmp_0 = ensureNotNull(this.j3b_1.z3a_1.h2(this.j3b_1.y3a_1)).solve(this.k3b_1.castToStruct());
1530
+ suspendResult = this.m3b_1.sc(map(tmp_0, Context$DynamicCacheGet$solve$slambda$lambda(this.l3b_1)), this);
1550
1531
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
1551
1532
  return suspendResult;
1552
1533
  }
@@ -1569,8 +1550,8 @@
1569
1550
  while (true);
1570
1551
  };
1571
1552
  protoOf(Context$DynamicCacheGet$solve$slambda).d2o = function ($this$sequence, completion) {
1572
- var i = new Context$DynamicCacheGet$solve$slambda(this.k3b_1, this.l3b_1, this.m3b_1, completion);
1573
- i.n3b_1 = $this$sequence;
1553
+ var i = new Context$DynamicCacheGet$solve$slambda(this.j3b_1, this.k3b_1, this.l3b_1, completion);
1554
+ i.m3b_1 = $this$sequence;
1574
1555
  return i;
1575
1556
  };
1576
1557
  function Context$DynamicCacheGet$solve$slambda_0(this$0, $term, $request, resultContinuation) {
@@ -1587,10 +1568,10 @@
1587
1568
  };
1588
1569
  }
1589
1570
  function Context$DynamicCacheGetIndexed$solve$slambda(this$0, $index, $term, $request, resultContinuation) {
1590
- this.w3b_1 = this$0;
1591
- this.x3b_1 = $index;
1592
- this.y3b_1 = $term;
1593
- this.z3b_1 = $request;
1571
+ this.v3b_1 = this$0;
1572
+ this.w3b_1 = $index;
1573
+ this.x3b_1 = $term;
1574
+ this.y3b_1 = $request;
1594
1575
  CoroutineImpl.call(this, resultContinuation);
1595
1576
  }
1596
1577
  protoOf(Context$DynamicCacheGetIndexed$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1611,8 +1592,8 @@
1611
1592
  case 0:
1612
1593
  this.c8_1 = 2;
1613
1594
  this.b8_1 = 1;
1614
- var tmp_0 = ensureNotNull(this.w3b_1.a3b_1.h2(this.x3b_1)).solve(this.y3b_1.castToStruct());
1615
- suspendResult = this.a3c_1.sc(map(tmp_0, Context$DynamicCacheGetIndexed$solve$slambda$lambda(this.z3b_1)), this);
1595
+ var tmp_0 = ensureNotNull(this.v3b_1.z3a_1.h2(this.w3b_1)).solve(this.x3b_1.castToStruct());
1596
+ suspendResult = this.z3b_1.sc(map(tmp_0, Context$DynamicCacheGetIndexed$solve$slambda$lambda(this.y3b_1)), this);
1616
1597
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
1617
1598
  return suspendResult;
1618
1599
  }
@@ -1635,8 +1616,8 @@
1635
1616
  while (true);
1636
1617
  };
1637
1618
  protoOf(Context$DynamicCacheGetIndexed$solve$slambda).d2o = function ($this$sequence, completion) {
1638
- var i = new Context$DynamicCacheGetIndexed$solve$slambda(this.w3b_1, this.x3b_1, this.y3b_1, this.z3b_1, completion);
1639
- i.a3c_1 = $this$sequence;
1619
+ var i = new Context$DynamicCacheGetIndexed$solve$slambda(this.v3b_1, this.w3b_1, this.x3b_1, this.y3b_1, completion);
1620
+ i.z3b_1 = $this$sequence;
1640
1621
  return i;
1641
1622
  };
1642
1623
  function Context$DynamicCacheGetIndexed$solve$slambda_0(this$0, $index, $term, $request, resultContinuation) {
@@ -1648,19 +1629,19 @@
1648
1629
  return l;
1649
1630
  }
1650
1631
  function DynamicCacheReset($outer) {
1651
- this.c3c_1 = $outer;
1652
- this.b3c_1 = new Signature('context_reset', 0);
1632
+ this.b3c_1 = $outer;
1633
+ this.a3c_1 = new Signature('context_reset', 0);
1653
1634
  }
1654
1635
  protoOf(DynamicCacheReset).m1s = function () {
1655
- return this.b3c_1;
1636
+ return this.a3c_1;
1656
1637
  };
1657
1638
  protoOf(DynamicCacheReset).g2e = function (request) {
1658
- this.c3c_1.z3a_1 = 0;
1659
- this.c3c_1.y3a_1 = 1;
1660
- this.c3c_1.a3b_1.d3();
1661
- var tmp0 = this.c3c_1.a3b_1;
1639
+ this.b3c_1.y3a_1 = 0;
1640
+ this.b3c_1.x3a_1 = 1;
1641
+ this.b3c_1.z3a_1.d3();
1642
+ var tmp0 = this.b3c_1.z3a_1;
1662
1643
  // Inline function 'kotlin.also' call
1663
- var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_2().u1i()));
1644
+ var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_1().u1i()));
1664
1645
  this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
1665
1646
  // Inline function 'kotlin.collections.set' call
1666
1647
  tmp0.k4(0, this_0);
@@ -1670,137 +1651,137 @@
1670
1651
  return this.g2e(request);
1671
1652
  };
1672
1653
  function DynamicCacheSelected($outer) {
1673
- this.e3c_1 = $outer;
1674
- this.d3c_1 = new Signature('context_active', 1);
1654
+ this.d3c_1 = $outer;
1655
+ this.c3c_1 = new Signature('context_active', 1);
1675
1656
  }
1676
1657
  protoOf(DynamicCacheSelected).m1s = function () {
1677
- return this.d3c_1;
1658
+ return this.c3c_1;
1678
1659
  };
1679
1660
  protoOf(DynamicCacheSelected).g2e = function (request) {
1680
1661
  var term = request.arguments.w(0);
1681
- return sequenceOf(request.replyWith(Companion_getInstance_4().of(term.castToVar(), Companion_getInstance_5().ofInteger(this.e3c_1.z3a_1)), VOID, []));
1662
+ return sequenceOf(request.replyWith(Companion_getInstance_3().of(term.castToVar(), Companion_getInstance_4().ofInteger(this.d3c_1.y3a_1)), VOID, []));
1682
1663
  };
1683
1664
  protoOf(DynamicCacheSelected).solve = function (request) {
1684
1665
  return this.g2e(request);
1685
1666
  };
1686
1667
  function DynamicCacheCheckout($outer) {
1687
- this.g3c_1 = $outer;
1688
- this.f3c_1 = new Signature('context_checkout', 1);
1668
+ this.f3c_1 = $outer;
1669
+ this.e3c_1 = new Signature('context_checkout', 1);
1689
1670
  }
1690
1671
  protoOf(DynamicCacheCheckout).m1s = function () {
1691
- return this.f3c_1;
1672
+ return this.e3c_1;
1692
1673
  };
1693
1674
  protoOf(DynamicCacheCheckout).g2e = function (request) {
1694
1675
  var target = request.arguments.w(0).castToInteger().py().toInt();
1695
- var result = this.g3c_1.a3b_1.i2().u(target);
1696
- this.g3c_1.z3a_1 = target;
1676
+ var result = this.f3c_1.z3a_1.i2().u(target);
1677
+ this.f3c_1.y3a_1 = target;
1697
1678
  return sequenceOf(request.replyWithCondition(result, VOID, []));
1698
1679
  };
1699
1680
  protoOf(DynamicCacheCheckout).solve = function (request) {
1700
1681
  return this.g2e(request);
1701
1682
  };
1702
1683
  function DynamicCacheBranch($outer) {
1703
- this.i3c_1 = $outer;
1704
- this.h3c_1 = new Signature('context_branch', 2);
1684
+ this.h3c_1 = $outer;
1685
+ this.g3c_1 = new Signature('context_branch', 2);
1705
1686
  }
1706
1687
  protoOf(DynamicCacheBranch).m1s = function () {
1707
- return this.h3c_1;
1688
+ return this.g3c_1;
1708
1689
  };
1709
1690
  protoOf(DynamicCacheBranch).g2e = function (request) {
1710
1691
  var target = request.arguments.w(0).castToInteger().py().toInt();
1711
1692
  var result = request.arguments.w(1);
1712
- var tmp0 = this.i3c_1.a3b_1;
1713
- var tmp2 = this.i3c_1.y3a_1;
1693
+ var tmp0 = this.h3c_1.z3a_1;
1694
+ var tmp2 = this.h3c_1.x3a_1;
1714
1695
  // Inline function 'kotlin.also' call
1715
- var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.ofIterable(Companion_getInstance_2().u1i(), ensureNotNull(this.i3c_1.a3b_1.h2(target)).c1t()));
1696
+ var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.ofIterable(Companion_getInstance_1().u1i(), ensureNotNull(this.h3c_1.z3a_1.h2(target)).c1t()));
1716
1697
  this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
1717
1698
  // Inline function 'kotlin.collections.set' call
1718
1699
  tmp0.k4(tmp2, this_0);
1719
- var tmp = this.i3c_1;
1720
- var _unary__edvuaz = this.i3c_1.y3a_1;
1721
- this.i3c_1.y3a_1 = _unary__edvuaz + 1 | 0;
1722
- tmp.z3a_1 = _unary__edvuaz;
1723
- return sequenceOf(request.replyWith(Companion_getInstance_4().of(result.castToVar(), Companion_getInstance_5().ofInteger(this.i3c_1.z3a_1)), VOID, []));
1700
+ var tmp = this.h3c_1;
1701
+ var _unary__edvuaz = this.h3c_1.x3a_1;
1702
+ this.h3c_1.x3a_1 = _unary__edvuaz + 1 | 0;
1703
+ tmp.y3a_1 = _unary__edvuaz;
1704
+ return sequenceOf(request.replyWith(Companion_getInstance_3().of(result.castToVar(), Companion_getInstance_4().ofInteger(this.h3c_1.y3a_1)), VOID, []));
1724
1705
  };
1725
1706
  protoOf(DynamicCacheBranch).solve = function (request) {
1726
1707
  return this.g2e(request);
1727
1708
  };
1728
1709
  function DynamicCacheAssert($outer) {
1729
- this.k3c_1 = $outer;
1730
- this.j3c_1 = new Signature('context_assert', 1);
1710
+ this.j3c_1 = $outer;
1711
+ this.i3c_1 = new Signature('context_assert', 1);
1731
1712
  }
1732
1713
  protoOf(DynamicCacheAssert).m1s = function () {
1733
- return this.j3c_1;
1714
+ return this.i3c_1;
1734
1715
  };
1735
1716
  protoOf(DynamicCacheAssert).g2e = function (request) {
1736
1717
  var term = request.arguments.w(0);
1737
- first(arg2pScope(Context$DynamicCacheAssert$solve$lambda(this.k3c_1, term)));
1718
+ first(arg2pScope(Context$DynamicCacheAssert$solve$lambda(this.j3c_1, term)));
1738
1719
  return sequenceOf(request.replyWithCondition(true, VOID, []));
1739
1720
  };
1740
1721
  protoOf(DynamicCacheAssert).solve = function (request) {
1741
1722
  return this.g2e(request);
1742
1723
  };
1743
1724
  function DynamicCacheRetract($outer) {
1744
- this.m3c_1 = $outer;
1745
- this.l3c_1 = new Signature('context_retract', 1);
1725
+ this.l3c_1 = $outer;
1726
+ this.k3c_1 = new Signature('context_retract', 1);
1746
1727
  }
1747
1728
  protoOf(DynamicCacheRetract).m1s = function () {
1748
- return this.l3c_1;
1729
+ return this.k3c_1;
1749
1730
  };
1750
1731
  protoOf(DynamicCacheRetract).g2e = function (request) {
1751
1732
  var term = request.arguments.w(0);
1752
- first(arg2pScope(Context$DynamicCacheRetract$solve$lambda(this.m3c_1, term)));
1733
+ first(arg2pScope(Context$DynamicCacheRetract$solve$lambda(this.l3c_1, term)));
1753
1734
  return sequenceOf(request.replyWithCondition(true, VOID, []));
1754
1735
  };
1755
1736
  protoOf(DynamicCacheRetract).solve = function (request) {
1756
1737
  return this.g2e(request);
1757
1738
  };
1758
1739
  function DynamicCacheGet($outer) {
1759
- this.o3c_1 = $outer;
1760
- this.n3c_1 = new Signature('context_check', 1);
1740
+ this.n3c_1 = $outer;
1741
+ this.m3c_1 = new Signature('context_check', 1);
1761
1742
  }
1762
1743
  protoOf(DynamicCacheGet).m1s = function () {
1763
- return this.n3c_1;
1744
+ return this.m3c_1;
1764
1745
  };
1765
1746
  protoOf(DynamicCacheGet).g2e = function (request) {
1766
1747
  var term = request.arguments.w(0);
1767
- return sequence(Context$DynamicCacheGet$solve$slambda_0(this.o3c_1, term, request, null));
1748
+ return sequence(Context$DynamicCacheGet$solve$slambda_0(this.n3c_1, term, request, null));
1768
1749
  };
1769
1750
  protoOf(DynamicCacheGet).solve = function (request) {
1770
1751
  return this.g2e(request);
1771
1752
  };
1772
1753
  function DynamicCacheGetIndexed($outer) {
1773
- this.q3c_1 = $outer;
1774
- this.p3c_1 = new Signature('context_check', 2);
1754
+ this.p3c_1 = $outer;
1755
+ this.o3c_1 = new Signature('context_check', 2);
1775
1756
  }
1776
1757
  protoOf(DynamicCacheGetIndexed).m1s = function () {
1777
- return this.p3c_1;
1758
+ return this.o3c_1;
1778
1759
  };
1779
1760
  protoOf(DynamicCacheGetIndexed).g2e = function (request) {
1780
1761
  var index = ensureNotNull(request.arguments.w(0).asNumeric()).py().toInt();
1781
1762
  var term = request.arguments.w(1);
1782
- return sequence(Context$DynamicCacheGetIndexed$solve$slambda_0(this.q3c_1, index, term, request, null));
1763
+ return sequence(Context$DynamicCacheGetIndexed$solve$slambda_0(this.p3c_1, index, term, request, null));
1783
1764
  };
1784
1765
  protoOf(DynamicCacheGetIndexed).solve = function (request) {
1785
1766
  return this.g2e(request);
1786
1767
  };
1787
1768
  function Context() {
1788
- this.y3a_1 = 1;
1789
- this.z3a_1 = 0;
1769
+ this.x3a_1 = 1;
1770
+ this.y3a_1 = 0;
1790
1771
  var tmp = this;
1791
1772
  // Inline function 'kotlin.also' call
1792
- var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_2().u1i()));
1773
+ var this_0 = ClassicSolverFactory_instance.mutableSolverWithDefaultBuiltinsAnd(VOID, VOID, VOID, Companion_instance_0.emptyWithDefaultUnificator(), Companion_instance_2.empty(Companion_getInstance_1().u1i()));
1793
1774
  this_0.setFlag(Unknown_getInstance().g27_1, Unknown_getInstance().f27_1);
1794
- tmp.a3b_1 = mutableMapOf([to(0, this_0)]);
1795
- this.b3b_1 = 'prolog.argumentation.context';
1775
+ tmp.z3a_1 = mutableMapOf([to(0, this_0)]);
1776
+ this.a3b_1 = 'prolog.argumentation.context';
1796
1777
  }
1797
1778
  protoOf(Context).y2b = function () {
1798
- return this.b3b_1;
1779
+ return this.a3b_1;
1799
1780
  };
1800
- protoOf(Context).z39 = function () {
1781
+ protoOf(Context).y39 = function () {
1801
1782
  // Inline function 'kotlin.let' call
1802
1783
  var primitives = listOf([new DynamicCacheReset(this), new DynamicCacheCheckout(this), new DynamicCacheSelected(this), new DynamicCacheBranch(this), new DynamicCacheAssert(this), new DynamicCacheRetract(this), new DynamicCacheGet(this), new DynamicCacheGetIndexed(this)]);
1803
- var tmp = Companion_getInstance_3();
1784
+ var tmp = Companion_getInstance_2();
1804
1785
  // Inline function 'kotlin.collections.associateBy' call
1805
1786
  var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(primitives, 10)), 16);
1806
1787
  // Inline function 'kotlin.collections.associateByTo' call
@@ -1811,7 +1792,7 @@
1811
1792
  var tmp$ret$0 = element.m1s();
1812
1793
  destination.k4(tmp$ret$0, element);
1813
1794
  }
1814
- return tmp.of(this.b3b_1, destination);
1795
+ return tmp.of(this.a3b_1, destination);
1815
1796
  };
1816
1797
  function DynamicLoader$AbstractWithLib$solve$slambda$lambda($request) {
1817
1798
  return function (it) {
@@ -1819,9 +1800,9 @@
1819
1800
  };
1820
1801
  }
1821
1802
  function DynamicLoader$AbstractWithLib$solve$slambda($solver, $goal, $request, resultContinuation) {
1822
- this.z3c_1 = $solver;
1823
- this.a3d_1 = $goal;
1824
- this.b3d_1 = $request;
1803
+ this.y3c_1 = $solver;
1804
+ this.z3c_1 = $goal;
1805
+ this.a3d_1 = $request;
1825
1806
  CoroutineImpl.call(this, resultContinuation);
1826
1807
  }
1827
1808
  protoOf(DynamicLoader$AbstractWithLib$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -1842,8 +1823,8 @@
1842
1823
  case 0:
1843
1824
  this.c8_1 = 2;
1844
1825
  this.b8_1 = 1;
1845
- var tmp_0 = this.z3c_1.solveWithOptions(this.a3d_1, Companion_getInstance_6().allLazilyWithTimeout(9223372036854775807n));
1846
- suspendResult = this.c3d_1.sc(map(tmp_0, DynamicLoader$AbstractWithLib$solve$slambda$lambda(this.b3d_1)), this);
1826
+ var tmp_0 = this.y3c_1.solveWithOptions(this.z3c_1, Companion_getInstance_5().allLazilyWithTimeout(9223372036854775807n));
1827
+ suspendResult = this.b3d_1.sc(map(tmp_0, DynamicLoader$AbstractWithLib$solve$slambda$lambda(this.a3d_1)), this);
1847
1828
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
1848
1829
  return suspendResult;
1849
1830
  }
@@ -1866,8 +1847,8 @@
1866
1847
  while (true);
1867
1848
  };
1868
1849
  protoOf(DynamicLoader$AbstractWithLib$solve$slambda).d2o = function ($this$sequence, completion) {
1869
- var i = new DynamicLoader$AbstractWithLib$solve$slambda(this.z3c_1, this.a3d_1, this.b3d_1, completion);
1870
- i.c3d_1 = $this$sequence;
1850
+ var i = new DynamicLoader$AbstractWithLib$solve$slambda(this.y3c_1, this.z3c_1, this.a3d_1, completion);
1851
+ i.b3d_1 = $this$sequence;
1871
1852
  return i;
1872
1853
  };
1873
1854
  function DynamicLoader$AbstractWithLib$solve$slambda_0($solver, $goal, $request, resultContinuation) {
@@ -1894,7 +1875,7 @@
1894
1875
  };
1895
1876
  }
1896
1877
  function AbstractWithLib($outer) {
1897
- this.d3d_1 = $outer;
1878
+ this.c3d_1 = $outer;
1898
1879
  }
1899
1880
  protoOf(AbstractWithLib).g2e = function (request) {
1900
1881
  var lib = request.arguments.w(0);
@@ -1905,78 +1886,33 @@
1905
1886
  if (!isInterface(goal, Struct)) {
1906
1887
  throw Companion_instance_3.forGoal(request.context, request.signature, Expected_CALLABLE_getInstance(), goal);
1907
1888
  }
1908
- var tmp0 = this.d3d_1.f3d_1.b39();
1909
- var tmp$ret$1;
1910
- $l$block: {
1911
- // Inline function 'kotlin.collections.firstOrNull' call
1912
- var _iterator__ex2g4s = tmp0.p();
1913
- while (_iterator__ex2g4s.s()) {
1914
- var element = _iterator__ex2g4s.t();
1915
- if ((isInterface(element, Loadable) ? element : THROW_CCE()).a3a() === lib.toString()) {
1916
- tmp$ret$1 = element;
1917
- break $l$block;
1918
- }
1919
- }
1920
- tmp$ret$1 = null;
1921
- }
1922
- var tmp0_elvis_lhs = tmp$ret$1;
1923
- var tmp;
1924
- if (tmp0_elvis_lhs == null) {
1925
- throw Companion_instance_4.forGoal(request.context, request.signature, Companion_instance_5.of('Loadable Lib'), lib);
1926
- } else {
1927
- tmp = tmp0_elvis_lhs;
1928
- }
1929
- // Inline function 'kotlin.let' call
1930
- var library = tmp;
1931
- var tmp_0 = Companion_instance;
1932
- // Inline function 'kotlin.collections.filterNot' call
1933
- var tmp0_0 = request.context.z1s().z1s();
1934
- // Inline function 'kotlin.collections.filterNotTo' call
1935
- var destination = ArrayList_init_$Create$_0();
1936
- var _iterator__ex2g4s_0 = tmp0_0.p();
1937
- while (_iterator__ex2g4s_0.s()) {
1938
- var element_0 = _iterator__ex2g4s_0.t();
1939
- // Inline function 'kotlin.collections.map' call
1940
- var this_0 = this.d3d_1.f3d_1.b39();
1941
- // Inline function 'kotlin.collections.mapTo' call
1942
- var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
1943
- var _iterator__ex2g4s_1 = this_0.p();
1944
- while (_iterator__ex2g4s_1.s()) {
1945
- var item = _iterator__ex2g4s_1.t();
1946
- var tmp$ret$2 = item.y2b();
1947
- destination_0.m(tmp$ret$2);
1948
- }
1949
- if (!destination_0.u(element_0.y2b())) {
1950
- destination.m(element_0);
1951
- }
1952
- }
1953
- var solver = request.context.createMutableSolver(VOID, tmp_0.ofIterable(destination).plusLibrary(library.h39()), VOID, request.context.b1t());
1954
- this.e3d(lib.toString(), solver);
1889
+ var solver = this.c3d_1.i3d(request, lib);
1890
+ this.d3d(lib.toString(), solver);
1955
1891
  return sequence(DynamicLoader$AbstractWithLib$solve$slambda_0(solver, goal, request, null));
1956
1892
  };
1957
1893
  protoOf(AbstractWithLib).solve = function (request) {
1958
1894
  return this.g2e(request);
1959
1895
  };
1960
1896
  function WithLib($outer) {
1961
- this.k3d_1 = $outer;
1897
+ this.l3d_1 = $outer;
1962
1898
  AbstractWithLib.call(this, $outer);
1963
- this.j3d_1 = new Signature('::', 2);
1899
+ this.k3d_1 = new Signature('::', 2);
1964
1900
  }
1965
1901
  protoOf(WithLib).m1s = function () {
1966
- return this.j3d_1;
1902
+ return this.k3d_1;
1967
1903
  };
1968
- protoOf(WithLib).e3d = function (module_0, solver) {
1904
+ protoOf(WithLib).d3d = function (module_0, solver) {
1969
1905
  return Unit_instance;
1970
1906
  };
1971
1907
  function WithLibInNewContext($outer) {
1972
- this.n3d_1 = $outer;
1908
+ this.o3d_1 = $outer;
1973
1909
  AbstractWithLib.call(this, $outer);
1974
- this.m3d_1 = new Signature(':::', 2);
1910
+ this.n3d_1 = new Signature(':::', 2);
1975
1911
  }
1976
1912
  protoOf(WithLibInNewContext).m1s = function () {
1977
- return this.m3d_1;
1913
+ return this.n3d_1;
1978
1914
  };
1979
- protoOf(WithLibInNewContext).e3d = function (module_0, solver) {
1915
+ protoOf(WithLibInNewContext).d3d = function (module_0, solver) {
1980
1916
  return logicProgramming(DynamicLoader$WithLibInNewContext$execute$lambda(solver));
1981
1917
  };
1982
1918
  function Companion_0() {
@@ -1989,17 +1925,83 @@
1989
1925
  return Companion_instance_8;
1990
1926
  }
1991
1927
  function DynamicLoader(solver) {
1992
- this.f3d_1 = solver;
1928
+ this.e3d_1 = solver;
1929
+ var tmp = this;
1930
+ // Inline function 'kotlin.collections.mutableMapOf' call
1931
+ tmp.f3d_1 = LinkedHashMap_init_$Create$_0();
1993
1932
  this.g3d_1 = 'prolog.argumentation.loader';
1994
1933
  this.h3d_1 = Companion_instance_8.d39();
1995
1934
  }
1935
+ protoOf(DynamicLoader).i3d = function (request, library) {
1936
+ var tmp0 = this.f3d_1;
1937
+ // Inline function 'kotlin.collections.getOrPut' call
1938
+ var key = library.toString();
1939
+ var value = tmp0.h2(key);
1940
+ var tmp;
1941
+ if (value == null) {
1942
+ var tmp0_0 = this.e3d_1.b39();
1943
+ var tmp$ret$1;
1944
+ $l$block: {
1945
+ // Inline function 'kotlin.collections.firstOrNull' call
1946
+ var _iterator__ex2g4s = tmp0_0.p();
1947
+ while (_iterator__ex2g4s.s()) {
1948
+ var element = _iterator__ex2g4s.t();
1949
+ if ((isInterface(element, Loadable) ? element : THROW_CCE()).z39() === library.toString()) {
1950
+ tmp$ret$1 = element;
1951
+ break $l$block;
1952
+ }
1953
+ }
1954
+ tmp$ret$1 = null;
1955
+ }
1956
+ var tmp0_elvis_lhs = tmp$ret$1;
1957
+ var tmp_0;
1958
+ if (tmp0_elvis_lhs == null) {
1959
+ throw Companion_instance_4.forGoal(request.context, request.signature, Companion_instance_5.of('Loadable Lib'), library);
1960
+ } else {
1961
+ tmp_0 = tmp0_elvis_lhs;
1962
+ }
1963
+ // Inline function 'kotlin.let' call
1964
+ var x = tmp_0;
1965
+ var tmp_1 = Companion_instance;
1966
+ // Inline function 'kotlin.collections.filterNot' call
1967
+ var tmp0_1 = request.context.z1s().z1s();
1968
+ // Inline function 'kotlin.collections.filterNotTo' call
1969
+ var destination = ArrayList_init_$Create$_0();
1970
+ var _iterator__ex2g4s_0 = tmp0_1.p();
1971
+ while (_iterator__ex2g4s_0.s()) {
1972
+ var element_0 = _iterator__ex2g4s_0.t();
1973
+ // Inline function 'kotlin.collections.map' call
1974
+ var this_0 = this.e3d_1.b39();
1975
+ // Inline function 'kotlin.collections.mapTo' call
1976
+ var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
1977
+ var _iterator__ex2g4s_1 = this_0.p();
1978
+ while (_iterator__ex2g4s_1.s()) {
1979
+ var item = _iterator__ex2g4s_1.t();
1980
+ var tmp$ret$2 = item.y2b();
1981
+ destination_0.m(tmp$ret$2);
1982
+ }
1983
+ if (!destination_0.u(element_0.y2b())) {
1984
+ destination.m(element_0);
1985
+ }
1986
+ }
1987
+ var answer = request.context.createMutableSolver(VOID, tmp_1.ofIterable(destination).plusLibrary(x.h39()));
1988
+ tmp0.k4(key, answer);
1989
+ tmp = answer;
1990
+ } else {
1991
+ tmp = value;
1992
+ }
1993
+ // Inline function 'kotlin.also' call
1994
+ var this_1 = tmp;
1995
+ this_1.loadStaticKb(request.context.b1t());
1996
+ return this_1;
1997
+ };
1996
1998
  protoOf(DynamicLoader).y2b = function () {
1997
1999
  return this.g3d_1;
1998
2000
  };
1999
- protoOf(DynamicLoader).z39 = function () {
2001
+ protoOf(DynamicLoader).y39 = function () {
2000
2002
  // Inline function 'kotlin.let' call
2001
2003
  var it = listOf([new WithLib(this), new WithLibInNewContext(this)]);
2002
- var tmp = Companion_getInstance_3();
2004
+ var tmp = Companion_getInstance_2();
2003
2005
  // Inline function 'kotlin.collections.associateBy' call
2004
2006
  var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(it, 10)), 16);
2005
2007
  // Inline function 'kotlin.collections.associateByTo' call
@@ -2017,48 +2019,51 @@
2017
2019
  };
2018
2020
  function EngineInterfaceBase() {
2019
2021
  LazyRawPrologContent.call(this);
2020
- this.p3d_1 = 'prolog.argumentation.interface';
2021
- this.q3d_1 = Companion_instance_10.d39().plusOperatorSet(Companion_instance_8.d39()).plusOperatorSet(Companion_getInstance_1().DEFAULT);
2022
+ this.q3d_1 = 'prolog.argumentation.interface';
2023
+ this.r3d_1 = Companion_instance_10.d39().plusOperatorSet(Companion_instance_8.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
2022
2024
  }
2023
2025
  protoOf(EngineInterfaceBase).y2b = function () {
2024
- return this.p3d_1;
2026
+ return this.q3d_1;
2025
2027
  };
2026
- protoOf(EngineInterfaceBase).z39 = function () {
2027
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a(), Companion_instance_10.d39());
2028
+ protoOf(EngineInterfaceBase).y39 = function () {
2029
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a(), Companion_instance_10.d39());
2028
2030
  };
2029
2031
  protoOf(EngineInterfaceBase).i39 = function () {
2030
- return this.q3d_1;
2032
+ return this.r3d_1;
2033
+ };
2034
+ protoOf(EngineInterfaceBase).z39 = function () {
2035
+ return 'arg2p';
2031
2036
  };
2032
2037
  function Companion_1() {
2033
2038
  }
2034
- protoOf(Companion_1).r3d = function (target) {
2039
+ protoOf(Companion_1).s3d = function (target) {
2035
2040
  // Inline function 'kotlin.also' call
2036
- var this_0 = Companion_instance_2.empty(Companion_getInstance_2().u1i());
2041
+ var this_0 = Companion_instance_2.empty(Companion_getInstance_1().u1i());
2037
2042
  $l$block: {
2038
- if (target.j39_1) {
2043
+ if (target.l39_1) {
2039
2044
  break $l$block;
2040
2045
  }
2041
2046
  // Inline function 'kotlin.collections.forEach' call
2042
- var _iterator__ex2g4s = target.t39_1.p();
2047
+ var _iterator__ex2g4s = target.v39_1.p();
2043
2048
  while (_iterator__ex2g4s.s()) {
2044
2049
  var element = _iterator__ex2g4s.t();
2045
- this_0.g1q(parseClause(Companion_getInstance_7(), GraphExtension_instance.s3d() + '(X) :- X = ' + element));
2050
+ this_0.g1q(parseClause(Companion_getInstance_6(), GraphExtension_instance.t3d() + '(X) :- X = ' + element));
2046
2051
  }
2047
- if (target.k39_1) {
2048
- this_0.g1r(parseStruct(Companion_getInstance(), QueryMode_instance.s3d()));
2052
+ if (target.m39_1) {
2053
+ this_0.g1r(parseStruct(Companion_getInstance_7(), QueryMode_instance.t3d()));
2049
2054
  }
2050
- if (target.l39_1) {
2051
- this_0.g1r(parseStruct(Companion_getInstance(), AutoTransposition_instance.s3d()));
2055
+ if (target.n39_1) {
2056
+ this_0.g1r(parseStruct(Companion_getInstance_7(), AutoTransposition_instance.t3d()));
2052
2057
  }
2053
- if (target.m39_1) {
2054
- this_0.g1r(parseStruct(Companion_getInstance(), PrologStrictCompatibility_instance.s3d()));
2058
+ if (target.o39_1) {
2059
+ this_0.g1r(parseStruct(Companion_getInstance_7(), PrologStrictCompatibility_instance.t3d()));
2055
2060
  }
2056
- this_0.g1r(parseStruct(Companion_getInstance(), GraphBuildMode_instance.s3d() + '(' + target.n39_1 + ')'));
2057
- this_0.g1r(parseStruct(Companion_getInstance(), ArgumentLabellingMode_instance.s3d() + '(' + target.o39_1 + ')'));
2058
- this_0.g1r(parseStruct(Companion_getInstance(), StatementLabellingMode_instance.s3d() + '(' + target.p39_1 + ')'));
2059
- this_0.g1r(parseStruct(Companion_getInstance(), OrderingPrinciple_instance.s3d() + '(' + target.q39_1 + ')'));
2060
- this_0.g1r(parseStruct(Companion_getInstance(), OrderingComparator_instance.s3d() + '(' + target.r39_1 + ')'));
2061
- this_0.g1r(parseStruct(Companion_getInstance(), ModulesPath_instance.s3d() + '(' + target.s39_1 + ')'));
2061
+ this_0.g1r(parseStruct(Companion_getInstance_7(), GraphBuildMode_instance.t3d() + '(' + target.p39_1 + ')'));
2062
+ this_0.g1r(parseStruct(Companion_getInstance_7(), ArgumentLabellingMode_instance.t3d() + '(' + target.q39_1 + ')'));
2063
+ this_0.g1r(parseStruct(Companion_getInstance_7(), StatementLabellingMode_instance.t3d() + '(' + target.r39_1 + ')'));
2064
+ this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingPrinciple_instance.t3d() + '(' + target.s39_1 + ')'));
2065
+ this_0.g1r(parseStruct(Companion_getInstance_7(), OrderingComparator_instance.t3d() + '(' + target.t39_1 + ')'));
2066
+ this_0.g1r(parseStruct(Companion_getInstance_7(), ModulesPath_instance.t3d() + '(' + target.u39_1 + ')'));
2062
2067
  }
2063
2068
  return this_0;
2064
2069
  };
@@ -2067,57 +2072,57 @@
2067
2072
  return Companion_instance_9;
2068
2073
  }
2069
2074
  function FlagsBuilder$create$1(this$0) {
2070
- this.u3d_1 = this$0;
2071
- this.t3d_1 = 'prolog.argumentation.flags';
2075
+ this.v3d_1 = this$0;
2076
+ this.u3d_1 = 'prolog.argumentation.flags';
2072
2077
  }
2073
2078
  protoOf(FlagsBuilder$create$1).y2b = function () {
2074
- return this.t3d_1;
2079
+ return this.u3d_1;
2075
2080
  };
2076
- protoOf(FlagsBuilder$create$1).z39 = function () {
2077
- return Companion_getInstance_3().of(this.t3d_1, VOID, Companion_instance_9.r3d(this.u3d_1));
2081
+ protoOf(FlagsBuilder$create$1).y39 = function () {
2082
+ return Companion_getInstance_2().of(this.u3d_1, VOID, Companion_instance_9.s3d(this.v3d_1));
2078
2083
  };
2079
2084
  function FlagsBuilder(emptyBuilder, queryMode, autoTransposition, prologStrictCompatibility, graphBuildMode, argumentLabellingMode, statementLabellingMode, orderingPrinciple, orderingComparator, modulesPath, graphExtensions) {
2080
2085
  emptyBuilder = emptyBuilder === VOID ? false : emptyBuilder;
2081
- queryMode = queryMode === VOID ? QueryMode_instance.v3d() : queryMode;
2082
- autoTransposition = autoTransposition === VOID ? AutoTransposition_instance.v3d() : autoTransposition;
2083
- prologStrictCompatibility = prologStrictCompatibility === VOID ? PrologStrictCompatibility_instance.v3d() : prologStrictCompatibility;
2084
- graphBuildMode = graphBuildMode === VOID ? GraphBuildMode_instance.v3d() : graphBuildMode;
2085
- argumentLabellingMode = argumentLabellingMode === VOID ? ArgumentLabellingMode_instance.v3d() : argumentLabellingMode;
2086
- statementLabellingMode = statementLabellingMode === VOID ? StatementLabellingMode_instance.v3d() : statementLabellingMode;
2087
- orderingPrinciple = orderingPrinciple === VOID ? OrderingPrinciple_instance.v3d() : orderingPrinciple;
2088
- orderingComparator = orderingComparator === VOID ? OrderingComparator_instance.v3d() : orderingComparator;
2089
- modulesPath = modulesPath === VOID ? ModulesPath_instance.v3d() : modulesPath;
2090
- graphExtensions = graphExtensions === VOID ? GraphExtension_instance.v3d() : graphExtensions;
2091
- this.j39_1 = emptyBuilder;
2092
- this.k39_1 = queryMode;
2093
- this.l39_1 = autoTransposition;
2094
- this.m39_1 = prologStrictCompatibility;
2095
- this.n39_1 = graphBuildMode;
2096
- this.o39_1 = argumentLabellingMode;
2097
- this.p39_1 = statementLabellingMode;
2098
- this.q39_1 = orderingPrinciple;
2099
- this.r39_1 = orderingComparator;
2100
- this.s39_1 = modulesPath;
2101
- this.t39_1 = graphExtensions;
2102
- }
2103
- protoOf(FlagsBuilder).u39 = function () {
2086
+ queryMode = queryMode === VOID ? QueryMode_instance.w3d() : queryMode;
2087
+ autoTransposition = autoTransposition === VOID ? AutoTransposition_instance.w3d() : autoTransposition;
2088
+ prologStrictCompatibility = prologStrictCompatibility === VOID ? PrologStrictCompatibility_instance.w3d() : prologStrictCompatibility;
2089
+ graphBuildMode = graphBuildMode === VOID ? GraphBuildMode_instance.w3d() : graphBuildMode;
2090
+ argumentLabellingMode = argumentLabellingMode === VOID ? ArgumentLabellingMode_instance.w3d() : argumentLabellingMode;
2091
+ statementLabellingMode = statementLabellingMode === VOID ? StatementLabellingMode_instance.w3d() : statementLabellingMode;
2092
+ orderingPrinciple = orderingPrinciple === VOID ? OrderingPrinciple_instance.w3d() : orderingPrinciple;
2093
+ orderingComparator = orderingComparator === VOID ? OrderingComparator_instance.w3d() : orderingComparator;
2094
+ modulesPath = modulesPath === VOID ? ModulesPath_instance.w3d() : modulesPath;
2095
+ graphExtensions = graphExtensions === VOID ? GraphExtension_instance.w3d() : graphExtensions;
2096
+ this.l39_1 = emptyBuilder;
2097
+ this.m39_1 = queryMode;
2098
+ this.n39_1 = autoTransposition;
2099
+ this.o39_1 = prologStrictCompatibility;
2100
+ this.p39_1 = graphBuildMode;
2101
+ this.q39_1 = argumentLabellingMode;
2102
+ this.r39_1 = statementLabellingMode;
2103
+ this.s39_1 = orderingPrinciple;
2104
+ this.t39_1 = orderingComparator;
2105
+ this.u39_1 = modulesPath;
2106
+ this.v39_1 = graphExtensions;
2107
+ }
2108
+ protoOf(FlagsBuilder).w39 = function () {
2104
2109
  return new FlagsBuilder$create$1(this);
2105
2110
  };
2106
2111
  protoOf(FlagsBuilder).toString = function () {
2107
- return 'FlagsBuilder(emptyBuilder=' + this.j39_1 + ', queryMode=' + this.k39_1 + ', autoTransposition=' + this.l39_1 + ', prologStrictCompatibility=' + this.m39_1 + ', graphBuildMode=' + this.n39_1 + ', argumentLabellingMode=' + this.o39_1 + ', statementLabellingMode=' + this.p39_1 + ', orderingPrinciple=' + this.q39_1 + ', orderingComparator=' + this.r39_1 + ', modulesPath=' + this.s39_1 + ', graphExtensions=' + toString(this.t39_1) + ')';
2112
+ return 'FlagsBuilder(emptyBuilder=' + this.l39_1 + ', queryMode=' + this.m39_1 + ', autoTransposition=' + this.n39_1 + ', prologStrictCompatibility=' + this.o39_1 + ', graphBuildMode=' + this.p39_1 + ', argumentLabellingMode=' + this.q39_1 + ', statementLabellingMode=' + this.r39_1 + ', orderingPrinciple=' + this.s39_1 + ', orderingComparator=' + this.t39_1 + ', modulesPath=' + this.u39_1 + ', graphExtensions=' + toString(this.v39_1) + ')';
2108
2113
  };
2109
2114
  protoOf(FlagsBuilder).hashCode = function () {
2110
- var result = getBooleanHashCode(this.j39_1);
2111
- result = imul(result, 31) + getBooleanHashCode(this.k39_1) | 0;
2112
- result = imul(result, 31) + getBooleanHashCode(this.l39_1) | 0;
2115
+ var result = getBooleanHashCode(this.l39_1);
2113
2116
  result = imul(result, 31) + getBooleanHashCode(this.m39_1) | 0;
2114
- result = imul(result, 31) + getStringHashCode(this.n39_1) | 0;
2115
- result = imul(result, 31) + getStringHashCode(this.o39_1) | 0;
2117
+ result = imul(result, 31) + getBooleanHashCode(this.n39_1) | 0;
2118
+ result = imul(result, 31) + getBooleanHashCode(this.o39_1) | 0;
2116
2119
  result = imul(result, 31) + getStringHashCode(this.p39_1) | 0;
2117
2120
  result = imul(result, 31) + getStringHashCode(this.q39_1) | 0;
2118
2121
  result = imul(result, 31) + getStringHashCode(this.r39_1) | 0;
2119
2122
  result = imul(result, 31) + getStringHashCode(this.s39_1) | 0;
2120
- result = imul(result, 31) + hashCode(this.t39_1) | 0;
2123
+ result = imul(result, 31) + getStringHashCode(this.t39_1) | 0;
2124
+ result = imul(result, 31) + getStringHashCode(this.u39_1) | 0;
2125
+ result = imul(result, 31) + hashCode(this.v39_1) | 0;
2121
2126
  return result;
2122
2127
  };
2123
2128
  protoOf(FlagsBuilder).equals = function (other) {
@@ -2125,10 +2130,6 @@
2125
2130
  return true;
2126
2131
  if (!(other instanceof FlagsBuilder))
2127
2132
  return false;
2128
- if (!(this.j39_1 === other.j39_1))
2129
- return false;
2130
- if (!(this.k39_1 === other.k39_1))
2131
- return false;
2132
2133
  if (!(this.l39_1 === other.l39_1))
2133
2134
  return false;
2134
2135
  if (!(this.m39_1 === other.m39_1))
@@ -2145,20 +2146,24 @@
2145
2146
  return false;
2146
2147
  if (!(this.s39_1 === other.s39_1))
2147
2148
  return false;
2148
- if (!equals(this.t39_1, other.t39_1))
2149
+ if (!(this.t39_1 === other.t39_1))
2150
+ return false;
2151
+ if (!(this.u39_1 === other.u39_1))
2152
+ return false;
2153
+ if (!equals(this.v39_1, other.v39_1))
2149
2154
  return false;
2150
2155
  return true;
2151
2156
  };
2152
2157
  function MetaInterpreter() {
2153
- this.w3d_1 = 'prolog.argumentation.meta.crossjustice';
2158
+ this.x3d_1 = 'prolog.argumentation.meta.crossjustice';
2154
2159
  }
2155
2160
  protoOf(MetaInterpreter).y2b = function () {
2156
- return this.w3d_1;
2161
+ return this.x3d_1;
2157
2162
  };
2158
- protoOf(MetaInterpreter).z39 = function () {
2159
- return Companion_getInstance_3().of(this.w3d_1, VOID, parseTheory(Companion_instance_0, '% with_facts_and_length/3\nwith_facts_and_length(X, Y, L) :-\n solve(X, R),\n recover_facts(R, Y),\n length(Y, L).\n\n% lenght/2\n\nlength([], 0).\nlength([_|T], X) :- length(T, Y), X is Y + 1.\n\n% recover_facts/2\n\nrecover_facts([], []) :- !.\nrecover_facts([H|T], C) :-\n is_list(H), !,\n recover_facts(T, TC),\n recover_facts(H, HC),\n append(TC, HC, C).\nrecover_facts([H|T], C) :-\n \\+ is_list(H),\n recover_facts(T, TC),\n evaluate(H, HC),\n append(TC, HC, C).\n\nevaluate(user_fact(X), [X]) :- !.\nevaluate(_, []) :- !.\n\n% solve/2\n\nsolve((A,B), Result) :- !,\n solve(A, ARes),\n solve(B, BRes),\n append(ARes, BRes, Result).\n\nsolve((A;B), Result) :- !,\n solve(A, Result);\n solve(B, Result).\n\nsolve(member(A, B), [system_predicate]) :- !,\n call(member(A, B)).\n\nsolve(\\+(A), [not(A)]) :- !,\n call(\\+(A)).\n\nsolve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n call((A)\\=(B)).\n\nsolve(A, [system_predicate]) :-\n catch(clause(A, _), B, true),\n \\+ var(B), !,\n call(A).\n\nsolve(A, [A]) :-\n \\+ clause(A, B), !,\n call(A).\n\nsolve(A, [A|[Res]]) :-\n clause(A, B),\n solve(B, Res).\n\n% is_list/1\n\nis_list(X) :- var(X), !, fail.\nis_list([]).\nis_list([_|T]) :- is_list(T).\n\n% fetch_argument_facts/2\n\nfetch_argument_facts(Conclusion, Facts) :-\n argument([R, TR, [Conclusion]]),\n findall(user_fact(Fact), \n support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n Facts).'));
2163
+ protoOf(MetaInterpreter).y39 = function () {
2164
+ return Companion_getInstance_2().of(this.x3d_1, VOID, parseTheory(Companion_instance_0, '% with_facts_and_length/3\nwith_facts_and_length(X, Y, L) :-\n solve(X, R),\n recover_facts(R, Y),\n length(Y, L).\n\n% lenght/2\n\nlength([], 0).\nlength([_|T], X) :- length(T, Y), X is Y + 1.\n\n% recover_facts/2\n\nrecover_facts([], []) :- !.\nrecover_facts([H|T], C) :-\n is_list(H), !,\n recover_facts(T, TC),\n recover_facts(H, HC),\n append(TC, HC, C).\nrecover_facts([H|T], C) :-\n \\+ is_list(H),\n recover_facts(T, TC),\n evaluate(H, HC),\n append(TC, HC, C).\n\nevaluate(user_fact(X), [X]) :- !.\nevaluate(_, []) :- !.\n\n% solve/2\n\nsolve((A,B), Result) :- !,\n solve(A, ARes),\n solve(B, BRes),\n append(ARes, BRes, Result).\n\nsolve((A;B), Result) :- !,\n solve(A, Result);\n solve(B, Result).\n\nsolve(member(A, B), [system_predicate]) :- !,\n call(member(A, B)).\n\nsolve(\\+(A), [not(A)]) :- !,\n call(\\+(A)).\n\nsolve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n call((A)\\=(B)).\n\nsolve(A, [system_predicate]) :-\n catch(clause(A, _), B, true),\n \\+ var(B), !,\n call(A).\n\nsolve(A, [A]) :-\n \\+ clause(A, B), !,\n call(A).\n\nsolve(A, [A|[Res]]) :-\n clause(A, B),\n solve(B, Res).\n\n% is_list/1\n\nis_list(X) :- var(X), !, fail.\nis_list([]).\nis_list([_|T]) :- is_list(T).\n\n% fetch_argument_facts/2\n\nfetch_argument_facts(Conclusion, Facts) :-\n argument([R, TR, [Conclusion]]),\n findall(user_fact(Fact), \n support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n Facts).'));
2160
2165
  };
2161
- protoOf(MetaInterpreter).a3a = function () {
2166
+ protoOf(MetaInterpreter).z39 = function () {
2162
2167
  return 'interpreter';
2163
2168
  };
2164
2169
  var MetaInterpreter_instance;
@@ -2166,15 +2171,15 @@
2166
2171
  return MetaInterpreter_instance;
2167
2172
  }
2168
2173
  function ModuleCalls() {
2169
- this.x3d_1 = 'prolog.argumentation.modularity';
2174
+ this.y3d_1 = 'prolog.argumentation.modularity';
2170
2175
  }
2171
2176
  protoOf(ModuleCalls).y2b = function () {
2172
- return this.x3d_1;
2177
+ return this.y3d_1;
2173
2178
  };
2174
- protoOf(ModuleCalls).z39 = function () {
2175
- return Companion_getInstance_3().of(this.x3d_1, mapOf(to(ModuleCall_getInstance().y3d_1, ModuleCall_getInstance())));
2179
+ protoOf(ModuleCalls).y39 = function () {
2180
+ return Companion_getInstance_2().of(this.y3d_1, mapOf(to(ModuleCall_getInstance().z3d_1, ModuleCall_getInstance())));
2176
2181
  };
2177
- protoOf(ModuleCalls).a3a = function () {
2182
+ protoOf(ModuleCalls).z39 = function () {
2178
2183
  return 'module';
2179
2184
  };
2180
2185
  var ModuleCalls_instance;
@@ -2200,9 +2205,9 @@
2200
2205
  return logicProgramming_0(VOID, ModuleCall$getCleanSolver$lambda_0(context, modules, module_0));
2201
2206
  }
2202
2207
  function ModuleCall$solve$slambda($solver, $goal, $request, resultContinuation) {
2203
- this.h3e_1 = $solver;
2204
- this.i3e_1 = $goal;
2205
- this.j3e_1 = $request;
2208
+ this.i3e_1 = $solver;
2209
+ this.j3e_1 = $goal;
2210
+ this.k3e_1 = $request;
2206
2211
  CoroutineImpl.call(this, resultContinuation);
2207
2212
  }
2208
2213
  protoOf(ModuleCall$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -2223,8 +2228,8 @@
2223
2228
  case 0:
2224
2229
  this.c8_1 = 2;
2225
2230
  this.b8_1 = 1;
2226
- var tmp_0 = this.h3e_1.solve(this.i3e_1);
2227
- suspendResult = this.k3e_1.sc(map(tmp_0, ModuleCall$solve$slambda$lambda(this.j3e_1)), this);
2231
+ var tmp_0 = this.i3e_1.solve(this.j3e_1);
2232
+ suspendResult = this.l3e_1.sc(map(tmp_0, ModuleCall$solve$slambda$lambda(this.k3e_1)), this);
2228
2233
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
2229
2234
  return suspendResult;
2230
2235
  }
@@ -2247,8 +2252,8 @@
2247
2252
  while (true);
2248
2253
  };
2249
2254
  protoOf(ModuleCall$solve$slambda).d2o = function ($this$sequence, completion) {
2250
- var i = new ModuleCall$solve$slambda(this.h3e_1, this.i3e_1, this.j3e_1, completion);
2251
- i.k3e_1 = $this$sequence;
2255
+ var i = new ModuleCall$solve$slambda(this.i3e_1, this.j3e_1, this.k3e_1, completion);
2256
+ i.l3e_1 = $this$sequence;
2252
2257
  return i;
2253
2258
  };
2254
2259
  function ModuleCall$solve$slambda_0($solver, $goal, $request, resultContinuation) {
@@ -2296,7 +2301,7 @@
2296
2301
  }
2297
2302
  function ModuleCall() {
2298
2303
  ModuleCall_instance = this;
2299
- this.y3d_1 = new Signature('call_module', 2);
2304
+ this.z3d_1 = new Signature('call_module', 2);
2300
2305
  }
2301
2306
  protoOf(ModuleCall).g2e = function (request) {
2302
2307
  var modules = request.arguments.w(0);
@@ -2332,10 +2337,10 @@
2332
2337
  }
2333
2338
  function ModulesPath() {
2334
2339
  }
2335
- protoOf(ModulesPath).s3d = function () {
2340
+ protoOf(ModulesPath).t3d = function () {
2336
2341
  return 'modulesPath';
2337
2342
  };
2338
- protoOf(ModulesPath).v3d = function () {
2343
+ protoOf(ModulesPath).w3d = function () {
2339
2344
  return 'none';
2340
2345
  };
2341
2346
  var ModulesPath_instance;
@@ -2344,27 +2349,27 @@
2344
2349
  }
2345
2350
  function AbstractModeBase() {
2346
2351
  LazyRawPrologContent.call(this);
2347
- this.m3e_1 = 'prolog.argumentation.abstract';
2348
- this.n3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2352
+ this.n3e_1 = 'prolog.argumentation.abstract';
2353
+ this.o3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2349
2354
  }
2350
2355
  protoOf(AbstractModeBase).y2b = function () {
2351
- return this.m3e_1;
2356
+ return this.n3e_1;
2352
2357
  };
2353
- protoOf(AbstractModeBase).z39 = function () {
2354
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2358
+ protoOf(AbstractModeBase).y39 = function () {
2359
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2355
2360
  };
2356
- protoOf(AbstractModeBase).a3a = function () {
2361
+ protoOf(AbstractModeBase).z39 = function () {
2357
2362
  return 'abstract';
2358
2363
  };
2359
2364
  protoOf(AbstractModeBase).i39 = function () {
2360
- return this.n3e_1;
2365
+ return this.o3e_1;
2361
2366
  };
2362
2367
  function GraphExtension() {
2363
2368
  }
2364
- protoOf(GraphExtension).s3d = function () {
2369
+ protoOf(GraphExtension).t3d = function () {
2365
2370
  return 'graphExtension';
2366
2371
  };
2367
- protoOf(GraphExtension).v3d = function () {
2372
+ protoOf(GraphExtension).w3d = function () {
2368
2373
  return listOf_0('standardPref');
2369
2374
  };
2370
2375
  var GraphExtension_instance;
@@ -2373,10 +2378,10 @@
2373
2378
  }
2374
2379
  function ArgumentLabellingMode() {
2375
2380
  }
2376
- protoOf(ArgumentLabellingMode).s3d = function () {
2381
+ protoOf(ArgumentLabellingMode).t3d = function () {
2377
2382
  return 'argumentLabellingMode';
2378
2383
  };
2379
- protoOf(ArgumentLabellingMode).v3d = function () {
2384
+ protoOf(ArgumentLabellingMode).w3d = function () {
2380
2385
  return 'grounded';
2381
2386
  };
2382
2387
  var ArgumentLabellingMode_instance;
@@ -2385,10 +2390,10 @@
2385
2390
  }
2386
2391
  function StatementLabellingMode() {
2387
2392
  }
2388
- protoOf(StatementLabellingMode).s3d = function () {
2393
+ protoOf(StatementLabellingMode).t3d = function () {
2389
2394
  return 'statementLabellingMode';
2390
2395
  };
2391
- protoOf(StatementLabellingMode).v3d = function () {
2396
+ protoOf(StatementLabellingMode).w3d = function () {
2392
2397
  return 'statement';
2393
2398
  };
2394
2399
  var StatementLabellingMode_instance;
@@ -2397,10 +2402,10 @@
2397
2402
  }
2398
2403
  function GraphBuildMode() {
2399
2404
  }
2400
- protoOf(GraphBuildMode).s3d = function () {
2405
+ protoOf(GraphBuildMode).t3d = function () {
2401
2406
  return 'graphBuildMode';
2402
2407
  };
2403
- protoOf(GraphBuildMode).v3d = function () {
2408
+ protoOf(GraphBuildMode).w3d = function () {
2404
2409
  return 'standard_af';
2405
2410
  };
2406
2411
  var GraphBuildMode_instance;
@@ -2409,122 +2414,122 @@
2409
2414
  }
2410
2415
  function ArgumentationGraphBuilderBase() {
2411
2416
  LazyRawPrologContent.call(this);
2412
- this.p3e_1 = 'prolog.argumentation.graph';
2413
- this.q3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2417
+ this.q3e_1 = 'prolog.argumentation.graph';
2418
+ this.r3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2414
2419
  }
2415
2420
  protoOf(ArgumentationGraphBuilderBase).y2b = function () {
2416
- return this.p3e_1;
2421
+ return this.q3e_1;
2417
2422
  };
2418
- protoOf(ArgumentationGraphBuilderBase).z39 = function () {
2419
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2423
+ protoOf(ArgumentationGraphBuilderBase).y39 = function () {
2424
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2420
2425
  };
2421
- protoOf(ArgumentationGraphBuilderBase).a3a = function () {
2426
+ protoOf(ArgumentationGraphBuilderBase).z39 = function () {
2422
2427
  return 'standard_af';
2423
2428
  };
2424
2429
  protoOf(ArgumentationGraphBuilderBase).i39 = function () {
2425
- return this.q3e_1;
2430
+ return this.r3e_1;
2426
2431
  };
2427
2432
  function AttackRestrictionHandlerBase() {
2428
2433
  LazyRawPrologContent.call(this);
2429
- this.s3e_1 = 'prolog.argumentation.graph.rebutrestriction';
2430
- this.t3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2434
+ this.t3e_1 = 'prolog.argumentation.graph.rebutrestriction';
2435
+ this.u3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2431
2436
  }
2432
2437
  protoOf(AttackRestrictionHandlerBase).y2b = function () {
2433
- return this.s3e_1;
2438
+ return this.t3e_1;
2434
2439
  };
2435
- protoOf(AttackRestrictionHandlerBase).z39 = function () {
2436
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2440
+ protoOf(AttackRestrictionHandlerBase).y39 = function () {
2441
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2437
2442
  };
2438
- protoOf(AttackRestrictionHandlerBase).a3a = function () {
2443
+ protoOf(AttackRestrictionHandlerBase).z39 = function () {
2439
2444
  return 'rebutRestriction';
2440
2445
  };
2441
2446
  protoOf(AttackRestrictionHandlerBase).i39 = function () {
2442
- return this.t3e_1;
2447
+ return this.u3e_1;
2443
2448
  };
2444
2449
  function BpMetaGraphHandlerBase() {
2445
2450
  LazyRawPrologContent.call(this);
2446
- this.v3e_1 = 'prolog.argumentation.graph.meta.bp';
2447
- this.w3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2451
+ this.w3e_1 = 'prolog.argumentation.graph.meta.bp';
2452
+ this.x3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2448
2453
  }
2449
2454
  protoOf(BpMetaGraphHandlerBase).y2b = function () {
2450
- return this.v3e_1;
2455
+ return this.w3e_1;
2451
2456
  };
2452
- protoOf(BpMetaGraphHandlerBase).z39 = function () {
2453
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2457
+ protoOf(BpMetaGraphHandlerBase).y39 = function () {
2458
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2454
2459
  };
2455
- protoOf(BpMetaGraphHandlerBase).a3a = function () {
2460
+ protoOf(BpMetaGraphHandlerBase).z39 = function () {
2456
2461
  return 'bp';
2457
2462
  };
2458
2463
  protoOf(BpMetaGraphHandlerBase).i39 = function () {
2459
- return this.w3e_1;
2464
+ return this.x3e_1;
2460
2465
  };
2461
2466
  function DefeasiblePreferencesHandlerBase() {
2462
2467
  LazyRawPrologContent.call(this);
2463
- this.y3e_1 = 'prolog.argumentation.graph.preferences.defeasible';
2464
- this.z3e_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2468
+ this.z3e_1 = 'prolog.argumentation.graph.preferences.defeasible';
2469
+ this.a3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2465
2470
  }
2466
2471
  protoOf(DefeasiblePreferencesHandlerBase).y2b = function () {
2467
- return this.y3e_1;
2472
+ return this.z3e_1;
2468
2473
  };
2469
- protoOf(DefeasiblePreferencesHandlerBase).z39 = function () {
2470
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2474
+ protoOf(DefeasiblePreferencesHandlerBase).y39 = function () {
2475
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2471
2476
  };
2472
- protoOf(DefeasiblePreferencesHandlerBase).a3a = function () {
2477
+ protoOf(DefeasiblePreferencesHandlerBase).z39 = function () {
2473
2478
  return 'defeasiblePref';
2474
2479
  };
2475
2480
  protoOf(DefeasiblePreferencesHandlerBase).i39 = function () {
2476
- return this.z3e_1;
2481
+ return this.a3f_1;
2477
2482
  };
2478
2483
  function GenericDefeasiblePreferencesHandlerBase() {
2479
2484
  LazyRawPrologContent.call(this);
2480
- this.b3f_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
2481
- this.c3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2485
+ this.c3f_1 = 'prolog.argumentation.graph.preferences.defeasible.generic';
2486
+ this.d3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2482
2487
  }
2483
2488
  protoOf(GenericDefeasiblePreferencesHandlerBase).y2b = function () {
2484
- return this.b3f_1;
2489
+ return this.c3f_1;
2485
2490
  };
2486
- protoOf(GenericDefeasiblePreferencesHandlerBase).z39 = function () {
2487
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2491
+ protoOf(GenericDefeasiblePreferencesHandlerBase).y39 = function () {
2492
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2488
2493
  };
2489
- protoOf(GenericDefeasiblePreferencesHandlerBase).a3a = function () {
2494
+ protoOf(GenericDefeasiblePreferencesHandlerBase).z39 = function () {
2490
2495
  return 'defeasibleAllPref';
2491
2496
  };
2492
2497
  protoOf(GenericDefeasiblePreferencesHandlerBase).i39 = function () {
2493
- return this.c3f_1;
2498
+ return this.d3f_1;
2494
2499
  };
2495
2500
  function StrictPreferencesHandlerBase() {
2496
2501
  LazyRawPrologContent.call(this);
2497
- this.e3f_1 = 'prolog.argumentation.graph.preferences.strict';
2498
- this.f3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2502
+ this.f3f_1 = 'prolog.argumentation.graph.preferences.strict';
2503
+ this.g3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2499
2504
  }
2500
2505
  protoOf(StrictPreferencesHandlerBase).y2b = function () {
2501
- return this.e3f_1;
2506
+ return this.f3f_1;
2502
2507
  };
2503
- protoOf(StrictPreferencesHandlerBase).z39 = function () {
2504
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2508
+ protoOf(StrictPreferencesHandlerBase).y39 = function () {
2509
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2505
2510
  };
2506
- protoOf(StrictPreferencesHandlerBase).a3a = function () {
2511
+ protoOf(StrictPreferencesHandlerBase).z39 = function () {
2507
2512
  return 'standardPref';
2508
2513
  };
2509
2514
  protoOf(StrictPreferencesHandlerBase).i39 = function () {
2510
- return this.f3f_1;
2515
+ return this.g3f_1;
2511
2516
  };
2512
2517
  function BinaryStatementLabeller() {
2513
2518
  BinaryStatementLabeller_instance = this;
2514
- this.g3f_1 = 'prolog.argumentation.graph.labelling.statement.binary';
2515
- this.h3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2519
+ this.h3f_1 = 'prolog.argumentation.graph.labelling.statement.binary';
2520
+ this.i3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2516
2521
  }
2517
2522
  protoOf(BinaryStatementLabeller).y2b = function () {
2518
- return this.g3f_1;
2523
+ return this.h3f_1;
2519
2524
  };
2520
- protoOf(BinaryStatementLabeller).z39 = function () {
2521
- return Companion_getInstance_3().of(this.g3f_1, VOID, Companion_instance_0.ofWithDefaultUnificator([BinaryLabelling_getInstance().n1s()]));
2525
+ protoOf(BinaryStatementLabeller).y39 = function () {
2526
+ return Companion_getInstance_2().of(this.h3f_1, VOID, Companion_instance_0.ofWithDefaultUnificator([BinaryLabelling_getInstance().n1s()]));
2522
2527
  };
2523
- protoOf(BinaryStatementLabeller).a3a = function () {
2528
+ protoOf(BinaryStatementLabeller).z39 = function () {
2524
2529
  return 'statement_binary';
2525
2530
  };
2526
2531
  protoOf(BinaryStatementLabeller).i39 = function () {
2527
- return this.h3f_1;
2532
+ return this.i3f_1;
2528
2533
  };
2529
2534
  var BinaryStatementLabeller_instance;
2530
2535
  function BinaryStatementLabeller_getInstance() {
@@ -2550,122 +2555,122 @@
2550
2555
  }
2551
2556
  function BpCompleteLabellerBase() {
2552
2557
  LazyRawPrologContent.call(this);
2553
- this.m3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
2554
- this.n3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2558
+ this.n3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedcomplete';
2559
+ this.o3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2555
2560
  }
2556
2561
  protoOf(BpCompleteLabellerBase).y2b = function () {
2557
- return this.m3f_1;
2562
+ return this.n3f_1;
2558
2563
  };
2559
- protoOf(BpCompleteLabellerBase).z39 = function () {
2560
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2564
+ protoOf(BpCompleteLabellerBase).y39 = function () {
2565
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2561
2566
  };
2562
- protoOf(BpCompleteLabellerBase).a3a = function () {
2567
+ protoOf(BpCompleteLabellerBase).z39 = function () {
2563
2568
  return 'bp_grounded_complete';
2564
2569
  };
2565
2570
  protoOf(BpCompleteLabellerBase).i39 = function () {
2566
- return this.n3f_1;
2571
+ return this.o3f_1;
2567
2572
  };
2568
2573
  function BpLabellerBase() {
2569
2574
  LazyRawPrologContent.call(this);
2570
- this.p3f_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
2571
- this.q3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2575
+ this.q3f_1 = 'prolog.argumentation.graph.labelling.bpgrounded';
2576
+ this.r3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2572
2577
  }
2573
2578
  protoOf(BpLabellerBase).y2b = function () {
2574
- return this.p3f_1;
2579
+ return this.q3f_1;
2575
2580
  };
2576
- protoOf(BpLabellerBase).z39 = function () {
2577
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2581
+ protoOf(BpLabellerBase).y39 = function () {
2582
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2578
2583
  };
2579
- protoOf(BpLabellerBase).a3a = function () {
2584
+ protoOf(BpLabellerBase).z39 = function () {
2580
2585
  return 'bp_grounded';
2581
2586
  };
2582
2587
  protoOf(BpLabellerBase).i39 = function () {
2583
- return this.q3f_1;
2588
+ return this.r3f_1;
2584
2589
  };
2585
2590
  function BpPartialLabellerBase() {
2586
2591
  LazyRawPrologContent.call(this);
2587
- this.s3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
2588
- this.t3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2592
+ this.t3f_1 = 'prolog.argumentation.graph.labelling.bpgroundedpartial';
2593
+ this.u3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2589
2594
  }
2590
2595
  protoOf(BpPartialLabellerBase).y2b = function () {
2591
- return this.s3f_1;
2596
+ return this.t3f_1;
2592
2597
  };
2593
- protoOf(BpPartialLabellerBase).z39 = function () {
2594
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2598
+ protoOf(BpPartialLabellerBase).y39 = function () {
2599
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2595
2600
  };
2596
- protoOf(BpPartialLabellerBase).a3a = function () {
2601
+ protoOf(BpPartialLabellerBase).z39 = function () {
2597
2602
  return 'bp_grounded_partial';
2598
2603
  };
2599
2604
  protoOf(BpPartialLabellerBase).i39 = function () {
2600
- return this.t3f_1;
2605
+ return this.u3f_1;
2601
2606
  };
2602
2607
  function CompleteLabellerBase() {
2603
2608
  LazyRawPrologContent.call(this);
2604
- this.v3f_1 = 'prolog.argumentation.graph.labelling.complete';
2605
- this.w3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2609
+ this.w3f_1 = 'prolog.argumentation.graph.labelling.complete';
2610
+ this.x3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2606
2611
  }
2607
2612
  protoOf(CompleteLabellerBase).y2b = function () {
2608
- return this.v3f_1;
2613
+ return this.w3f_1;
2609
2614
  };
2610
- protoOf(CompleteLabellerBase).z39 = function () {
2611
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2615
+ protoOf(CompleteLabellerBase).y39 = function () {
2616
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2612
2617
  };
2613
- protoOf(CompleteLabellerBase).a3a = function () {
2618
+ protoOf(CompleteLabellerBase).z39 = function () {
2614
2619
  return 'complete';
2615
2620
  };
2616
2621
  protoOf(CompleteLabellerBase).i39 = function () {
2617
- return this.w3f_1;
2622
+ return this.x3f_1;
2618
2623
  };
2619
2624
  function GroundedLabellerBase() {
2620
2625
  LazyRawPrologContent.call(this);
2621
- this.y3f_1 = 'prolog.argumentation.graph.labelling.grounded';
2622
- this.z3f_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2626
+ this.z3f_1 = 'prolog.argumentation.graph.labelling.grounded';
2627
+ this.a3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2623
2628
  }
2624
2629
  protoOf(GroundedLabellerBase).y2b = function () {
2625
- return this.y3f_1;
2630
+ return this.z3f_1;
2626
2631
  };
2627
- protoOf(GroundedLabellerBase).z39 = function () {
2628
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2632
+ protoOf(GroundedLabellerBase).y39 = function () {
2633
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2629
2634
  };
2630
- protoOf(GroundedLabellerBase).a3a = function () {
2635
+ protoOf(GroundedLabellerBase).z39 = function () {
2631
2636
  return 'grounded';
2632
2637
  };
2633
2638
  protoOf(GroundedLabellerBase).i39 = function () {
2634
- return this.z3f_1;
2639
+ return this.a3g_1;
2635
2640
  };
2636
2641
  function GroundedLabellerOptimizedBase() {
2637
2642
  LazyRawPrologContent.call(this);
2638
- this.b3g_1 = 'prolog.argumentation.graph.labelling.grounded.optimized';
2639
- this.c3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2643
+ this.c3g_1 = 'prolog.argumentation.graph.labelling.grounded.optimized';
2644
+ this.d3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2640
2645
  }
2641
2646
  protoOf(GroundedLabellerOptimizedBase).y2b = function () {
2642
- return this.b3g_1;
2647
+ return this.c3g_1;
2643
2648
  };
2644
- protoOf(GroundedLabellerOptimizedBase).z39 = function () {
2645
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2649
+ protoOf(GroundedLabellerOptimizedBase).y39 = function () {
2650
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2646
2651
  };
2647
- protoOf(GroundedLabellerOptimizedBase).a3a = function () {
2652
+ protoOf(GroundedLabellerOptimizedBase).z39 = function () {
2648
2653
  return 'grounded_hash';
2649
2654
  };
2650
2655
  protoOf(GroundedLabellerOptimizedBase).i39 = function () {
2651
- return this.c3g_1;
2656
+ return this.d3g_1;
2652
2657
  };
2653
2658
  function PassThroughStatementLabeller() {
2654
2659
  PassThroughStatementLabeller_instance = this;
2655
- this.d3g_1 = 'prolog.argumentation.graph.labelling.statement.pt';
2656
- this.e3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2660
+ this.e3g_1 = 'prolog.argumentation.graph.labelling.statement.pt';
2661
+ this.f3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2657
2662
  }
2658
2663
  protoOf(PassThroughStatementLabeller).y2b = function () {
2659
- return this.d3g_1;
2664
+ return this.e3g_1;
2660
2665
  };
2661
- protoOf(PassThroughStatementLabeller).z39 = function () {
2662
- return Companion_getInstance_3().of(this.d3g_1, VOID, Companion_instance_0.ofWithDefaultUnificator([Labelling_getInstance().n1s()]));
2666
+ protoOf(PassThroughStatementLabeller).y39 = function () {
2667
+ return Companion_getInstance_2().of(this.e3g_1, VOID, Companion_instance_0.ofWithDefaultUnificator([Labelling_getInstance().n1s()]));
2663
2668
  };
2664
- protoOf(PassThroughStatementLabeller).a3a = function () {
2669
+ protoOf(PassThroughStatementLabeller).z39 = function () {
2665
2670
  return 'statement_pass_through';
2666
2671
  };
2667
2672
  protoOf(PassThroughStatementLabeller).i39 = function () {
2668
- return this.e3g_1;
2673
+ return this.f3g_1;
2669
2674
  };
2670
2675
  var PassThroughStatementLabeller_instance;
2671
2676
  function PassThroughStatementLabeller_getInstance() {
@@ -2691,20 +2696,20 @@
2691
2696
  }
2692
2697
  function StatementLabellerBase() {
2693
2698
  LazyRawPrologContent.call(this);
2694
- this.j3g_1 = 'prolog.argumentation.graph.labelling.statement';
2695
- this.k3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
2699
+ this.k3g_1 = 'prolog.argumentation.graph.labelling.statement';
2700
+ this.l3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
2696
2701
  }
2697
2702
  protoOf(StatementLabellerBase).y2b = function () {
2698
- return this.j3g_1;
2703
+ return this.k3g_1;
2699
2704
  };
2700
- protoOf(StatementLabellerBase).z39 = function () {
2701
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
2705
+ protoOf(StatementLabellerBase).y39 = function () {
2706
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
2702
2707
  };
2703
- protoOf(StatementLabellerBase).a3a = function () {
2708
+ protoOf(StatementLabellerBase).z39 = function () {
2704
2709
  return 'statement';
2705
2710
  };
2706
2711
  protoOf(StatementLabellerBase).i39 = function () {
2707
- return this.k3g_1;
2712
+ return this.l3g_1;
2708
2713
  };
2709
2714
  function Companion_2() {
2710
2715
  }
@@ -2766,14 +2771,14 @@
2766
2771
  }
2767
2772
  function RuleParserBase() {
2768
2773
  LazyRawPrologContent.call(this);
2769
- this.m3g_1 = 'prolog.argumentation.parser';
2770
- this.n3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_instance_10.d39()).plusOperatorSet(Companion_getInstance_1().DEFAULT);
2774
+ this.n3g_1 = 'prolog.argumentation.parser';
2775
+ this.o3g_1 = Companion_instance_8.d39().plusOperatorSet(Companion_instance_10.d39()).plusOperatorSet(Companion_getInstance_0().DEFAULT);
2771
2776
  }
2772
2777
  protoOf(RuleParserBase).y2b = function () {
2773
- return this.m3g_1;
2778
+ return this.n3g_1;
2774
2779
  };
2775
- protoOf(RuleParserBase).z39 = function () {
2776
- var tmp = Companion_getInstance_3();
2780
+ protoOf(RuleParserBase).y39 = function () {
2781
+ var tmp = Companion_getInstance_2();
2777
2782
  var tmp_0 = this.y2b();
2778
2783
  var tmp_1 = KProperty0;
2779
2784
  var tmp_2 = getPropertyCallableRef('descriptionPair', 0, tmp_1, StrictRules$_get_descriptionPair_$ref_jme898(StrictRules_getInstance()), null).get();
@@ -2788,13 +2793,13 @@
2788
2793
  var tmp_11 = KProperty0;
2789
2794
  var tmp_12 = getPropertyCallableRef('descriptionPair', 0, tmp_11, ExtractStrictIds$_get_descriptionPair_$ref_faxu5w(ExtractStrictIds_getInstance()), null).get();
2790
2795
  var tmp_13 = KProperty0;
2791
- return tmp.of(tmp_0, mapOf_0([tmp_2, tmp_4, tmp_6, tmp_8, tmp_10, tmp_12, getPropertyCallableRef('descriptionPair', 0, tmp_13, RuleToClause$_get_descriptionPair_$ref_20povg(RuleToClause_getInstance()), null).get()]), this.d3a(), Companion_instance_10.d39());
2796
+ return tmp.of(tmp_0, mapOf_0([tmp_2, tmp_4, tmp_6, tmp_8, tmp_10, tmp_12, getPropertyCallableRef('descriptionPair', 0, tmp_13, RuleToClause$_get_descriptionPair_$ref_20povg(RuleToClause_getInstance()), null).get()]), this.c3a(), Companion_instance_10.d39());
2792
2797
  };
2793
- protoOf(RuleParserBase).a3a = function () {
2798
+ protoOf(RuleParserBase).z39 = function () {
2794
2799
  return 'parser';
2795
2800
  };
2796
2801
  protoOf(RuleParserBase).i39 = function () {
2797
- return this.n3g_1;
2802
+ return this.o3g_1;
2798
2803
  };
2799
2804
  function StrictRules$computeAllSubstitutions$lambda($this_computeAllSubstitutions) {
2800
2805
  return function (clauses, prologScope) {
@@ -2814,7 +2819,7 @@
2814
2819
  var _iterator__ex2g4s_0 = destination.p();
2815
2820
  while (_iterator__ex2g4s_0.s()) {
2816
2821
  var item = _iterator__ex2g4s_0.t();
2817
- var tmp$ret$3 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.o3g(item, $this_computeAllSubstitutions), ensureNotNull(item.nw())]);
2822
+ var tmp$ret$3 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.p3g(item, $this_computeAllSubstitutions), ensureNotNull(item.nw())]);
2818
2823
  destination_0.m(tmp$ret$3);
2819
2824
  }
2820
2825
  return listToTerm(destination_0);
@@ -2824,12 +2829,12 @@
2824
2829
  StrictRules_instance = this;
2825
2830
  WithoutSideEffects.call(this, 'prologStrictRules');
2826
2831
  }
2827
- protoOf(StrictRules).q3g = function (_this__u8e3s4, first) {
2832
+ protoOf(StrictRules).r3g = function (_this__u8e3s4, first) {
2828
2833
  var tmp = ConversionUtils_instance;
2829
- return tmp.r3g(_this__u8e3s4, first, VOID, StrictRules$computeAllSubstitutions$lambda(_this__u8e3s4));
2834
+ return tmp.s3g(_this__u8e3s4, first, VOID, StrictRules$computeAllSubstitutions$lambda(_this__u8e3s4));
2830
2835
  };
2831
2836
  protoOf(StrictRules).x2g = function (_this__u8e3s4, first) {
2832
- return this.q3g(_this__u8e3s4, first);
2837
+ return this.r3g(_this__u8e3s4, first);
2833
2838
  };
2834
2839
  var StrictRules_instance;
2835
2840
  function StrictRules_getInstance() {
@@ -2863,12 +2868,12 @@
2863
2868
  Axioms_instance = this;
2864
2869
  WithoutSideEffects.call(this, 'prologAxioms');
2865
2870
  }
2866
- protoOf(Axioms).q3g = function (_this__u8e3s4, first) {
2871
+ protoOf(Axioms).r3g = function (_this__u8e3s4, first) {
2867
2872
  var tmp = ConversionUtils_instance;
2868
- return tmp.r3g(_this__u8e3s4, first, VOID, Axioms$computeAllSubstitutions$lambda);
2873
+ return tmp.s3g(_this__u8e3s4, first, VOID, Axioms$computeAllSubstitutions$lambda);
2869
2874
  };
2870
2875
  protoOf(Axioms).x2g = function (_this__u8e3s4, first) {
2871
- return this.q3g(_this__u8e3s4, first);
2876
+ return this.r3g(_this__u8e3s4, first);
2872
2877
  };
2873
2878
  var Axioms_instance;
2874
2879
  function Axioms_getInstance() {
@@ -2900,7 +2905,7 @@
2900
2905
  var _iterator__ex2g4s_0 = destination.p();
2901
2906
  while (_iterator__ex2g4s_0.s()) {
2902
2907
  var item = _iterator__ex2g4s_0.t();
2903
- var tmp$ret$3 = Companion_getInstance().of('abstractBp', [prologScope.logicListOfIterable(ensureNotNull(item.nw()).iu())]);
2908
+ var tmp$ret$3 = Companion_getInstance_7().of('abstractBp', [prologScope.logicListOfIterable(ensureNotNull(item.nw()).iu())]);
2904
2909
  destination_0.m(tmp$ret$3);
2905
2910
  }
2906
2911
  return listToTerm(destination_0);
@@ -2909,12 +2914,12 @@
2909
2914
  Bps_instance = this;
2910
2915
  WithoutSideEffects.call(this, 'bpsNew');
2911
2916
  }
2912
- protoOf(Bps).q3g = function (_this__u8e3s4, first) {
2917
+ protoOf(Bps).r3g = function (_this__u8e3s4, first) {
2913
2918
  var tmp = ConversionUtils_instance;
2914
- return tmp.u3g(_this__u8e3s4, first, true, Bps$computeAllSubstitutions$lambda);
2919
+ return tmp.v3g(_this__u8e3s4, first, true, Bps$computeAllSubstitutions$lambda);
2915
2920
  };
2916
2921
  protoOf(Bps).x2g = function (_this__u8e3s4, first) {
2917
- return this.q3g(_this__u8e3s4, first);
2922
+ return this.r3g(_this__u8e3s4, first);
2918
2923
  };
2919
2924
  var Bps_instance;
2920
2925
  function Bps_getInstance() {
@@ -2948,12 +2953,12 @@
2948
2953
  Premises_instance = this;
2949
2954
  WithoutSideEffects.call(this, 'prologPremises');
2950
2955
  }
2951
- protoOf(Premises).q3g = function (_this__u8e3s4, first) {
2956
+ protoOf(Premises).r3g = function (_this__u8e3s4, first) {
2952
2957
  var tmp = ConversionUtils_instance;
2953
- return tmp.r3g(_this__u8e3s4, first, VOID, Premises$computeAllSubstitutions$lambda);
2958
+ return tmp.s3g(_this__u8e3s4, first, VOID, Premises$computeAllSubstitutions$lambda);
2954
2959
  };
2955
2960
  protoOf(Premises).x2g = function (_this__u8e3s4, first) {
2956
- return this.q3g(_this__u8e3s4, first);
2961
+ return this.r3g(_this__u8e3s4, first);
2957
2962
  };
2958
2963
  var Premises_instance;
2959
2964
  function Premises_getInstance() {
@@ -3019,7 +3024,7 @@
3019
3024
  }
3020
3025
  // Inline function 'kotlin.let' call
3021
3026
  var it = tmp_3;
3022
- var tmp$ret$6 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.o3g(it, $this_computeAllSubstitutions), ensureNotNull(it.nw())]);
3027
+ var tmp$ret$6 = prologScope.logicListOfAny(['rule_' + Default_getInstance().wf(0, 2147483647), ConversionUtils_instance.p3g(it, $this_computeAllSubstitutions), ensureNotNull(it.nw())]);
3023
3028
  destination_0.m(tmp$ret$6);
3024
3029
  }
3025
3030
  return listToTerm(destination_0);
@@ -3029,12 +3034,12 @@
3029
3034
  DefeasibleRules_instance = this;
3030
3035
  WithoutSideEffects.call(this, 'prologDefeasibleRules');
3031
3036
  }
3032
- protoOf(DefeasibleRules).q3g = function (_this__u8e3s4, first) {
3037
+ protoOf(DefeasibleRules).r3g = function (_this__u8e3s4, first) {
3033
3038
  var tmp = ConversionUtils_instance;
3034
- return tmp.r3g(_this__u8e3s4, first, VOID, DefeasibleRules$computeAllSubstitutions$lambda(_this__u8e3s4));
3039
+ return tmp.s3g(_this__u8e3s4, first, VOID, DefeasibleRules$computeAllSubstitutions$lambda(_this__u8e3s4));
3035
3040
  };
3036
3041
  protoOf(DefeasibleRules).x2g = function (_this__u8e3s4, first) {
3037
- return this.q3g(_this__u8e3s4, first);
3042
+ return this.r3g(_this__u8e3s4, first);
3038
3043
  };
3039
3044
  var DefeasibleRules_instance;
3040
3045
  function DefeasibleRules_getInstance() {
@@ -3047,7 +3052,7 @@
3047
3052
  WithoutSideEffects_0.call(this, 'extract_id');
3048
3053
  }
3049
3054
  protoOf(ExtractStrictIds).a2m = function (_this__u8e3s4, first, second) {
3050
- var tmp = Companion_getInstance_4();
3055
+ var tmp = Companion_getInstance_3();
3051
3056
  var tmp_0 = ensureNotNull(second.asVar());
3052
3057
  var tmp_1 = Companion_instance_6;
3053
3058
  // Inline function 'kotlin.collections.map' call
@@ -3057,7 +3062,7 @@
3057
3062
  var _iterator__ex2g4s = this_0.p();
3058
3063
  while (_iterator__ex2g4s.s()) {
3059
3064
  var item = _iterator__ex2g4s.t();
3060
- var tmp$ret$0 = Companion_getInstance().of('strict', [ensureNotNull(item.asCons()).nw()]);
3065
+ var tmp$ret$0 = Companion_getInstance_7().of('strict', [ensureNotNull(item.asCons()).nw()]);
3061
3066
  destination.m(tmp$ret$0);
3062
3067
  }
3063
3068
  return sequenceOf(tmp.of(tmp_0, tmp_1.ofList(destination)));
@@ -3076,7 +3081,7 @@
3076
3081
  WithoutSideEffects_0.call(this, 'rule_to_clause');
3077
3082
  }
3078
3083
  protoOf(RuleToClause).a2m = function (_this__u8e3s4, first, second) {
3079
- var tmp = Companion_getInstance_4();
3084
+ var tmp = Companion_getInstance_3();
3080
3085
  var tmp_0 = ensureNotNull(second.asVar());
3081
3086
  var tmp_1 = Companion_instance_6;
3082
3087
  // Inline function 'kotlin.collections.map' call
@@ -3091,10 +3096,10 @@
3091
3096
  var tmp_2;
3092
3097
  switch (it.v()) {
3093
3098
  case 2:
3094
- tmp_2 = Companion_getInstance_7().pw(Companion_getInstance().of('rl', [it.w(1)]), [item]);
3099
+ tmp_2 = Companion_getInstance_6().pw(Companion_getInstance_7().of('rl', [it.w(1)]), [item]);
3095
3100
  break;
3096
3101
  case 3:
3097
- tmp_2 = Companion_getInstance_7().pw(Companion_getInstance().of('rl', [it.w(2)]), [item]);
3102
+ tmp_2 = Companion_getInstance_6().pw(Companion_getInstance_7().of('rl', [it.w(2)]), [item]);
3098
3103
  break;
3099
3104
  default:
3100
3105
  throw IllegalArgumentException_init_$Create$();
@@ -3115,10 +3120,10 @@
3115
3120
  }
3116
3121
  function AutoTransposition() {
3117
3122
  }
3118
- protoOf(AutoTransposition).s3d = function () {
3123
+ protoOf(AutoTransposition).t3d = function () {
3119
3124
  return 'autoTransposition';
3120
3125
  };
3121
- protoOf(AutoTransposition).v3d = function () {
3126
+ protoOf(AutoTransposition).w3d = function () {
3122
3127
  return false;
3123
3128
  };
3124
3129
  var AutoTransposition_instance;
@@ -3127,10 +3132,10 @@
3127
3132
  }
3128
3133
  function PrologStrictCompatibility() {
3129
3134
  }
3130
- protoOf(PrologStrictCompatibility).s3d = function () {
3135
+ protoOf(PrologStrictCompatibility).t3d = function () {
3131
3136
  return 'prologStrictCompatibility';
3132
3137
  };
3133
- protoOf(PrologStrictCompatibility).v3d = function () {
3138
+ protoOf(PrologStrictCompatibility).w3d = function () {
3134
3139
  return false;
3135
3140
  };
3136
3141
  var PrologStrictCompatibility_instance;
@@ -3179,10 +3184,10 @@
3179
3184
  }
3180
3185
  function ConversionUtils$commonMap$lambda($first, $force, $context, $mapper) {
3181
3186
  return function ($this$prolog) {
3182
- var tmp = Companion_getInstance_4();
3187
+ var tmp = Companion_getInstance_3();
3183
3188
  var tmp_0 = $first.castToVar();
3184
3189
  var tmp_1;
3185
- if ($force || first($context.solve(parseStruct(Companion_getInstance(), 'prologStrictCompatibility'))).d1u()) {
3190
+ if ($force || first($context.solve(parseStruct(Companion_getInstance_7(), 'prologStrictCompatibility'))).d1u()) {
3186
3191
  tmp_1 = $mapper($context.context.b1t().l1j(), $this$prolog);
3187
3192
  } else {
3188
3193
  tmp_1 = $this$prolog.vz();
@@ -3192,16 +3197,16 @@
3192
3197
  }
3193
3198
  function ConversionUtils() {
3194
3199
  }
3195
- protoOf(ConversionUtils).o3g = function (target, context) {
3200
+ protoOf(ConversionUtils).p3g = function (target, context) {
3196
3201
  return prolog(VOID, ConversionUtils$modifiers$lambda(target, context));
3197
3202
  };
3198
- protoOf(ConversionUtils).u3g = function (context, first, force, mapper) {
3203
+ protoOf(ConversionUtils).v3g = function (context, first, force, mapper) {
3199
3204
  Companion_getInstance_9().v2e(context, 0);
3200
3205
  return prolog(VOID, ConversionUtils$commonMap$lambda(first, force, context, mapper));
3201
3206
  };
3202
- protoOf(ConversionUtils).r3g = function (context, first, force, mapper, $super) {
3207
+ protoOf(ConversionUtils).s3g = function (context, first, force, mapper, $super) {
3203
3208
  force = force === VOID ? false : force;
3204
- return $super === VOID ? this.u3g(context, first, force, mapper) : $super.u3g.call(this, context, first, force, mapper);
3209
+ return $super === VOID ? this.v3g(context, first, force, mapper) : $super.v3g.call(this, context, first, force, mapper);
3205
3210
  };
3206
3211
  var ConversionUtils_instance;
3207
3212
  function ConversionUtils_getInstance() {
@@ -3209,27 +3214,27 @@
3209
3214
  }
3210
3215
  function StructuredModeBase() {
3211
3216
  LazyRawPrologContent.call(this);
3212
- this.a3h_1 = 'prolog.argumentation.structured';
3213
- this.b3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
3217
+ this.b3h_1 = 'prolog.argumentation.structured';
3218
+ this.c3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
3214
3219
  }
3215
3220
  protoOf(StructuredModeBase).y2b = function () {
3216
- return this.a3h_1;
3221
+ return this.b3h_1;
3217
3222
  };
3218
- protoOf(StructuredModeBase).z39 = function () {
3219
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
3223
+ protoOf(StructuredModeBase).y39 = function () {
3224
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
3220
3225
  };
3221
- protoOf(StructuredModeBase).a3a = function () {
3226
+ protoOf(StructuredModeBase).z39 = function () {
3222
3227
  return 'structured';
3223
3228
  };
3224
3229
  protoOf(StructuredModeBase).i39 = function () {
3225
- return this.b3h_1;
3230
+ return this.c3h_1;
3226
3231
  };
3227
3232
  function QueryMode() {
3228
3233
  }
3229
- protoOf(QueryMode).s3d = function () {
3234
+ protoOf(QueryMode).t3d = function () {
3230
3235
  return 'queryMode';
3231
3236
  };
3232
- protoOf(QueryMode).v3d = function () {
3237
+ protoOf(QueryMode).w3d = function () {
3233
3238
  return true;
3234
3239
  };
3235
3240
  var QueryMode_instance;
@@ -3238,61 +3243,61 @@
3238
3243
  }
3239
3244
  function AttackRelationBase() {
3240
3245
  LazyRawPrologContent.call(this);
3241
- this.d3h_1 = 'prolog.argumentation.attack';
3242
- this.e3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
3246
+ this.e3h_1 = 'prolog.argumentation.attack';
3247
+ this.f3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
3243
3248
  }
3244
3249
  protoOf(AttackRelationBase).y2b = function () {
3245
- return this.d3h_1;
3250
+ return this.e3h_1;
3246
3251
  };
3247
- protoOf(AttackRelationBase).z39 = function () {
3248
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
3252
+ protoOf(AttackRelationBase).y39 = function () {
3253
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
3249
3254
  };
3250
- protoOf(AttackRelationBase).a3a = function () {
3255
+ protoOf(AttackRelationBase).z39 = function () {
3251
3256
  return 'attack';
3252
3257
  };
3253
3258
  protoOf(AttackRelationBase).i39 = function () {
3254
- return this.e3h_1;
3259
+ return this.f3h_1;
3255
3260
  };
3256
3261
  function DebugBase() {
3257
3262
  LazyRawPrologContent.call(this);
3258
- this.g3h_1 = 'prolog.argumentation.debug';
3259
- this.h3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
3263
+ this.h3h_1 = 'prolog.argumentation.debug';
3264
+ this.i3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
3260
3265
  }
3261
3266
  protoOf(DebugBase).y2b = function () {
3262
- return this.g3h_1;
3267
+ return this.h3h_1;
3263
3268
  };
3264
- protoOf(DebugBase).z39 = function () {
3265
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
3269
+ protoOf(DebugBase).y39 = function () {
3270
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
3266
3271
  };
3267
- protoOf(DebugBase).a3a = function () {
3272
+ protoOf(DebugBase).z39 = function () {
3268
3273
  return 'debug';
3269
3274
  };
3270
3275
  protoOf(DebugBase).i39 = function () {
3271
- return this.h3h_1;
3276
+ return this.i3h_1;
3272
3277
  };
3273
3278
  function SuperiorityRelationBase() {
3274
3279
  LazyRawPrologContent.call(this);
3275
- this.j3h_1 = 'prolog.argumentation.superiority';
3276
- this.k3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
3280
+ this.k3h_1 = 'prolog.argumentation.superiority';
3281
+ this.l3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
3277
3282
  }
3278
3283
  protoOf(SuperiorityRelationBase).y2b = function () {
3279
- return this.j3h_1;
3284
+ return this.k3h_1;
3280
3285
  };
3281
- protoOf(SuperiorityRelationBase).z39 = function () {
3282
- return Companion_getInstance_3().of(this.y2b(), VOID, this.d3a());
3286
+ protoOf(SuperiorityRelationBase).y39 = function () {
3287
+ return Companion_getInstance_2().of(this.y2b(), VOID, this.c3a());
3283
3288
  };
3284
- protoOf(SuperiorityRelationBase).a3a = function () {
3289
+ protoOf(SuperiorityRelationBase).z39 = function () {
3285
3290
  return 'superiority';
3286
3291
  };
3287
3292
  protoOf(SuperiorityRelationBase).i39 = function () {
3288
- return this.k3h_1;
3293
+ return this.l3h_1;
3289
3294
  };
3290
3295
  function OrderingPrinciple() {
3291
3296
  }
3292
- protoOf(OrderingPrinciple).s3d = function () {
3297
+ protoOf(OrderingPrinciple).t3d = function () {
3293
3298
  return 'orderingPrinciple';
3294
3299
  };
3295
- protoOf(OrderingPrinciple).v3d = function () {
3300
+ protoOf(OrderingPrinciple).w3d = function () {
3296
3301
  return 'last';
3297
3302
  };
3298
3303
  var OrderingPrinciple_instance;
@@ -3301,10 +3306,10 @@
3301
3306
  }
3302
3307
  function OrderingComparator() {
3303
3308
  }
3304
- protoOf(OrderingComparator).s3d = function () {
3309
+ protoOf(OrderingComparator).t3d = function () {
3305
3310
  return 'orderingComparator';
3306
3311
  };
3307
- protoOf(OrderingComparator).v3d = function () {
3312
+ protoOf(OrderingComparator).w3d = function () {
3308
3313
  return 'elitist';
3309
3314
  };
3310
3315
  var OrderingComparator_instance;
@@ -3313,35 +3318,35 @@
3313
3318
  }
3314
3319
  function UtilsBase() {
3315
3320
  LazyRawPrologContent.call(this);
3316
- this.m3h_1 = 'prolog.argumentation.utils';
3317
- this.n3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_1().DEFAULT);
3321
+ this.n3h_1 = 'prolog.argumentation.utils';
3322
+ this.o3h_1 = Companion_instance_8.d39().plusOperatorSet(Companion_getInstance_0().DEFAULT);
3318
3323
  }
3319
3324
  protoOf(UtilsBase).y2b = function () {
3320
- return this.m3h_1;
3325
+ return this.n3h_1;
3321
3326
  };
3322
- protoOf(UtilsBase).z39 = function () {
3323
- var tmp0_$this = Companion_getInstance_3();
3327
+ protoOf(UtilsBase).y39 = function () {
3328
+ var tmp0_$this = Companion_getInstance_2();
3324
3329
  var tmp1_alias = this.y2b();
3325
- var tmp2_clauses = this.d3a();
3326
- var tmp = to(AppendOptimized_getInstance().o3h_1, AppendOptimized_getInstance());
3327
- var tmp_0 = to(AssertAll_getInstance().p3h_1, AssertAll_getInstance());
3330
+ var tmp2_clauses = this.c3a();
3331
+ var tmp = to(AppendOptimized_getInstance().p3h_1, AppendOptimized_getInstance());
3332
+ var tmp_0 = to(AssertAll_getInstance().q3h_1, AssertAll_getInstance());
3328
3333
  // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.descriptionPair' call
3329
3334
  var this_0 = ArgumentHash_getInstance();
3330
3335
  var tmp$ret$0 = to(this_0.signature, this_0.n1s());
3331
- var tmp3_primitives = mapOf_0([tmp, tmp_0, tmp$ret$0, to(Contains_getInstance().q3h_1, Contains_getInstance()), to(ContainsAny_getInstance().r3h_1, ContainsAny_getInstance())]);
3336
+ var tmp3_primitives = mapOf_0([tmp, tmp_0, tmp$ret$0, to(Contains_getInstance().r3h_1, Contains_getInstance()), to(ContainsAny_getInstance().s3h_1, ContainsAny_getInstance())]);
3332
3337
  return tmp0_$this.of(tmp1_alias, tmp3_primitives, tmp2_clauses);
3333
3338
  };
3334
- protoOf(UtilsBase).a3a = function () {
3339
+ protoOf(UtilsBase).z39 = function () {
3335
3340
  return 'utils';
3336
3341
  };
3337
3342
  protoOf(UtilsBase).i39 = function () {
3338
- return this.n3h_1;
3343
+ return this.o3h_1;
3339
3344
  };
3340
3345
  function AppendOptimized$solve$slambda($request, $res, $list1, $list2, resultContinuation) {
3341
- this.a3i_1 = $request;
3342
- this.b3i_1 = $res;
3343
- this.c3i_1 = $list1;
3344
- this.d3i_1 = $list2;
3346
+ this.b3i_1 = $request;
3347
+ this.c3i_1 = $res;
3348
+ this.d3i_1 = $list1;
3349
+ this.e3i_1 = $list2;
3345
3350
  CoroutineImpl.call(this, resultContinuation);
3346
3351
  }
3347
3352
  protoOf(AppendOptimized$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3362,7 +3367,7 @@
3362
3367
  case 0:
3363
3368
  this.c8_1 = 2;
3364
3369
  this.b8_1 = 1;
3365
- suspendResult = this.e3i_1.pc(this.a3i_1.replyWith(Companion_getInstance_4().of(this.b3i_1, Companion_instance_6.ofList(plus(this.c3i_1.toList(), this.d3i_1.toList()))), VOID, []), this);
3370
+ suspendResult = this.f3i_1.pc(this.b3i_1.replyWith(Companion_getInstance_3().of(this.c3i_1, Companion_instance_6.ofList(plus(this.d3i_1.toList(), this.e3i_1.toList()))), VOID, []), this);
3366
3371
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
3367
3372
  return suspendResult;
3368
3373
  }
@@ -3385,8 +3390,8 @@
3385
3390
  while (true);
3386
3391
  };
3387
3392
  protoOf(AppendOptimized$solve$slambda).d2o = function ($this$sequence, completion) {
3388
- var i = new AppendOptimized$solve$slambda(this.a3i_1, this.b3i_1, this.c3i_1, this.d3i_1, completion);
3389
- i.e3i_1 = $this$sequence;
3393
+ var i = new AppendOptimized$solve$slambda(this.b3i_1, this.c3i_1, this.d3i_1, this.e3i_1, completion);
3394
+ i.f3i_1 = $this$sequence;
3390
3395
  return i;
3391
3396
  };
3392
3397
  function AppendOptimized$solve$slambda_0($request, $res, $list1, $list2, resultContinuation) {
@@ -3399,7 +3404,7 @@
3399
3404
  }
3400
3405
  function AppendOptimized() {
3401
3406
  AppendOptimized_instance = this;
3402
- this.o3h_1 = new Signature('append_fast', 3);
3407
+ this.p3h_1 = new Signature('append_fast', 3);
3403
3408
  }
3404
3409
  protoOf(AppendOptimized).g2e = function (request) {
3405
3410
  var list1 = request.arguments.w(0);
@@ -3437,7 +3442,7 @@
3437
3442
  };
3438
3443
  }
3439
3444
  function AssertAll$solve$slambda($request, resultContinuation) {
3440
- this.n3i_1 = $request;
3445
+ this.o3i_1 = $request;
3441
3446
  CoroutineImpl.call(this, resultContinuation);
3442
3447
  }
3443
3448
  protoOf(AssertAll$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3458,7 +3463,7 @@
3458
3463
  case 0:
3459
3464
  this.c8_1 = 2;
3460
3465
  this.b8_1 = 1;
3461
- suspendResult = this.o3i_1.pc(this.n3i_1.replyWithCondition(true, VOID, []), this);
3466
+ suspendResult = this.p3i_1.pc(this.o3i_1.replyWithCondition(true, VOID, []), this);
3462
3467
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
3463
3468
  return suspendResult;
3464
3469
  }
@@ -3481,8 +3486,8 @@
3481
3486
  while (true);
3482
3487
  };
3483
3488
  protoOf(AssertAll$solve$slambda).d2o = function ($this$sequence, completion) {
3484
- var i = new AssertAll$solve$slambda(this.n3i_1, completion);
3485
- i.o3i_1 = $this$sequence;
3489
+ var i = new AssertAll$solve$slambda(this.o3i_1, completion);
3490
+ i.p3i_1 = $this$sequence;
3486
3491
  return i;
3487
3492
  };
3488
3493
  function AssertAll$solve$slambda_0($request, resultContinuation) {
@@ -3495,7 +3500,7 @@
3495
3500
  }
3496
3501
  function AssertAll() {
3497
3502
  AssertAll_instance = this;
3498
- this.p3h_1 = new Signature('assert_all', 1);
3503
+ this.q3h_1 = new Signature('assert_all', 1);
3499
3504
  }
3500
3505
  protoOf(AssertAll).g2e = function (request) {
3501
3506
  var list = request.arguments.w(0);
@@ -3519,7 +3524,7 @@
3519
3524
  WithoutSideEffects_0.call(this, 'hash');
3520
3525
  }
3521
3526
  protoOf(ArgumentHash).a2m = function (_this__u8e3s4, first, second) {
3522
- return sequenceOf(Companion_getInstance_4().of(ensureNotNull(second.asVar()), Companion_getInstance_5().ofInteger(getStringHashCode(first.toString()))));
3527
+ return sequenceOf(Companion_getInstance_3().of(ensureNotNull(second.asVar()), Companion_getInstance_4().ofInteger(getStringHashCode(first.toString()))));
3523
3528
  };
3524
3529
  protoOf(ArgumentHash).v2d = function (_this__u8e3s4, first, second) {
3525
3530
  return this.a2m(_this__u8e3s4, first, second);
@@ -3531,9 +3536,9 @@
3531
3536
  return ArgumentHash_instance;
3532
3537
  }
3533
3538
  function Contains$solve$slambda($request, $list, $elem, resultContinuation) {
3534
- this.y3i_1 = $request;
3535
- this.z3i_1 = $list;
3536
- this.a3j_1 = $elem;
3539
+ this.z3i_1 = $request;
3540
+ this.a3j_1 = $list;
3541
+ this.b3j_1 = $elem;
3537
3542
  CoroutineImpl.call(this, resultContinuation);
3538
3543
  }
3539
3544
  protoOf(Contains$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3554,7 +3559,7 @@
3554
3559
  case 0:
3555
3560
  this.c8_1 = 2;
3556
3561
  this.b8_1 = 1;
3557
- var tmp0 = this.z3i_1.toList();
3562
+ var tmp0 = this.a3j_1.toList();
3558
3563
  var tmp$ret$0;
3559
3564
  l$ret$1: do {
3560
3565
  var tmp_0;
@@ -3570,7 +3575,7 @@
3570
3575
  var _iterator__ex2g4s = tmp0.p();
3571
3576
  while (_iterator__ex2g4s.s()) {
3572
3577
  var element = _iterator__ex2g4s.t();
3573
- if (Companion_getInstance_2().u1i().match(element, this.a3j_1)) {
3578
+ if (Companion_getInstance_1().u1i().match(element, this.b3j_1)) {
3574
3579
  tmp$ret$0 = true;
3575
3580
  break l$ret$1;
3576
3581
  }
@@ -3578,7 +3583,7 @@
3578
3583
  tmp$ret$0 = false;
3579
3584
  }
3580
3585
  while (false);
3581
- suspendResult = this.b3j_1.pc(this.y3i_1.replyWithCondition(tmp$ret$0, VOID, []), this);
3586
+ suspendResult = this.c3j_1.pc(this.z3i_1.replyWithCondition(tmp$ret$0, VOID, []), this);
3582
3587
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
3583
3588
  return suspendResult;
3584
3589
  }
@@ -3601,8 +3606,8 @@
3601
3606
  while (true);
3602
3607
  };
3603
3608
  protoOf(Contains$solve$slambda).d2o = function ($this$sequence, completion) {
3604
- var i = new Contains$solve$slambda(this.y3i_1, this.z3i_1, this.a3j_1, completion);
3605
- i.b3j_1 = $this$sequence;
3609
+ var i = new Contains$solve$slambda(this.z3i_1, this.a3j_1, this.b3j_1, completion);
3610
+ i.c3j_1 = $this$sequence;
3606
3611
  return i;
3607
3612
  };
3608
3613
  function Contains$solve$slambda_0($request, $list, $elem, resultContinuation) {
@@ -3615,7 +3620,7 @@
3615
3620
  }
3616
3621
  function Contains() {
3617
3622
  Contains_instance = this;
3618
- this.q3h_1 = new Signature('contains', 2);
3623
+ this.r3h_1 = new Signature('contains', 2);
3619
3624
  }
3620
3625
  protoOf(Contains).g2e = function (request) {
3621
3626
  var elem = request.arguments.w(0);
@@ -3635,9 +3640,9 @@
3635
3640
  return Contains_instance;
3636
3641
  }
3637
3642
  function ContainsAny$solve$slambda($request, $list, $elemList, resultContinuation) {
3638
- this.k3j_1 = $request;
3639
- this.l3j_1 = $list;
3640
- this.m3j_1 = $elemList;
3643
+ this.l3j_1 = $request;
3644
+ this.m3j_1 = $list;
3645
+ this.n3j_1 = $elemList;
3641
3646
  CoroutineImpl.call(this, resultContinuation);
3642
3647
  }
3643
3648
  protoOf(ContainsAny$solve$slambda).c2o = function ($this$sequence, $completion) {
@@ -3658,19 +3663,19 @@
3658
3663
  case 0:
3659
3664
  this.c8_1 = 2;
3660
3665
  this.b8_1 = 1;
3661
- var tmp0 = this.l3j_1.xs();
3666
+ var tmp0 = this.m3j_1.xs();
3662
3667
  var tmp$ret$2;
3663
3668
  l$ret$3: do {
3664
3669
  var _iterator__ex2g4s = tmp0.p();
3665
3670
  while (_iterator__ex2g4s.s()) {
3666
3671
  var element = _iterator__ex2g4s.t();
3667
- var tmp0_0 = this.m3j_1.xs();
3672
+ var tmp0_0 = this.n3j_1.xs();
3668
3673
  var tmp$ret$0;
3669
3674
  l$ret$1: do {
3670
3675
  var _iterator__ex2g4s_0 = tmp0_0.p();
3671
3676
  while (_iterator__ex2g4s_0.s()) {
3672
3677
  var element_0 = _iterator__ex2g4s_0.t();
3673
- if (Companion_getInstance_2().u1i().match(element, element_0)) {
3678
+ if (Companion_getInstance_1().u1i().match(element, element_0)) {
3674
3679
  tmp$ret$0 = true;
3675
3680
  break l$ret$1;
3676
3681
  }
@@ -3686,7 +3691,7 @@
3686
3691
  tmp$ret$2 = false;
3687
3692
  }
3688
3693
  while (false);
3689
- suspendResult = this.n3j_1.pc(this.k3j_1.replyWithCondition(tmp$ret$2, VOID, []), this);
3694
+ suspendResult = this.o3j_1.pc(this.l3j_1.replyWithCondition(tmp$ret$2, VOID, []), this);
3690
3695
  if (suspendResult === get_COROUTINE_SUSPENDED()) {
3691
3696
  return suspendResult;
3692
3697
  }
@@ -3709,8 +3714,8 @@
3709
3714
  while (true);
3710
3715
  };
3711
3716
  protoOf(ContainsAny$solve$slambda).d2o = function ($this$sequence, completion) {
3712
- var i = new ContainsAny$solve$slambda(this.k3j_1, this.l3j_1, this.m3j_1, completion);
3713
- i.n3j_1 = $this$sequence;
3717
+ var i = new ContainsAny$solve$slambda(this.l3j_1, this.m3j_1, this.n3j_1, completion);
3718
+ i.o3j_1 = $this$sequence;
3714
3719
  return i;
3715
3720
  };
3716
3721
  function ContainsAny$solve$slambda_0($request, $list, $elemList, resultContinuation) {
@@ -3723,7 +3728,7 @@
3723
3728
  }
3724
3729
  function ContainsAny() {
3725
3730
  ContainsAny_instance = this;
3726
- this.r3h_1 = new Signature('contains_any', 2);
3731
+ this.s3h_1 = new Signature('contains_any', 2);
3727
3732
  }
3728
3733
  protoOf(ContainsAny).g2e = function (request) {
3729
3734
  var elemList = request.arguments.w(0);
@@ -3748,13 +3753,38 @@
3748
3753
  function mineGraph(_this__u8e3s4, context) {
3749
3754
  // Inline function 'kotlin.let' call
3750
3755
  var it = mineArguments(_this__u8e3s4, context);
3751
- return Companion_instance_12.o3j(mineLabels(_this__u8e3s4, context, it), mineAttacks(_this__u8e3s4, context, it), mineSupports(_this__u8e3s4, context, it));
3756
+ return Companion_instance_12.p3j(mineLabels(_this__u8e3s4, context, it), mineAttacks(_this__u8e3s4, context, it), mineSupports(_this__u8e3s4, context, it));
3752
3757
  }
3753
3758
  function mineArguments(_this__u8e3s4, context) {
3754
3759
  return toList(logicProgramming(arguments$lambda(_this__u8e3s4, context)));
3755
3760
  }
3756
3761
  function mineLabels(_this__u8e3s4, context, arguments_0) {
3757
- return plus(plus(labels$checkFunctor(_this__u8e3s4, context, arguments_0, 'in'), labels$checkFunctor(_this__u8e3s4, context, arguments_0, 'out')), labels$checkFunctor(_this__u8e3s4, context, arguments_0, 'und'));
3762
+ var labels = plus(plus(labels$checkFunctor(_this__u8e3s4, context, 'in'), labels$checkFunctor(_this__u8e3s4, context, 'out')), labels$checkFunctor(_this__u8e3s4, context, 'und'));
3763
+ // Inline function 'kotlin.collections.map' call
3764
+ // Inline function 'kotlin.collections.mapTo' call
3765
+ var destination = ArrayList_init_$Create$(collectionSizeOrDefault(arguments_0, 10));
3766
+ var _iterator__ex2g4s = arguments_0.p();
3767
+ while (_iterator__ex2g4s.s()) {
3768
+ var item = _iterator__ex2g4s.t();
3769
+ var tmp$ret$1;
3770
+ $l$block: {
3771
+ // Inline function 'kotlin.collections.firstOrNull' call
3772
+ var _iterator__ex2g4s_0 = labels.p();
3773
+ while (_iterator__ex2g4s_0.s()) {
3774
+ var element = _iterator__ex2g4s_0.t();
3775
+ if (Companion_getInstance_1().u1i().match(item.a3k(), element.fc_1)) {
3776
+ tmp$ret$1 = element;
3777
+ break $l$block;
3778
+ }
3779
+ }
3780
+ tmp$ret$1 = null;
3781
+ }
3782
+ var tmp0_safe_receiver = tmp$ret$1;
3783
+ var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.gc_1;
3784
+ var tmp$ret$2 = new LabelledArgument(item, tmp1_elvis_lhs == null ? 'na' : tmp1_elvis_lhs);
3785
+ destination.m(tmp$ret$2);
3786
+ }
3787
+ return destination;
3758
3788
  }
3759
3789
  function mineAttacks(_this__u8e3s4, context, arguments_0) {
3760
3790
  if (arguments_0.j())
@@ -3767,8 +3797,8 @@
3767
3797
  function mineActiveGraph(_this__u8e3s4) {
3768
3798
  return logicProgramming(graph$lambda(_this__u8e3s4));
3769
3799
  }
3770
- function labels$checkFunctor($this_labels, $context, $arguments, functor) {
3771
- return logicProgramming(labels$checkFunctor$lambda($this_labels, $context, functor, $arguments));
3800
+ function labels$checkFunctor($this_labels, $context, functor) {
3801
+ return logicProgramming(labels$checkFunctor$lambda($this_labels, $context, functor));
3772
3802
  }
3773
3803
  function arguments$lambda$lambda(it) {
3774
3804
  return it.d1u();
@@ -3779,7 +3809,7 @@
3779
3809
  };
3780
3810
  }
3781
3811
  function arguments$lambda$lambda_1(solution) {
3782
- return Companion_instance_11.p3j(solution);
3812
+ return Companion_instance_11.b3k(solution);
3783
3813
  }
3784
3814
  function arguments$lambda$lambda_2(it) {
3785
3815
  return it.z3j_1.v();
@@ -3827,7 +3857,7 @@
3827
3857
  var _iterator__ex2g4s = tmp0.p();
3828
3858
  while (_iterator__ex2g4s.s()) {
3829
3859
  var element = _iterator__ex2g4s.t();
3830
- if (Companion_getInstance_2().u1i().match(element.a3k(), solution.fc_1)) {
3860
+ if (Companion_getInstance_1().u1i().match(element.a3k(), solution.fc_1)) {
3831
3861
  tmp$ret$1 = element;
3832
3862
  break $l$block;
3833
3863
  }
@@ -3842,7 +3872,7 @@
3842
3872
  var _iterator__ex2g4s_0 = tmp0_0.p();
3843
3873
  while (_iterator__ex2g4s_0.s()) {
3844
3874
  var element_0 = _iterator__ex2g4s_0.t();
3845
- if (Companion_getInstance_2().u1i().match(element_0.a3k(), solution.gc_1)) {
3875
+ if (Companion_getInstance_1().u1i().match(element_0.a3k(), solution.gc_1)) {
3846
3876
  tmp$ret$3 = element_0;
3847
3877
  break $l$block_0;
3848
3878
  }
@@ -3877,7 +3907,7 @@
3877
3907
  var _iterator__ex2g4s = tmp0.p();
3878
3908
  while (_iterator__ex2g4s.s()) {
3879
3909
  var element = _iterator__ex2g4s.t();
3880
- if (Companion_getInstance_2().u1i().match(element.a3k(), solution.gc_1)) {
3910
+ if (Companion_getInstance_1().u1i().match(element.a3k(), solution.gc_1)) {
3881
3911
  tmp$ret$1 = element;
3882
3912
  break $l$block;
3883
3913
  }
@@ -3893,7 +3923,7 @@
3893
3923
  var _iterator__ex2g4s_0 = tmp0_0.p();
3894
3924
  while (_iterator__ex2g4s_0.s()) {
3895
3925
  var element_0 = _iterator__ex2g4s_0.t();
3896
- if (Companion_getInstance_2().u1i().match(element_0.a3k(), solution.fc_1)) {
3926
+ if (Companion_getInstance_1().u1i().match(element_0.a3k(), solution.fc_1)) {
3897
3927
  tmp$ret$3 = element_0;
3898
3928
  break $l$block_0;
3899
3929
  }
@@ -3902,7 +3932,7 @@
3902
3932
  }
3903
3933
  // Inline function 'kotlin.also' call
3904
3934
  var this_0 = new Support(tmp$ret$3, argument);
3905
- argument.z3j_1.m(this_0.b3k_1);
3935
+ argument.z3j_1.m(this_0.c3k_1);
3906
3936
  return this_0;
3907
3937
  };
3908
3938
  }
@@ -3946,30 +3976,16 @@
3946
3976
  function labels$checkFunctor$lambda$lambda(it) {
3947
3977
  return it.d1u();
3948
3978
  }
3949
- function labels$checkFunctor$lambda$lambda_0($arguments, $this_logicProgramming, $functor) {
3950
- return function (res) {
3951
- var tmp0 = $arguments;
3952
- var tmp$ret$1;
3953
- $l$block: {
3954
- // Inline function 'kotlin.collections.first' call
3955
- var _iterator__ex2g4s = tmp0.p();
3956
- while (_iterator__ex2g4s.s()) {
3957
- var element = _iterator__ex2g4s.t();
3958
- if (Companion_getInstance_2().u1i().match(element.a3k(), ensureNotNull(res.v1s().h2($this_logicProgramming.d1g())))) {
3959
- tmp$ret$1 = element;
3960
- break $l$block;
3961
- }
3962
- }
3963
- throw NoSuchElementException_init_$Create$('Collection contains no element matching the predicate.');
3964
- }
3965
- return new LabelledArgument(tmp$ret$1, $functor);
3979
+ function labels$checkFunctor$lambda$lambda_0($this_logicProgramming, $functor) {
3980
+ return function (it) {
3981
+ return to(ensureNotNull(it.v1s().h2($this_logicProgramming.d1g())), $functor);
3966
3982
  };
3967
3983
  }
3968
- function labels$checkFunctor$lambda($this_labels, $context, $functor, $arguments) {
3984
+ function labels$checkFunctor$lambda($this_labels, $context, $functor) {
3969
3985
  return function ($this$logicProgramming) {
3970
3986
  var tmp = $this_labels.solve($this$logicProgramming.stringInvoke('context_check', $context, [$this$logicProgramming.stringInvoke($functor, $this$logicProgramming.d1g(), [])]));
3971
3987
  var tmp_0 = filter(tmp, labels$checkFunctor$lambda$lambda);
3972
- return toList(map(tmp_0, labels$checkFunctor$lambda$lambda_0($arguments, $this$logicProgramming, $functor)));
3988
+ return toList(map(tmp_0, labels$checkFunctor$lambda$lambda_0($this$logicProgramming, $functor)));
3973
3989
  };
3974
3990
  }
3975
3991
  function of$termAsList(t) {
@@ -4018,7 +4034,7 @@
4018
4034
  }
4019
4035
  function Companion_3() {
4020
4036
  }
4021
- protoOf(Companion_3).p3j = function (term) {
4037
+ protoOf(Companion_3).b3k = function (term) {
4022
4038
  // Inline function 'kotlin.let' call
4023
4039
  var it = of$termAsList(term);
4024
4040
  return new Argument(of$argRules(it), of$argTopRule(it), of$argConclusion(it), of$argGroundings(it), of$argDefeasibleRules(it), of$argDefeasiblePremises(it), of$argLastDefeasibleRules(it), term);
@@ -4052,7 +4068,7 @@
4052
4068
  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
4053
4069
  return tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
4054
4070
  };
4055
- protoOf(Argument).d3k = function () {
4071
+ protoOf(Argument).e3k = function () {
4056
4072
  var tmp = this.y3j_1 + ' : ';
4057
4073
  var tmp_0;
4058
4074
  if (this.r3j_1 === 'none') {
@@ -4083,7 +4099,7 @@
4083
4099
  };
4084
4100
  protoOf(Argument).a3k = function () {
4085
4101
  var tmp0_elvis_lhs = this.x3j_1;
4086
- return tmp0_elvis_lhs == null ? parseStruct(Companion_getInstance(), '[' + toString(this.q3j_1) + ', ' + this.r3j_1 + ', [' + this.s3j_1 + '], ' + toString(this.t3j_1) + ', [' + toString(this.w3j_1) + ', ' + toString(this.u3j_1) + ', ' + toString(this.v3j_1) + ']]') : tmp0_elvis_lhs;
4102
+ return tmp0_elvis_lhs == null ? parseStruct(Companion_getInstance_7(), '[' + toString(this.q3j_1) + ', ' + this.r3j_1 + ', [' + this.s3j_1 + '], ' + toString(this.t3j_1) + ', [' + toString(this.w3j_1) + ', ' + toString(this.u3j_1) + ', ' + toString(this.v3j_1) + ']]') : tmp0_elvis_lhs;
4087
4103
  };
4088
4104
  protoOf(Argument).toString = function () {
4089
4105
  return 'argument(' + this.a3k().toString() + ')';
@@ -4117,23 +4133,23 @@
4117
4133
  function Attack(attacker, target, type, on) {
4118
4134
  type = type === VOID ? null : type;
4119
4135
  on = on === VOID ? null : on;
4120
- this.e3k_1 = attacker;
4121
- this.f3k_1 = target;
4122
- this.g3k_1 = type;
4123
- this.h3k_1 = on;
4136
+ this.f3k_1 = attacker;
4137
+ this.g3k_1 = target;
4138
+ this.h3k_1 = type;
4139
+ this.i3k_1 = on;
4124
4140
  }
4125
4141
  protoOf(Attack).toString = function () {
4126
- var tmp = toString(toString$parse(this.g3k_1));
4127
- var tmp_0 = this.e3k_1.a3k().toString();
4128
- var tmp_1 = this.f3k_1.a3k().toString();
4129
- var tmp0_safe_receiver = this.h3k_1;
4142
+ var tmp = toString(toString$parse(this.h3k_1));
4143
+ var tmp_0 = this.f3k_1.a3k().toString();
4144
+ var tmp_1 = this.g3k_1.a3k().toString();
4145
+ var tmp0_safe_receiver = this.i3k_1;
4130
4146
  return 'attack(' + tmp + ', ' + tmp_0 + ', ' + tmp_1 + ', ' + toString(toString$parse(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a3k())) + ')';
4131
4147
  };
4132
4148
  protoOf(Attack).hashCode = function () {
4133
- var result = this.e3k_1.hashCode();
4134
- result = imul(result, 31) + this.f3k_1.hashCode() | 0;
4135
- result = imul(result, 31) + (this.g3k_1 == null ? 0 : getStringHashCode(this.g3k_1)) | 0;
4136
- result = imul(result, 31) + (this.h3k_1 == null ? 0 : this.h3k_1.hashCode()) | 0;
4149
+ var result = this.f3k_1.hashCode();
4150
+ result = imul(result, 31) + this.g3k_1.hashCode() | 0;
4151
+ result = imul(result, 31) + (this.h3k_1 == null ? 0 : getStringHashCode(this.h3k_1)) | 0;
4152
+ result = imul(result, 31) + (this.i3k_1 == null ? 0 : this.i3k_1.hashCode()) | 0;
4137
4153
  return result;
4138
4154
  };
4139
4155
  protoOf(Attack).equals = function (other) {
@@ -4141,31 +4157,31 @@
4141
4157
  return true;
4142
4158
  if (!(other instanceof Attack))
4143
4159
  return false;
4144
- if (!this.e3k_1.equals(other.e3k_1))
4145
- return false;
4146
4160
  if (!this.f3k_1.equals(other.f3k_1))
4147
4161
  return false;
4148
- if (!(this.g3k_1 == other.g3k_1))
4162
+ if (!this.g3k_1.equals(other.g3k_1))
4149
4163
  return false;
4150
- if (!equals(this.h3k_1, other.h3k_1))
4164
+ if (!(this.h3k_1 == other.h3k_1))
4165
+ return false;
4166
+ if (!equals(this.i3k_1, other.i3k_1))
4151
4167
  return false;
4152
4168
  return true;
4153
4169
  };
4154
4170
  function Companion_4() {
4155
4171
  }
4156
- protoOf(Companion_4).o3j = function (labellings, attacks, supports) {
4172
+ protoOf(Companion_4).p3j = function (labellings, attacks, supports) {
4157
4173
  // Inline function 'kotlin.collections.map' call
4158
4174
  // Inline function 'kotlin.collections.mapTo' call
4159
4175
  var destination = ArrayList_init_$Create$(collectionSizeOrDefault(labellings, 10));
4160
4176
  var _iterator__ex2g4s = labellings.p();
4161
4177
  while (_iterator__ex2g4s.s()) {
4162
4178
  var item = _iterator__ex2g4s.t();
4163
- var tmp$ret$0 = item.i3k_1;
4179
+ var tmp$ret$0 = item.j3k_1;
4164
4180
  destination.m(tmp$ret$0);
4165
4181
  }
4166
4182
  // Inline function 'kotlin.also' call
4167
4183
  var this_0 = new Graph(destination, attacks, supports);
4168
- this_0.n3k_1 = labellings;
4184
+ this_0.o3k_1 = labellings;
4169
4185
  return this_0;
4170
4186
  };
4171
4187
  var Companion_instance_12;
@@ -4173,18 +4189,18 @@
4173
4189
  return Companion_instance_12;
4174
4190
  }
4175
4191
  function Graph(arguments_0, attacks, supports) {
4176
- this.k3k_1 = arguments_0;
4177
- this.l3k_1 = attacks;
4178
- this.m3k_1 = supports;
4179
- this.n3k_1 = emptyList();
4192
+ this.l3k_1 = arguments_0;
4193
+ this.m3k_1 = attacks;
4194
+ this.n3k_1 = supports;
4195
+ this.o3k_1 = emptyList();
4180
4196
  }
4181
4197
  protoOf(Graph).toString = function () {
4182
- return 'Graph(arguments=' + toString(this.k3k_1) + ', attacks=' + toString(this.l3k_1) + ', supports=' + toString(this.m3k_1) + ')';
4198
+ return 'Graph(arguments=' + toString(this.l3k_1) + ', attacks=' + toString(this.m3k_1) + ', supports=' + toString(this.n3k_1) + ')';
4183
4199
  };
4184
4200
  protoOf(Graph).hashCode = function () {
4185
- var result = hashCode(this.k3k_1);
4186
- result = imul(result, 31) + hashCode(this.l3k_1) | 0;
4201
+ var result = hashCode(this.l3k_1);
4187
4202
  result = imul(result, 31) + hashCode(this.m3k_1) | 0;
4203
+ result = imul(result, 31) + hashCode(this.n3k_1) | 0;
4188
4204
  return result;
4189
4205
  };
4190
4206
  protoOf(Graph).equals = function (other) {
@@ -4192,24 +4208,24 @@
4192
4208
  return true;
4193
4209
  if (!(other instanceof Graph))
4194
4210
  return false;
4195
- if (!equals(this.k3k_1, other.k3k_1))
4196
- return false;
4197
4211
  if (!equals(this.l3k_1, other.l3k_1))
4198
4212
  return false;
4199
4213
  if (!equals(this.m3k_1, other.m3k_1))
4200
4214
  return false;
4215
+ if (!equals(this.n3k_1, other.n3k_1))
4216
+ return false;
4201
4217
  return true;
4202
4218
  };
4203
4219
  function LabelledArgument(argument, label) {
4204
- this.i3k_1 = argument;
4205
- this.j3k_1 = label;
4220
+ this.j3k_1 = argument;
4221
+ this.k3k_1 = label;
4206
4222
  }
4207
4223
  protoOf(LabelledArgument).toString = function () {
4208
- return this.j3k_1 + '(' + this.i3k_1.a3k().toString() + ')';
4224
+ return this.k3k_1 + '(' + this.j3k_1.a3k().toString() + ')';
4209
4225
  };
4210
4226
  protoOf(LabelledArgument).hashCode = function () {
4211
- var result = this.i3k_1.hashCode();
4212
- result = imul(result, 31) + getStringHashCode(this.j3k_1) | 0;
4227
+ var result = this.j3k_1.hashCode();
4228
+ result = imul(result, 31) + getStringHashCode(this.k3k_1) | 0;
4213
4229
  return result;
4214
4230
  };
4215
4231
  protoOf(LabelledArgument).equals = function (other) {
@@ -4217,22 +4233,22 @@
4217
4233
  return true;
4218
4234
  if (!(other instanceof LabelledArgument))
4219
4235
  return false;
4220
- if (!this.i3k_1.equals(other.i3k_1))
4236
+ if (!this.j3k_1.equals(other.j3k_1))
4221
4237
  return false;
4222
- if (!(this.j3k_1 === other.j3k_1))
4238
+ if (!(this.k3k_1 === other.k3k_1))
4223
4239
  return false;
4224
4240
  return true;
4225
4241
  };
4226
4242
  function Support(supporter, supported) {
4227
- this.b3k_1 = supporter;
4228
- this.c3k_1 = supported;
4243
+ this.c3k_1 = supporter;
4244
+ this.d3k_1 = supported;
4229
4245
  }
4230
4246
  protoOf(Support).toString = function () {
4231
- return 'support(' + this.b3k_1.a3k().toString() + ', ' + this.c3k_1.a3k().toString() + ')';
4247
+ return 'support(' + this.c3k_1.a3k().toString() + ', ' + this.d3k_1.a3k().toString() + ')';
4232
4248
  };
4233
4249
  protoOf(Support).hashCode = function () {
4234
- var result = this.b3k_1.hashCode();
4235
- result = imul(result, 31) + this.c3k_1.hashCode() | 0;
4250
+ var result = this.c3k_1.hashCode();
4251
+ result = imul(result, 31) + this.d3k_1.hashCode() | 0;
4236
4252
  return result;
4237
4253
  };
4238
4254
  protoOf(Support).equals = function (other) {
@@ -4240,18 +4256,18 @@
4240
4256
  return true;
4241
4257
  if (!(other instanceof Support))
4242
4258
  return false;
4243
- if (!this.b3k_1.equals(other.b3k_1))
4244
- return false;
4245
4259
  if (!this.c3k_1.equals(other.c3k_1))
4246
4260
  return false;
4261
+ if (!this.d3k_1.equals(other.d3k_1))
4262
+ return false;
4247
4263
  return true;
4248
4264
  };
4249
4265
  function EngineInterface() {
4250
4266
  EngineInterface_instance = this;
4251
4267
  EngineInterfaceBase.call(this);
4252
4268
  }
4253
- protoOf(EngineInterface).c3a = function () {
4254
- return ArgumentationEngineInterface_instance.r3k_1;
4269
+ protoOf(EngineInterface).b3a = function () {
4270
+ return ArgumentationEngineInterface_instance.s3k_1;
4255
4271
  };
4256
4272
  var EngineInterface_instance;
4257
4273
  function EngineInterface_getInstance() {
@@ -4263,8 +4279,8 @@
4263
4279
  AbstractMode_instance = this;
4264
4280
  AbstractModeBase.call(this);
4265
4281
  }
4266
- protoOf(AbstractMode).c3a = function () {
4267
- return AbstractMode_instance_0.v3k_1;
4282
+ protoOf(AbstractMode).b3a = function () {
4283
+ return AbstractMode_instance_0.w3k_1;
4268
4284
  };
4269
4285
  var AbstractMode_instance;
4270
4286
  function AbstractMode_getInstance() {
@@ -4276,8 +4292,8 @@
4276
4292
  ArgumentationGraphBuilder_instance = this;
4277
4293
  ArgumentationGraphBuilderBase.call(this);
4278
4294
  }
4279
- protoOf(ArgumentationGraphBuilder).c3a = function () {
4280
- return ArgumentationGraph_instance.z3k_1;
4295
+ protoOf(ArgumentationGraphBuilder).b3a = function () {
4296
+ return ArgumentationGraph_instance.a3l_1;
4281
4297
  };
4282
4298
  var ArgumentationGraphBuilder_instance;
4283
4299
  function ArgumentationGraphBuilder_getInstance() {
@@ -4289,8 +4305,8 @@
4289
4305
  AttackRestrictionHandler_instance = this;
4290
4306
  AttackRestrictionHandlerBase.call(this);
4291
4307
  }
4292
- protoOf(AttackRestrictionHandler).c3a = function () {
4293
- return AttackRestriction_instance.d3l_1;
4308
+ protoOf(AttackRestrictionHandler).b3a = function () {
4309
+ return AttackRestriction_instance.e3l_1;
4294
4310
  };
4295
4311
  var AttackRestrictionHandler_instance;
4296
4312
  function AttackRestrictionHandler_getInstance() {
@@ -4302,8 +4318,8 @@
4302
4318
  BpMetaGraphHandler_instance = this;
4303
4319
  BpMetaGraphHandlerBase.call(this);
4304
4320
  }
4305
- protoOf(BpMetaGraphHandler).c3a = function () {
4306
- return Bp_instance.h3l_1;
4321
+ protoOf(BpMetaGraphHandler).b3a = function () {
4322
+ return Bp_instance.i3l_1;
4307
4323
  };
4308
4324
  var BpMetaGraphHandler_instance;
4309
4325
  function BpMetaGraphHandler_getInstance() {
@@ -4315,8 +4331,8 @@
4315
4331
  DefeasiblePreferencesHandler_instance = this;
4316
4332
  DefeasiblePreferencesHandlerBase.call(this);
4317
4333
  }
4318
- protoOf(DefeasiblePreferencesHandler).c3a = function () {
4319
- return DefPreferences_instance.l3l_1;
4334
+ protoOf(DefeasiblePreferencesHandler).b3a = function () {
4335
+ return DefPreferences_instance.m3l_1;
4320
4336
  };
4321
4337
  var DefeasiblePreferencesHandler_instance;
4322
4338
  function DefeasiblePreferencesHandler_getInstance() {
@@ -4328,8 +4344,8 @@
4328
4344
  GenericDefeasiblePreferencesHandler_instance = this;
4329
4345
  GenericDefeasiblePreferencesHandlerBase.call(this);
4330
4346
  }
4331
- protoOf(GenericDefeasiblePreferencesHandler).c3a = function () {
4332
- return GenericDefPreferences_instance.p3l_1;
4347
+ protoOf(GenericDefeasiblePreferencesHandler).b3a = function () {
4348
+ return GenericDefPreferences_instance.q3l_1;
4333
4349
  };
4334
4350
  var GenericDefeasiblePreferencesHandler_instance;
4335
4351
  function GenericDefeasiblePreferencesHandler_getInstance() {
@@ -4341,8 +4357,8 @@
4341
4357
  StrictPreferencesHandler_instance = this;
4342
4358
  StrictPreferencesHandlerBase.call(this);
4343
4359
  }
4344
- protoOf(StrictPreferencesHandler).c3a = function () {
4345
- return Preferences_instance.t3l_1;
4360
+ protoOf(StrictPreferencesHandler).b3a = function () {
4361
+ return Preferences_instance.u3l_1;
4346
4362
  };
4347
4363
  var StrictPreferencesHandler_instance;
4348
4364
  function StrictPreferencesHandler_getInstance() {
@@ -4354,8 +4370,8 @@
4354
4370
  BpCompleteLabeller_instance = this;
4355
4371
  BpCompleteLabellerBase.call(this);
4356
4372
  }
4357
- protoOf(BpCompleteLabeller).c3a = function () {
4358
- return BpGroundedComplete_instance.x3l_1;
4373
+ protoOf(BpCompleteLabeller).b3a = function () {
4374
+ return BpGroundedComplete_instance.y3l_1;
4359
4375
  };
4360
4376
  var BpCompleteLabeller_instance;
4361
4377
  function BpCompleteLabeller_getInstance() {
@@ -4367,8 +4383,8 @@
4367
4383
  BpLabeller_instance = this;
4368
4384
  BpLabellerBase.call(this);
4369
4385
  }
4370
- protoOf(BpLabeller).c3a = function () {
4371
- return BpGrounded_instance.b3m_1;
4386
+ protoOf(BpLabeller).b3a = function () {
4387
+ return BpGrounded_instance.c3m_1;
4372
4388
  };
4373
4389
  var BpLabeller_instance;
4374
4390
  function BpLabeller_getInstance() {
@@ -4380,8 +4396,8 @@
4380
4396
  BpPartialLabeller_instance = this;
4381
4397
  BpPartialLabellerBase.call(this);
4382
4398
  }
4383
- protoOf(BpPartialLabeller).c3a = function () {
4384
- return BpGroundedPartial_instance.f3m_1;
4399
+ protoOf(BpPartialLabeller).b3a = function () {
4400
+ return BpGroundedPartial_instance.g3m_1;
4385
4401
  };
4386
4402
  var BpPartialLabeller_instance;
4387
4403
  function BpPartialLabeller_getInstance() {
@@ -4393,8 +4409,8 @@
4393
4409
  CompleteLabeller_instance = this;
4394
4410
  CompleteLabellerBase.call(this);
4395
4411
  }
4396
- protoOf(CompleteLabeller).c3a = function () {
4397
- return Complete_instance.j3m_1;
4412
+ protoOf(CompleteLabeller).b3a = function () {
4413
+ return Complete_instance.k3m_1;
4398
4414
  };
4399
4415
  var CompleteLabeller_instance;
4400
4416
  function CompleteLabeller_getInstance() {
@@ -4406,8 +4422,8 @@
4406
4422
  GroundedLabeller_instance = this;
4407
4423
  GroundedLabellerBase.call(this);
4408
4424
  }
4409
- protoOf(GroundedLabeller).c3a = function () {
4410
- return Grounded_instance.n3m_1;
4425
+ protoOf(GroundedLabeller).b3a = function () {
4426
+ return Grounded_instance.o3m_1;
4411
4427
  };
4412
4428
  var GroundedLabeller_instance;
4413
4429
  function GroundedLabeller_getInstance() {
@@ -4419,8 +4435,8 @@
4419
4435
  GroundedLabellerOptimized_instance = this;
4420
4436
  GroundedLabellerOptimizedBase.call(this);
4421
4437
  }
4422
- protoOf(GroundedLabellerOptimized).c3a = function () {
4423
- return GroundedOptimized_instance.r3m_1;
4438
+ protoOf(GroundedLabellerOptimized).b3a = function () {
4439
+ return GroundedOptimized_instance.s3m_1;
4424
4440
  };
4425
4441
  var GroundedLabellerOptimized_instance;
4426
4442
  function GroundedLabellerOptimized_getInstance() {
@@ -4432,8 +4448,8 @@
4432
4448
  StatementLabeller_instance = this;
4433
4449
  StatementLabellerBase.call(this);
4434
4450
  }
4435
- protoOf(StatementLabeller).c3a = function () {
4436
- return StatementLabelling_instance.v3m_1;
4451
+ protoOf(StatementLabeller).b3a = function () {
4452
+ return StatementLabelling_instance.w3m_1;
4437
4453
  };
4438
4454
  var StatementLabeller_instance;
4439
4455
  function StatementLabeller_getInstance() {
@@ -4445,8 +4461,8 @@
4445
4461
  RuleParser_instance = this;
4446
4462
  RuleParserBase.call(this);
4447
4463
  }
4448
- protoOf(RuleParser).c3a = function () {
4449
- return RuleTranslator_instance.z3m_1;
4464
+ protoOf(RuleParser).b3a = function () {
4465
+ return RuleTranslator_instance.a3n_1;
4450
4466
  };
4451
4467
  var RuleParser_instance;
4452
4468
  function RuleParser_getInstance() {
@@ -4455,147 +4471,147 @@
4455
4471
  return RuleParser_instance;
4456
4472
  }
4457
4473
  function AbstractMode_0() {
4458
- this.v3k_1 = 'computeGlobalAcceptance :-\n buildGraph,\n modifyGraph,\n buildArgumentLabelling,\n buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n computeGlobalAcceptance,\n utils::recoverGraph(Arguments, Attacks, Supports),\n utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n graphBuildMode(X),\n X:::buildArgumentationGraph.\nmodifyGraph :-\n findall(X, graphExtension(X), Ext),\n modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n modifyGraph(Ext),\n X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n argumentLabellingMode(X),\n X:::argumentLabelling.\nbuildStatementLabelling :-\n statementLabellingMode(X),\n X:::statementLabelling.';
4474
+ this.w3k_1 = 'computeGlobalAcceptance :-\n buildGraph,\n modifyGraph,\n buildArgumentLabelling,\n buildStatementLabelling.\ncomputeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]) :-\n computeGlobalAcceptance,\n utils::recoverGraph(Arguments, Attacks, Supports),\n utils::recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd),\n utils::recoverStatementLabelling(StatIn, StatOut, StatUnd).\nbuildGraph :-\n graphBuildMode(X),\n X:::buildArgumentationGraph.\nmodifyGraph :-\n findall(X, graphExtension(X), Ext),\n modifyGraph(Ext).\nmodifyGraph([]).\nmodifyGraph([X|Ext]) :-\n modifyGraph(Ext),\n X:::modifyArgumentationGraph.\nbuildArgumentLabelling :-\n argumentLabellingMode(X),\n X:::argumentLabelling.\nbuildStatementLabelling :-\n statementLabellingMode(X),\n X:::statementLabelling.';
4459
4475
  }
4460
4476
  var AbstractMode_instance_0;
4461
4477
  function AbstractMode_getInstance_0() {
4462
4478
  return AbstractMode_instance_0;
4463
4479
  }
4464
4480
  function ArgumentationEngineInterface() {
4465
- this.r3k_1 = 'argTuProlog.\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n context_reset,\n parser:::convertAllRules(_),\n abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n context_reset,\n parser:::convertAllRules(ArgRules),\n abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n debug::printArgumentationGraph(Arguments, Attacks, Supports),\n debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n context_reset,\n parser:::convertAllRules(_),\n structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n context_reset,\n parser:::convertAllRules(_),\n structured:::query(Goal, Res).\nbuildLabelSetsSilent :-\n context_reset,\n parser:::convertAllRules(ArgRules),\n abstract::computeGlobalAcceptance.';
4481
+ this.s3k_1 = 'argTuProlog.\nsolve :- buildLabelSetsSilent.\nsolve(Query) :- answerQuery(Query).\nsolve(Query, Res) :- answerQuery(Query, Res).\nbuildLabelSets([StatIn, StatOut, StatUnd], [ArgsIn, ArgsOut, ArgsUnd]) :-\n context_reset,\n parser:::convertAllRules(_),\n abstract::computeGlobalAcceptance(_, [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]).\nbuildLabelSets(StatIn, StatOut, StatUnd) :-\n buildLabelSets([StatIn, StatOut, StatUnd], _).\nbuildLabelSets :-\n context_reset,\n parser:::convertAllRules(ArgRules),\n abstract::computeGlobalAcceptance([Arguments, Attacks, Supports], [ArgsIn, ArgsOut, ArgsUnd], [StatIn, StatOut, StatUnd]),\n debug::printArgumentationGraph(Arguments, Attacks, Supports),\n debug::printArgumentLabelling([ArgsIn, ArgsOut, ArgsUnd]),\n debug::printStatementLabelling([StatIn, StatOut, StatUnd]).\nanswerQuery(Goal, Yes, No, Und) :-\n context_reset,\n parser:::convertAllRules(_),\n structured:::computeStatementAcceptance(Goal, Yes, No, Und).\nanswerQuery(Goal, Res) :-\n context_reset,\n parser:::convertAllRules(_),\n structured:::computeStatementAcceptance(Goal, Res).\nanswerQuery(Goal) :-\n context_reset,\n parser:::convertAllRules(_),\n structured:::computeStatementAcceptance(Goal).\nbuildLabelSetsSilent :-\n context_reset,\n parser:::convertAllRules(ArgRules),\n abstract::computeGlobalAcceptance.';
4466
4482
  }
4467
4483
  var ArgumentationEngineInterface_instance;
4468
4484
  function ArgumentationEngineInterface_getInstance() {
4469
4485
  return ArgumentationEngineInterface_instance;
4470
4486
  }
4471
4487
  function ArgumentationGraph() {
4472
- this.z3k_1 = 'buildArgumentationGraph :-\n buildArguments,\n findall(_, buildAdditionalArgument, _),\n buildAttacks.\nbuildAdditionalArgument :-\n metaConflicts,\n conf_arg(A, CArg),\n context_check(clause(conc(A), argument([R, T, C, B, I]))),\n \\+ filter_meta([R, T, C, B, I]),\n saveArgument(a, A, [[mc|R], T, C, B, I]),\n saveSupport(CArg, [[mc|R], T, C, B, I]),\n cloneSupport([R, T, C, B, I], [[mc|R], T, C, B, I]),\n fail.\nbuildAdditionalArgument.\ncloneSupport(Original, New) :-\n findall(_, (\n context_check(support(S, Original)),\n saveSupport(S, New)\n ), _).\nconf_arg([A], Arg) :-\n context_check(clause(conc([conflict(A, _, _)]), argument(Arg))).\nconf_arg([A], Arg) :-\n context_check(clause(conc([conflict(A, _)]), argument(Arg))).\nfilter_meta([Id, _, _, _, _]) :- metaConflicts, member(mc, Id).\nfilter_meta(_) :- \\+ metaConflicts.\nbuildArguments :-\n\tbuildArgumentsFromPremises,\n\tbuildArgumentsFromEmptyRules,\n\tfindall([RuleID, RuleBody, RuleHead], (\n\t parser::classic_rule(RuleID, RuleBody, RuleHead),\n\t \\+ emptyRule([RuleID, RuleBody, RuleHead])\n ), Rules),\n findall(X, context_check(newConc(a, [X])), N),\n\tbuildArgumentsFromRules(N, b, Rules, Rules, n).\nbuildArgumentsFromPremises :-\n findall(\n _,\n (\n parser::classic_rule(PremiseID, Premise),\n checkStrict(PremiseID, DefPrem),\n saveArgument(a, Premise, [[PremiseID], none, Premise, [], [[], [], DefPrem]])\n ),\n _\n ).\nbuildArgumentsFromEmptyRules :-\n findall(\n _,\n (\n emptyRule([RuleID, RulePrem, RuleHead]),\n checkStrict(RuleID, DefRule),\n saveArgument(a, RuleHead, [[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])\n ),\n _\n ).\nemptyRule([RuleID, Body, RuleHead]) :-\n parser::classic_rule(RuleID, Body, RuleHead),\n \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n ruleBodyIsSupported(RuleID, RuleHead, Body, Body, [[], [], [], []], _).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\nbuildArgumentsFromRules(_, _, Rules, [], n) :- !.\nbuildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\nbuildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n utils::contains_any(Body, N),\n findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n R \\== [],\n buildArgumentsFromRules(N, Tn, Rules, T, y), !.\nbuildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n buildArgumentsFromRules(N, Tn, Rules, T, X).\nbuildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n\tsaveArgument(Tn, RuleHead, Argument).\nclean(Tn, Rules) :-\n invert(Tn, Tx),\n context_retract(newConc(Tx, _)),\n findall(X, context_check(newConc(Tn, [X])), N),\n buildArgumentsFromRules(N, Tx, Rules, Rules, n).\ninvert(a, b).\ninvert(b, a).\ndefRules(Id, Def, Def) :- parser::check_strict(Id), !.\ndefRules(Id, Def, [Id|Def]).\nlastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\nlastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\nargumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n utils::sortDistinct(Prem, FPrem),\n defRules(RuleId, Def, NDef),\n utils::sortDistinct(NDef, FDef),\n lastDefRules(RuleId, LDef, NLDef),\n utils::sortDistinct(NLDef, FLDef).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n utils::appendLists(TAll, All),\n \\+ utils::contains(RuleID, All),\n utils::appendLists(TLDef, LDef),\n utils::appendLists(TDef, Def),\n utils::appendLists(TPrem, Prem),\n argumentInfo(RuleID, LDef, Def, Prem, Info),\n utils::sort([RuleID|All], Rules),\n Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n \\+ context_check(clause(conc(RuleHead), argument(Argument))).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n\t(callable(Check) -> call(Check); Check),\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n\truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n\tsaveSupport([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument).\nbuildAttacks :-\n\tfindall(_, buildDirectAttack, _),\n\tbuildTransitiveAttacks.\nbuildDirectAttack :-\n context_check(argument(A)),\n attack::findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tfilter_meta(B),\n\tA \\== B,\n attack::attacks(T, B, A),\n saveAttack(T, B, A, A),\n\tfail.\nbuildDirectAttack.\nbuildTransitiveAttacks :-\n\tcontext_check(attack(T, A, B, D)),\n\tcontext_check(support(B, C)),\n\tsaveAttack(T, A, C, D),!,\n buildTransitiveAttacks.\nbuildTransitiveAttacks.\nsaveArgument(T, Conclusion, Argument) :-\n \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n context_assert(newConc(T, Conclusion)),\n utils::hash(argument(Argument), Id),\n context_assert(argument(Argument)),\n context_assert(conc(Conclusion) :- argument(Argument)),\n context_assert(arg(Id) :- argument(Argument)).\nsaveAttack(T, A, C, D) :-\n \\+ context_check(attack(T, A, C, D)),\n context_assert(attack(T, A, C, D)),\n utils::hash(argument(A), IdA),\n utils::hash(argument(C), IdC),\n context_assert(att(IdA, IdC) :- attack(T, A, C, D)).\nsaveSupport(A, B) :-\n \\+ context_check(support(A, B)),\n context_assert(support(A, B)).\nremoveAttack(T, A, B, C) :-\n context_retract(attack(T, A, B, C)),\n utils::hash(argument(A), IdA),\n utils::hash(argument(B), IdB),\n context_retract(att(IdA, IdB) :- attack(T, A, B, C)).';
4488
+ this.a3l_1 = 'buildArgumentationGraph :-\n buildArguments,\n findall(_, buildAdditionalArgument, _),\n buildAttacks.\nbuildAdditionalArgument :-\n metaConflicts,\n conf_arg(A, CArg),\n context_check(clause(conc(A), argument([R, T, C, B, I]))),\n \\+ filter_meta([R, T, C, B, I]),\n saveArgument(a, A, [[mc|R], T, C, B, I]),\n saveSupport(CArg, [[mc|R], T, C, B, I]),\n cloneSupport([R, T, C, B, I], [[mc|R], T, C, B, I]),\n fail.\nbuildAdditionalArgument.\ncloneSupport(Original, New) :-\n findall(_, (\n context_check(support(S, Original)),\n saveSupport(S, New)\n ), _).\nconf_arg([A], Arg) :-\n context_check(clause(conc([conflict(A, _, _)]), argument(Arg))).\nconf_arg([A], Arg) :-\n context_check(clause(conc([conflict(A, _)]), argument(Arg))).\nfilter_meta([Id, _, _, _, _]) :- metaConflicts, member(mc, Id).\nfilter_meta(_) :- \\+ metaConflicts.\nbuildArguments :-\n\tbuildArgumentsFromPremises,\n\tbuildArgumentsFromEmptyRules,\n\tfindall([RuleID, RuleBody, RuleHead], (\n\t parser::classic_rule(RuleID, RuleBody, RuleHead),\n\t \\+ emptyRule([RuleID, RuleBody, RuleHead])\n ), Rules),\n findall(X, context_check(newConc(a, [X])), N),\n\tbuildArgumentsFromRules(N, b, Rules, Rules, n).\nbuildArgumentsFromPremises :-\n findall(\n _,\n (\n parser::classic_rule(PremiseID, Premise),\n checkStrict(PremiseID, DefPrem),\n saveArgument(a, Premise, [[PremiseID], none, Premise, [], [[], [], DefPrem]])\n ),\n _\n ).\nbuildArgumentsFromEmptyRules :-\n findall(\n _,\n (\n emptyRule([RuleID, RulePrem, RuleHead]),\n checkStrict(RuleID, DefRule),\n saveArgument(a, RuleHead, [[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])\n ),\n _\n ).\nemptyRule([RuleID, Body, RuleHead]) :-\n parser::classic_rule(RuleID, Body, RuleHead),\n \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n ruleBodyIsSupported(RuleID, RuleHead, Body, Body, [[], [], [], []], _).\ncheckStrict(Id, []) :- parser::check_strict(Id), !.\ncheckStrict(Id, [Id]).\nbuildArgumentsFromRules(_, _, Rules, [], n) :- !.\nbuildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\nbuildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n utils::contains_any(Body, N),\n findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n R \\== [],\n buildArgumentsFromRules(N, Tn, Rules, T, y), !.\nbuildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n buildArgumentsFromRules(N, Tn, Rules, T, X).\nbuildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n\tsaveArgument(Tn, RuleHead, Argument).\nclean(Tn, Rules) :-\n invert(Tn, Tx),\n context_retract(newConc(Tx, _)),\n findall(X, context_check(newConc(Tn, [X])), N),\n buildArgumentsFromRules(N, Tx, Rules, Rules, n).\ninvert(a, b).\ninvert(b, a).\ndefRules(Id, Def, Def) :- parser::check_strict(Id), !.\ndefRules(Id, Def, [Id|Def]).\nlastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\nlastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\nargumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n utils::sortDistinct(Prem, FPrem),\n defRules(RuleId, Def, NDef),\n utils::sortDistinct(NDef, FDef),\n lastDefRules(RuleId, LDef, NLDef),\n utils::sortDistinct(NLDef, FLDef).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n utils::appendLists(TAll, All),\n \\+ utils::contains(RuleID, All),\n utils::appendLists(TLDef, LDef),\n utils::appendLists(TDef, Def),\n utils::appendLists(TPrem, Prem),\n argumentInfo(RuleID, LDef, Def, Prem, Info),\n utils::sort([RuleID|All], Rules),\n Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n \\+ context_check(clause(conc(RuleHead), argument(Argument))).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n\t(callable(Check) -> call(Check); Check),\n\truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\nruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n\truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n\tsaveSupport([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument).\nbuildAttacks :-\n\tfindall(_, buildDirectAttack, _).\nbuildDirectAttack :-\n context_check(argument(A)),\n attack::findPossibleAttackers(A, BB),\n\tcontext_check(clause(conc(BB), argument(B))),\n\tfilter_meta(B),\n\tA \\== B,\n attack::attacks(T, B, A),\n saveAttack(T, B, A, A),\n findall(_, (\n expanded_support(A, C),\n saveAttack(T, B, C, A)\n ),_),\n\tfail.\nbuildDirectAttack.\nexpanded_support(A, B) :-\n context_check(support(A, B)).\nexpanded_support(A, C) :-\n context_check(support(A, B)),\n expanded_support(B, C).\nsaveArgument(T, Conclusion, Argument) :-\n \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n context_assert(newConc(T, Conclusion)),\n utils::hash(argument(Argument), Id),\n context_assert(argument(Argument)),\n context_assert(conc(Conclusion) :- argument(Argument)),\n context_assert(arg(Id) :- argument(Argument)).\nsaveAttack(T, A, C, D) :-\n \\+ context_check(attack(T, A, C, D)),\n context_assert(attack(T, A, C, D)),\n utils::hash(argument(A), IdA),\n utils::hash(argument(C), IdC),\n context_assert(att(IdA, IdC) :- attack(T, A, C, D)).\nsaveSupport(A, B) :-\n \\+ context_check(support(A, B)),\n context_assert(support(A, B)).\nremoveAttack(T, A, B, C) :-\n context_retract(attack(T, A, B, C)),\n utils::hash(argument(A), IdA),\n utils::hash(argument(B), IdB),\n context_retract(att(IdA, IdB) :- attack(T, A, B, C)).';
4473
4489
  }
4474
4490
  var ArgumentationGraph_instance;
4475
4491
  function ArgumentationGraph_getInstance() {
4476
4492
  return ArgumentationGraph_instance;
4477
4493
  }
4478
4494
  function AttackRelation() {
4479
- this.a3n_1 = 'attacks(rebut, A, B) :- rebuts(A, B), !.\nattacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\nattacks(undermine, A, B) :- undermines(A, B), !.\nattacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\nattacks(undercut, A, B) :- undercuts(A, B), !.\nexpanded_conflict(HeadA, HeadB) :-\n parser::classic_conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n parser::classic_conflict(HeadA, HeadB, Guard),\n (callable(Guard) -> call(Guard); Guard).\nrebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n\tRuleB \\== none,\n Info \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleA \\== none,\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n\tInfo \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\nundercuts([_, _, NegRuleB, _, _], [_, RuleB, _, _, [[RuleB], _, _]]) :-\n expanded_conflict(NegRuleB, [RuleB]).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n parser::classic_conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n parser::classic_conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n parser::classic_conflict(Conf, [RuleID], Guard).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n parser::classic_conflict(Conf, [RuleID]).';
4495
+ this.b3n_1 = 'attacks(rebut, A, B) :- rebuts(A, B), !.\nattacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\nattacks(undermine, A, B) :- undermines(A, B), !.\nattacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\nattacks(undercut, A, B) :- undercuts(A, B), !.\nexpanded_conflict(HeadA, HeadB) :-\n parser::classic_conflict(HeadA, HeadB).\nexpanded_conflict(HeadA, HeadB) :-\n parser::classic_conflict(HeadA, HeadB, Guard),\n (callable(Guard) -> call(Guard); Guard).\nrebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n\tRuleB \\== none,\n Info \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleA \\== none,\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n\tInfo \\== [[], [], []],\n\texpanded_conflict(RuleHeadA, RuleHeadB).\ncontraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n\tRuleB \\== none,\n\tutils::contains(~(RuleHeadA), Body).\nundercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\nundercuts([_, _, NegRuleB, _, _], [_, RuleB, _, _, [[RuleB], _, _]]) :-\n expanded_conflict(NegRuleB, [RuleB]).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n parser::classic_conflict(Conf, Head, Guard).\nfindPossibleAttackers([_, _, Head, _, _], Conf) :-\n parser::classic_conflict(Conf, Head).\nfindPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n member(~(Conf), Prem).\nfindPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n parser::classic_conflict(Conf, [RuleID], Guard).\nfindPossibleAttackers([_, RuleID, _, _, _], Conf) :-\n parser::classic_conflict(Conf, [RuleID]).';
4480
4496
  }
4481
4497
  var AttackRelation_instance;
4482
4498
  function AttackRelation_getInstance() {
4483
4499
  return AttackRelation_instance;
4484
4500
  }
4485
4501
  function AttackRestriction() {
4486
- this.d3l_1 = 'modifyArgumentationGraph :-\n findall(_, (\n context_check(attack(T, A, B, C)),\n checkRebutRestriction(T, A, B, C)\n ), _).\ncheckRebutRestriction(T, A, B, C) :-\n \\+ rebutRestriction(T, A, B, C),\n standard_af::removeAttack(T, A, B, C).\nrebutRestriction(rebut, _, _, C) :- restrict(C).\nrebutRestriction(undermine, _, _, C).\nrebutRestriction(contrary_rebut, _, _, _).\nrebutRestriction(contrary_undermine, _, _, _).\nrebutRestriction(undercut, _, _, _).\nrestrict([_, TopRule, _, _, [[TopRule], _, _]]) :- TopRule \\== none.';
4502
+ this.e3l_1 = 'modifyArgumentationGraph :-\n findall(_, (\n context_check(attack(T, A, B, C)),\n checkRebutRestriction(T, A, B, C)\n ), _).\ncheckRebutRestriction(T, A, B, C) :-\n \\+ rebutRestriction(T, A, B, C),\n standard_af::removeAttack(T, A, B, C).\nrebutRestriction(rebut, _, _, C) :- restrict(C).\nrebutRestriction(undermine, _, _, C).\nrebutRestriction(contrary_rebut, _, _, _).\nrebutRestriction(contrary_undermine, _, _, _).\nrebutRestriction(undercut, _, _, _).\nrestrict([_, TopRule, _, _, [[TopRule], _, _]]) :- TopRule \\== none.';
4487
4503
  }
4488
4504
  var AttackRestriction_instance;
4489
4505
  function AttackRestriction_getInstance() {
4490
4506
  return AttackRestriction_instance;
4491
4507
  }
4492
4508
  function Bp() {
4493
- this.h3l_1 = 'modifyArgumentationGraph :-\n findall(([Rules, Top, [bp(Checked)], G, I], [Z, P, [Y], GG, II]), (\n context_check(argument([Rules, Top, [bp(Checked)], G, I])),\n member(Y, [Checked]),\n context_check(argument([Z, P, [Y], GG, II]))\n ), TemplateBpPairs),\n checkBpArguments(TemplateBpPairs).\ncheckBpArguments([]).\ncheckBpArguments(TemplateBpPairs) :-\n createBpArguments(TemplateBpPairs, BpPairs),\n createBpAttacks(BpPairs).\ncreateBpArguments([], []).\ncreateBpArguments([(Original, [Z, P, Y, B, I])|Others], [(Conflict, [Z, P, Y, B, I])|BpPairs]) :-\n Conflict = [[artificial|Z], artificial, [-burdmet(Y)], [], [[artificial], [artificial], []]],\n standard_af::saveArgument(a, [-burdmet(Y)], Conflict),\n standard_af::saveSupport(Original, Conflict),\n liftBpAttacks(Original, Conflict),\n createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n findall(_, (\n context_check(attack(T, A, Template, O)),\n standard_af::saveAttack(T, A, BpArg, O)\n ), _).\ncreateBpAttacks(BpPairs) :-\n generateBpsEvaluationChain(BpPairs, OrderedBpPairs),\n evaluateBurdenedArgs(OrderedBpPairs).\ngenerateBpsEvaluationChain([], []).\ngenerateBpsEvaluationChain([BpPair|BpPairs], OrderedBpPairs) :-\n generateBpsEvaluationChain(BpPairs, TempOrderedBpPairs),\n insertBpPair(BpPair, TempOrderedBpPairs, OrderedBpPairs).\ninsertBpPair(BpPair, [], [BpPair]).\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(BpL, BurdenedL)|Return]) :-\n bp_grounded::argumentChain(BurdenedL, Burdened),\n insertBpPair((Bp, Burdened), Others, Return), !.\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(Bp, Burdened)|[(BpL, BurdenedL)|Others]]).\nevaluateBurdenedArgs([]).\nevaluateBurdenedArgs([(Bp, Burdened)|Others]) :-\n context_active(X),\n grounded:::argumentLabelling,\n statusToAttack((Bp, Burdened), attack(T, A, B, C)),\n context_checkout(X),\n standard_af::saveAttack(T, A, B, C),\n evaluateBurdenedArgs(Others).\nstatusToAttack((Bp, Burdened), attack(bprebut, Burdened, Bp, Bp)) :-\n context_check(in(Burdened)).\nstatusToAttack((Bp, Burdened), attack(bprebut, Bp, Burdened, Burdened)) :-\n \\+ context_check(in(Burdened)).';
4509
+ this.i3l_1 = 'modifyArgumentationGraph :-\n findall(([Rules, Top, [bp(Checked)], G, I], [Z, P, [Y], GG, II]), (\n context_check(argument([Rules, Top, [bp(Checked)], G, I])),\n member(Y, [Checked]),\n context_check(argument([Z, P, [Y], GG, II]))\n ), TemplateBpPairs),\n checkBpArguments(TemplateBpPairs).\ncheckBpArguments([]).\ncheckBpArguments(TemplateBpPairs) :-\n createBpArguments(TemplateBpPairs, BpPairs),\n createBpAttacks(BpPairs).\ncreateBpArguments([], []).\ncreateBpArguments([(Original, [Z, P, Y, B, I])|Others], [(Conflict, [Z, P, Y, B, I])|BpPairs]) :-\n Conflict = [[artificial|Z], artificial, [-burdmet(Y)], [], [[artificial], [artificial], []]],\n standard_af::saveArgument(a, [-burdmet(Y)], Conflict),\n standard_af::saveSupport(Original, Conflict),\n liftBpAttacks(Original, Conflict),\n createBpArguments(Others, BpPairs).\nliftBpAttacks(Template, BpArg) :-\n findall(_, (\n context_check(attack(T, A, Template, O)),\n standard_af::saveAttack(T, A, BpArg, O)\n ), _).\ncreateBpAttacks(BpPairs) :-\n generateBpsEvaluationChain(BpPairs, OrderedBpPairs),\n evaluateBurdenedArgs(OrderedBpPairs).\ngenerateBpsEvaluationChain([], []).\ngenerateBpsEvaluationChain([BpPair|BpPairs], OrderedBpPairs) :-\n generateBpsEvaluationChain(BpPairs, TempOrderedBpPairs),\n insertBpPair(BpPair, TempOrderedBpPairs, OrderedBpPairs).\ninsertBpPair(BpPair, [], [BpPair]).\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(BpL, BurdenedL)|Return]) :-\n bp_grounded::argumentChain(BurdenedL, Burdened),\n insertBpPair((Bp, Burdened), Others, Return), !.\ninsertBpPair((Bp, Burdened), [(BpL, BurdenedL)|Others], [(Bp, Burdened)|[(BpL, BurdenedL)|Others]]).\nevaluateBurdenedArgs([]).\nevaluateBurdenedArgs([(Bp, Burdened)|Others]) :-\n context_active(X),\n grounded:::argumentLabelling,\n statusToAttack((Bp, Burdened), attack(T, A, B, C)),\n context_checkout(X),\n standard_af::saveAttack(T, A, B, C),\n evaluateBurdenedArgs(Others).\nstatusToAttack((Bp, Burdened), attack(bprebut, Burdened, Bp, Bp)) :-\n context_check(in(Burdened)).\nstatusToAttack((Bp, Burdened), attack(bprebut, Bp, Burdened, Burdened)) :-\n \\+ context_check(in(Burdened)).';
4494
4510
  }
4495
4511
  var Bp_instance;
4496
4512
  function Bp_getInstance() {
4497
4513
  return Bp_instance;
4498
4514
  }
4499
4515
  function BpGrounded() {
4500
- this.b3m_1 = 'argumentLabelling :-\n reifyBurdenOfProofs,\n filterBpDefeats,\n findall(X, context_check(argument(X)), Arguments),\n bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n member(A, Arguments),\n grounded::allAttacksOUT(A), !,\n context_assert(in(A)),\n utils::subtract(Arguments, [A], NewArguments),\n bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n member(A, Arguments),\n \\+ isArgumentInBurdenOfProof(A),\n grounded::oneAttackIN(A), !,\n context_assert(out(A)),\n utils::subtract(Arguments, [A], NewArguments),\n bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n context_active(Branch),\n mostGroundedBpUnd(Arguments, A),\n context_branch(Branch, _),\n context_assert(out(A)),\n utils::subtract(Arguments, [A], NewArguments),\n bpLabelling(NewArguments).\nbpLabelling(Args) :-\n notLabelled(Args),\n findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n \\+ (\n member(A, Args),\n (\n context_check(in(A));\n context_check(out(A));\n context_check(und(A))\n )\n ).\nisInBurdenOfProof(Conclusion) :-\n context_check(reifiedBp(Literals)),\n member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n findall(_, (\n context_check(attack(T, A, B, C)),\n filterBpDefeat(T, A, B, C)\n ), _).\nfilterBpDefeat(T, B, A, C) :-\n (T = rebut; T = undermine),\n isArgumentInBurdenOfProof(B),\n \\+ superiority::superiorArgument(B, C),\n context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n member(Arg, Arguments),\n isArgumentInBurdenOfProof(Arg),\n \\+ (\n member(A, Arguments), Arg \\= A,\n isArgumentInBurdenOfProof(A),\n argumentChain(A, Arg)\n ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n A \\== B,\n context_check(attack(_, A, C, _)),\n argumentChain(C, B).\nreifyBurdenOfProofs :-\n findall(_, (\n context_check(abstractBp(AbstractBp)),\n fillTemplate(AbstractBp, R),\n \\+ context_check(reifiedBp(R)),\n context_assert(reifiedBp(R))\n ), _).\n/*\n Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n context_check(argument([_ , _, [P], _, _])),\n fillTemplate(T, R).';
4516
+ this.c3m_1 = 'argumentLabelling :-\n reifyBurdenOfProofs,\n filterBpDefeats,\n findall(X, context_check(argument(X)), Arguments),\n bpLabelling(Arguments).\nbpLabelling(Arguments) :-\n member(A, Arguments),\n grounded::allAttacksOUT(A), !,\n context_assert(in(A)),\n utils::subtract(Arguments, [A], NewArguments),\n bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n member(A, Arguments),\n \\+ isArgumentInBurdenOfProof(A),\n grounded::oneAttackIN(A), !,\n context_assert(out(A)),\n utils::subtract(Arguments, [A], NewArguments),\n bpLabelling(NewArguments).\nbpLabelling(Arguments) :-\n context_active(Branch),\n mostGroundedBpUnd(Arguments, A),\n context_branch(Branch, _),\n context_assert(out(A)),\n utils::subtract(Arguments, [A], NewArguments),\n bpLabelling(NewArguments).\nbpLabelling(Args) :-\n notLabelled(Args),\n findall(_, (member(A, Args), context_assert(und(A))), _).\nnotLabelled(Args) :-\n \\+ (\n member(A, Args),\n (\n context_check(in(A));\n context_check(out(A));\n context_check(und(A))\n )\n ).\nisInBurdenOfProof(Conclusion) :-\n context_check(reifiedBp(Literals)),\n member(Conclusion, Literals), !.\nisArgumentInBurdenOfProof([_, _, Conclusion, _, _]) :-\n isInBurdenOfProof(Conclusion).\nfilterBpDefeats :-\n findall(_, (\n context_check(attack(T, A, B, C)),\n filterBpDefeat(T, A, B, C)\n ), _).\nfilterBpDefeat(T, B, A, C) :-\n (T = rebut; T = undermine),\n isArgumentInBurdenOfProof(B),\n \\+ superiority::superiorArgument(B, C),\n context_retract(attack(T, B, A, C)).\nmostGroundedBpUnd(Arguments, Arg) :-\n member(Arg, Arguments),\n isArgumentInBurdenOfProof(Arg),\n \\+ (\n member(A, Arguments), Arg \\= A,\n isArgumentInBurdenOfProof(A),\n argumentChain(A, Arg)\n ).\nargumentChain(A, A) :- !.\nargumentChain(A, B) :-\n A \\== B,\n context_check(attack(_, A, C, _)),\n argumentChain(C, B).\nreifyBurdenOfProofs :-\n findall(_, (\n context_check(abstractBp(AbstractBp)),\n fillTemplate(AbstractBp, R),\n \\+ context_check(reifiedBp(R)),\n context_assert(reifiedBp(R))\n ), _).\n/*\n Fill the template (first parameter) using arguments conclusions\n*/\nfillTemplate([], []).\nfillTemplate([H|T], [[H]|R]) :-\n context_check(argument([_ , _, [P], _, _])),\n fillTemplate(T, R).';
4501
4517
  }
4502
4518
  var BpGrounded_instance;
4503
4519
  function BpGrounded_getInstance() {
4504
4520
  return BpGrounded_instance;
4505
4521
  }
4506
4522
  function BpGroundedComplete() {
4507
- this.x3l_1 = 'argumentLabelling :-\n bp_grounded::reifyBurdenOfProofs,\n findall(X, context_check(argument(X)), Arguments),\n completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n bp_grounded_partial::partialBpLabelling(Arguments), !,\n findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n grounded::groundedLabelling(NewArgs),\n findall(X, context_check(und(X)), LeftArguments),\n stopCondition(Stop, Arguments, LeftArguments),\n completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n utils::sort(Args, SortedArgs),\n utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
4523
+ this.y3l_1 = 'argumentLabelling :-\n bp_grounded::reifyBurdenOfProofs,\n findall(X, context_check(argument(X)), Arguments),\n completeBpLabelling(go, Arguments).\ncompleteBpLabelling(stop, _).\ncompleteBpLabelling(go, Arguments) :-\n bp_grounded_partial::partialBpLabelling(Arguments), !,\n findall(X, (context_check(und(X)), context_retract(und(X))), NewArgs),\n grounded::groundedLabelling(NewArgs),\n findall(X, context_check(und(X)), LeftArguments),\n stopCondition(Stop, Arguments, LeftArguments),\n completeBpLabelling(Stop, LeftArguments).\nstopCondition(stop, Args, NewArgs) :-\n utils::sort(Args, SortedArgs),\n utils::sort(NewArgs, SortedArgs), !.\nstopCondition(go, _, _) :- context_retract(und(_)).';
4508
4524
  }
4509
4525
  var BpGroundedComplete_instance;
4510
4526
  function BpGroundedComplete_getInstance() {
4511
4527
  return BpGroundedComplete_instance;
4512
4528
  }
4513
4529
  function BpGroundedPartial() {
4514
- this.f3m_1 = "argumentLabelling :-\n bp_grounded::reifyBurdenOfProofs,\n findall(X, context_check(argument(X)), Arguments),\n partialBpLabelling(Arguments), !.\npartialBpLabelling([]).\npartialBpLabelling(Arguments) :-\n mostGroundedArgument(Arguments, A),\n debug::writeDebug(['Evaluating ', A]),\n demonstration(Arguments, A, [A], Evaluated),\n utils::subtract(Arguments, [Evaluated], NewArgs),\n partialBpLabelling(NewArgs).\n/*\n (a.i) BP(neg(\u03C6)), and no argument B for neg(\u03C6) such that A < B is IN*, and no A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t superiorComplementArgument(A, B),\n\t context_check(in(B))\n\t),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t context_check(support(X, A)),\n\t context_check(out(X))\n\t),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.i)']),\n context_assert(in(A)).\n/*\n (a.ii) not BP(neg(\u03C6)) and every argument B for neg(\u03C6) such that B(not <)A is OUT*, and every A1,...An is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n superiorOrEqualComplementArgument(A, B),\n \\+ context_check(out(B))\n ),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n context_check(support(X, A)),\n \\+ context_check(in(X))\n ),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.ii)']),\n context_assert(in(A)).\n/*\n (b.i.1) BP(\u03C6) and exists an argument B for neg(\u03C6) such that B(not <)A is not OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorOrEqualComplementArgument(A, B),\n\t\\+ context_check(out(B)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.1)']),\n context_assert(out(A)).\n/*\n (b.i.2) BP(\u03C6) and exist one of A1,...An is not IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n \\+ context_check(in(X)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.2)']),\n context_assert(out(A)).\n/*\n (b.ii.1) not BP(\u03C6) and an argument B for neg(\u03C6) such A < B is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorComplementArgument(A, B),\n\tcontext_check(in(B)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.1)']),\n context_assert(out(A)).\n/*\n (b.ii.2) not BP(\u03C6) and one of A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n context_check(out(X)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.2)']),\n context_assert(out(A)).\n/*\n If above definitions do not apply try to decide on the arguments on which they depend\n*/\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n superiorComplementArgument(A, X),\n context_check(in(X))\n ),\n notEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n \\+ isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n superiorOrEqualComplementArgument(A, X),\n \\+ context_check(out(X))\n ),\n notEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\n/*\n (c) A is labelled UND* otherwise.\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tdebug::writeDebug(['Adding argument: ', A, ' to UND* (2.c)']),\n context_assert(und(A)).\nisComplementInBurdenOfProof(A) :-\n complement(A, Complement),\n bp_grounded::isInBurdenOfProof(Complement), !.\nmostGroundedArgument([], []).\nmostGroundedArgument([X], X).\nmostGroundedArgument([[L, _, _, _, _]|T], [L2, Q2, W2, B2, I2]) :-\n mostGroundedArgument(T, [L2, Q2, W2, B2, I2]),\n length(L, LN1),\n length(L2, LN2),\n LN1 > LN2, !.\nmostGroundedArgument([A|_], A).\n/*\n Get a conclusion complement\n*/\ncomplement([_, _, Conclusion, _, _], A) :-\n attack::expanded_conflict(Conclusion, A).\nnotEvaluatedSubArgument(Arguments, A, Resolving, B) :-\n context_check(support(B, A)),\n member(B, Arguments),\n \\+ member(B, Resolving).\nnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B) :-\n superiorComplementArgument(A, B),\n member(B, Arguments),\n \\+ member(B, Resolving).\nnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B) :-\n superiorOrEqualComplementArgument(A, B),\n member(B, Arguments),\n \\+ member(B, Resolving).\nsuperiorComplementArgument(A, [A, B, CA, BB, I]) :-\n complement(A, CA),\n context_check(argument([R, B, CA, BB, I])),\n superiority::superiorArgument([R, B, CA, BB, I], A).\nsuperiorOrEqualComplementArgument(A, [R, B, CA, BB, I]) :-\n complement(A, CA),\n context_check(argument([R, B, CA, BB, I])),\n \\+ superiority::superiorArgument(A, [R, B, CA, BB, I]).";
4530
+ this.g3m_1 = "argumentLabelling :-\n bp_grounded::reifyBurdenOfProofs,\n findall(X, context_check(argument(X)), Arguments),\n partialBpLabelling(Arguments), !.\npartialBpLabelling([]).\npartialBpLabelling(Arguments) :-\n mostGroundedArgument(Arguments, A),\n debug::writeDebug(['Evaluating ', A]),\n demonstration(Arguments, A, [A], Evaluated),\n utils::subtract(Arguments, [Evaluated], NewArgs),\n partialBpLabelling(NewArgs).\n/*\n (a.i) BP(neg(\u03C6)), and no argument B for neg(\u03C6) such that A < B is IN*, and no A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t superiorComplementArgument(A, B),\n\t context_check(in(B))\n\t),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n\t context_check(support(X, A)),\n\t context_check(out(X))\n\t),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.i)']),\n context_assert(in(A)).\n/*\n (a.ii) not BP(neg(\u03C6)) and every argument B for neg(\u03C6) such that B(not <)A is OUT*, and every A1,...An is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n superiorOrEqualComplementArgument(A, B),\n \\+ context_check(out(B))\n ),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\t\\+ (\n context_check(support(X, A)),\n \\+ context_check(in(X))\n ),\n\tdebug::writeDebug(['Adding argument: ', A, ' to IN* (2.a.ii)']),\n context_assert(in(A)).\n/*\n (b.i.1) BP(\u03C6) and exists an argument B for neg(\u03C6) such that B(not <)A is not OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorOrEqualComplementArgument(A, B),\n\t\\+ context_check(out(B)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.1)']),\n context_assert(out(A)).\n/*\n (b.i.2) BP(\u03C6) and exist one of A1,...An is not IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n \\+ context_check(in(X)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.i.2)']),\n context_assert(out(A)).\n/*\n (b.ii.1) not BP(\u03C6) and an argument B for neg(\u03C6) such A < B is IN*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\tsuperiorComplementArgument(A, B),\n\tcontext_check(in(B)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.1)']),\n context_assert(out(A)).\n/*\n (b.ii.2) not BP(\u03C6) and one of A1,...An is OUT*\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\t\\+ notEvaluatedSubArgument(Arguments, A, Resolving, _),\n\tcontext_check(support(X, A)),\n context_check(out(X)),\n debug::writeDebug(['Adding argument: ', A, ' to OUT* (2.b.ii.2)']),\n context_assert(out(A)).\n/*\n If above definitions do not apply try to decide on the arguments on which they depend\n*/\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tisComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n superiorComplementArgument(A, X),\n context_check(in(X))\n ),\n notEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n \\+ isComplementInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ isComplementInBurdenOfProof(A),\n\t\\+ notEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, _),\n\t\\+ (\n superiorOrEqualComplementArgument(A, X),\n \\+ context_check(out(X))\n ),\n notEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\tbp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\ndemonstration(Arguments, A, Resolving, Evaluated) :-\n\t\\+ bp_grounded::isArgumentInBurdenOfProof(A),\n\tnotEvaluatedSubArgument(Arguments, A, Resolving, B),\n demonstration(Arguments, B, [B|Resolving], Evaluated).\n/*\n (c) A is labelled UND* otherwise.\n*/\ndemonstration(Arguments, A, Resolving, A) :-\n\tdebug::writeDebug(['Adding argument: ', A, ' to UND* (2.c)']),\n context_assert(und(A)).\nisComplementInBurdenOfProof(A) :-\n complement(A, Complement),\n bp_grounded::isInBurdenOfProof(Complement), !.\nmostGroundedArgument([], []).\nmostGroundedArgument([X], X).\nmostGroundedArgument([[L, _, _, _, _]|T], [L2, Q2, W2, B2, I2]) :-\n mostGroundedArgument(T, [L2, Q2, W2, B2, I2]),\n length(L, LN1),\n length(L2, LN2),\n LN1 > LN2, !.\nmostGroundedArgument([A|_], A).\n/*\n Get a conclusion complement\n*/\ncomplement([_, _, Conclusion, _, _], A) :-\n attack::expanded_conflict(Conclusion, A).\nnotEvaluatedSubArgument(Arguments, A, Resolving, B) :-\n context_check(support(B, A)),\n member(B, Arguments),\n \\+ member(B, Resolving).\nnotEvaluatedSuperiorComplementArgument(Arguments, A, Resolving, B) :-\n superiorComplementArgument(A, B),\n member(B, Arguments),\n \\+ member(B, Resolving).\nnotEvaluatedSuperiorOrEqualComplementArgument(Arguments, A, Resolving, B) :-\n superiorOrEqualComplementArgument(A, B),\n member(B, Arguments),\n \\+ member(B, Resolving).\nsuperiorComplementArgument(A, [A, B, CA, BB, I]) :-\n complement(A, CA),\n context_check(argument([R, B, CA, BB, I])),\n superiority::superiorArgument([R, B, CA, BB, I], A).\nsuperiorOrEqualComplementArgument(A, [R, B, CA, BB, I]) :-\n complement(A, CA),\n context_check(argument([R, B, CA, BB, I])),\n \\+ superiority::superiorArgument(A, [R, B, CA, BB, I]).";
4515
4531
  }
4516
4532
  var BpGroundedPartial_instance;
4517
4533
  function BpGroundedPartial_getInstance() {
4518
4534
  return BpGroundedPartial_instance;
4519
4535
  }
4520
4536
  function Complete() {
4521
- this.j3m_1 = 'argumentLabelling :-\n cache_retract(complete(_,_,_)),\n grounded:::argumentLabelling,\n context_active(Branch),\n completeLabelling(Branch).\ncompleteLabelling(_) :-\n admissibleSet,\n utils::recoverArgumentLabelling(In, Out, Und),\n \\+ cache_check(complete(In, Out, Und)),\n cache_assert(complete(In, Out, Und)).\ncompleteLabelling(Branch) :-\n context_check(und(X)),\n context_branch(Branch, NewBranch),\n findall(Y, (context_check(und(Y)), Y \\= X), Arguments),\n context_retract(und(_)),\n context_assert(in(X)),\n grounded::groundedLabelling(Arguments),\n completeLabelling(NewBranch).\nadmissibleSet :-\n \\+ (context_check(in(H)), \\+ admissible(H)).\nadmissible(H) :-\n \\+ (\n context_check(attack(_, Attacker, H, _)),\n \\+ (\n context_check(attack(_, Defendant, Attacker, _)),\n context_check(in(Defendant))\n )\n ).';
4537
+ this.k3m_1 = 'argumentLabelling :-\n cache_retract(complete(_,_,_)),\n grounded:::argumentLabelling,\n context_active(Branch),\n completeLabelling(Branch).\ncompleteLabelling(_) :-\n admissibleSet,\n utils::recoverArgumentLabelling(In, Out, Und),\n \\+ cache_check(complete(In, Out, Und)),\n cache_assert(complete(In, Out, Und)).\ncompleteLabelling(Branch) :-\n context_check(und(X)),\n context_branch(Branch, NewBranch),\n findall(Y, (context_check(und(Y)), Y \\= X), Arguments),\n context_retract(und(_)),\n context_assert(in(X)),\n grounded::groundedLabelling(Arguments),\n completeLabelling(NewBranch).\nadmissibleSet :-\n \\+ (context_check(in(H)), \\+ admissible(H)).\nadmissible(H) :-\n \\+ (\n context_check(attack(_, Attacker, H, _)),\n \\+ (\n context_check(attack(_, Defendant, Attacker, _)),\n context_check(in(Defendant))\n )\n ).';
4522
4538
  }
4523
4539
  var Complete_instance;
4524
4540
  function Complete_getInstance() {
4525
4541
  return Complete_instance;
4526
4542
  }
4527
4543
  function Debug() {
4528
- this.b3n_1 = "printTheory(Rules) :-\n write('HERE THE THEORY:'),nl,\n findall(rule([Id, Body, Head]), member(rule([Id, Body, Head]), Rules), ListRules),\n utils::writeListNl(ListRules),\n findall(premise([A, B]), member(premise([A, B]), Rules), ListPremises),\n utils::writeListNl(ListPremises),\n findall(sup(A, B), member(sup(A, B), Rules), ListSups),\n utils::writeListNl(ListSups).\nprintArgumentationGraph(Arguments, Attacks, Supports) :-\n\tfindall(\n\t [IDPremises, '\\n', ' TOPRULE ', TopRule, '\\n', ' CONCLUSION ', RuleHead, '\\n', ' BODY ', Body, '\\n', ' INFO ', Info, '\\n'],\n\t member([IDPremises, TopRule, RuleHead, Body, Info], Arguments),\n ArgumentsToPrint\n ),\n findall((A1, ' SUPPORTS ', A2), member((A1, A2), Supports), SupportsToPrint),\n\tfindall((A1, ' ', T, ' ', A2, ' ON ', A3), member((T, A1, A2, A3), Attacks), AttacksToPrint),\n write('HERE THE GROUNDED SEMI-ABSTRACT ARGUMENTATION GRAPH'),nl,\n\tutils::writeListNl(ArgumentsToPrint),\n\tutils::writeListNl(SupportsToPrint),\n\tutils::writeListNl(AttacksToPrint).\nprintArgumentLabelling([IN, OUT, UND]) :-\n write('HERE THE ARGUMENTS LABELLED IN: '),nl,\n utils::writeListNl(IN),\n write('HERE THE ARGUMENTS LABELLED OUT: '),nl,\n utils::writeListNl(OUT),\n write('HERE THE ARGUMENTS LABELLED UND: '),nl,\n utils::writeListNl(UND).\nprintStatementLabelling([In, Ni, Und]) :-\n write('HERE THE STATEMENTS LABELLED IN: '),nl,\n utils::writeListNl(In),\n write('HERE THE STATEMENTS LABELLED NI: '),nl,\n utils::writeListNl(Ni),\n write('HERE THE STATEMENTS LABELLED UND: '),nl,\n utils::writeListNl(Und).\ndebug.\nwriteDebug(List) :-\n debug,\n utils::writeList(List).\nwriteDebug(_) :- \\+ debug.";
4544
+ this.c3n_1 = "printTheory(Rules) :-\n write('HERE THE THEORY:'),nl,\n findall(rule([Id, Body, Head]), member(rule([Id, Body, Head]), Rules), ListRules),\n utils::writeListNl(ListRules),\n findall(premise([A, B]), member(premise([A, B]), Rules), ListPremises),\n utils::writeListNl(ListPremises),\n findall(sup(A, B), member(sup(A, B), Rules), ListSups),\n utils::writeListNl(ListSups).\nprintArgumentationGraph(Arguments, Attacks, Supports) :-\n\tfindall(\n\t [IDPremises, '\\n', ' TOPRULE ', TopRule, '\\n', ' CONCLUSION ', RuleHead, '\\n', ' BODY ', Body, '\\n', ' INFO ', Info, '\\n'],\n\t member([IDPremises, TopRule, RuleHead, Body, Info], Arguments),\n ArgumentsToPrint\n ),\n findall((A1, ' SUPPORTS ', A2), member((A1, A2), Supports), SupportsToPrint),\n\tfindall((A1, ' ', T, ' ', A2, ' ON ', A3), member((T, A1, A2, A3), Attacks), AttacksToPrint),\n write('HERE THE GROUNDED SEMI-ABSTRACT ARGUMENTATION GRAPH'),nl,\n\tutils::writeListNl(ArgumentsToPrint),\n\tutils::writeListNl(SupportsToPrint),\n\tutils::writeListNl(AttacksToPrint).\nprintArgumentLabelling([IN, OUT, UND]) :-\n write('HERE THE ARGUMENTS LABELLED IN: '),nl,\n utils::writeListNl(IN),\n write('HERE THE ARGUMENTS LABELLED OUT: '),nl,\n utils::writeListNl(OUT),\n write('HERE THE ARGUMENTS LABELLED UND: '),nl,\n utils::writeListNl(UND).\nprintStatementLabelling([In, Ni, Und]) :-\n write('HERE THE STATEMENTS LABELLED IN: '),nl,\n utils::writeListNl(In),\n write('HERE THE STATEMENTS LABELLED NI: '),nl,\n utils::writeListNl(Ni),\n write('HERE THE STATEMENTS LABELLED UND: '),nl,\n utils::writeListNl(Und).\ndebug.\nwriteDebug(List) :-\n debug,\n utils::writeList(List).\nwriteDebug(_) :- \\+ debug.";
4529
4545
  }
4530
4546
  var Debug_instance;
4531
4547
  function Debug_getInstance() {
4532
4548
  return Debug_instance;
4533
4549
  }
4534
4550
  function DefPreferences() {
4535
- this.l3l_1 = 'modifyArgumentationGraph :-\n assertAllSup,\n findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n filterSupRelatedAttacks(Attacks, InvalidAttacks),\n convertAttacks(InvalidAttacks),\n buildPrefAttacks.\nassertAllSup :-\n context_retract(sup(_, _)),\n findall(_,\n (\n context_check(argument([_, _, [sup(RuleOne, RuleTwo)], _, _])),\n \\+ context_check(sup(RuleOne, RuleTwo)),\n context_assert(sup(RuleOne, RuleTwo))\n ),\n _).\nfilterSupRelatedAttacks([], []).\nfilterSupRelatedAttacks([(T, A, B, C)|Attacks], [(T, A, B, C)|Invalid]) :-\n invalid(T, A, B, C, _),\n filterSupRelatedAttacks(Attacks, Invalid), !.\nfilterSupRelatedAttacks([_|Attacks], Invalid) :-\n filterSupRelatedAttacks(Attacks, Invalid).\ninvalid(rebut, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\ninvalid(undermine, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\n/*\n* Translates the attack relations identified during the building phase.\n* Attack from A to B -> Argument [[], attack, Attack]\n* support(A, Argument)\n* attack(Argument, B)\n* If an Argument A built in this way attacks the argument B, and this one also attacks a third argument C\n* through the argument B1 we have to consider an attack from A to B1 (transitive attack)\n*/\nconvertAttacks(Attacks) :-\n conversion(Attacks),\n standard_af::buildTransitiveAttacks.\nconversion(List) :-\n member((T, A, B, B), List),\n generateDirectAttackArgument(T, A, B, B),\n fail.\nconversion(List) :-\n member((T, A, B, C), List),\n C \\= B,\n generateTransitiveAttackArgument(T, A, B, C),\n fail.\nconversion(_).\ngenerateTransitiveAttackArgument(T, A, B, C) :-\n context_check(argument([Id, attack, [attack(T, A, C, C)], G, I])),\n standard_af::saveAttack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C),\n standard_af::removeAttack(T, A, B, C).\ngenerateDirectAttackArgument(T, A, B, B) :-\n RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n standard_af::saveArgument(a, [attack(T, A, B, B)], RArgument),\n standard_af::saveSupport(A, RArgument),\n standard_af::saveAttack(T, RArgument, B, B),\n standard_af::removeAttack(T, A, B, B).\n/*\n* Computes the pref attack. If an Argument A has a conclusion in the form sup(a, b), we verify if\n* the attacks involving arguments built on the rules a or b are compatible with this preference.\n* If there are some contradictions we add an attack from the argument A towards the incompatible attack\n*/\nbuildPrefAttacks :-\n context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n invalid(T, A, B, C, SupSet),\n member(X, SupSet),\n context_check(argument([IdA, TRA, [X], GG, II])),\n standard_af::saveAttack(pref, [IdA, TRA, [X], GG, II], [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n fail.\nbuildPrefAttacks.';
4551
+ this.m3l_1 = 'modifyArgumentationGraph :-\n assertAllSup,\n findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n filterSupRelatedAttacks(Attacks, InvalidAttacks),\n convertAttacks(InvalidAttacks),\n buildPrefAttacks.\nassertAllSup :-\n context_retract(sup(_, _)),\n findall(_,\n (\n context_check(argument([_, _, [sup(RuleOne, RuleTwo)], _, _])),\n \\+ context_check(sup(RuleOne, RuleTwo)),\n context_assert(sup(RuleOne, RuleTwo))\n ),\n _).\nfilterSupRelatedAttacks([], []).\nfilterSupRelatedAttacks([(T, A, B, C)|Attacks], [(T, A, B, C)|Invalid]) :-\n invalid(T, A, B, C, _),\n filterSupRelatedAttacks(Attacks, Invalid), !.\nfilterSupRelatedAttacks([_|Attacks], Invalid) :-\n filterSupRelatedAttacks(Attacks, Invalid).\ninvalid(rebut, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\ninvalid(undermine, A, B, C, SupSet) :- superiority::superiorArgument(C, A, SupSet), !.\n/*\n* Translates the attack relations identified during the building phase.\n* Attack from A to B -> Argument [[], attack, Attack]\n* support(A, Argument)\n* attack(Argument, B)\n* If an Argument A built in this way attacks the argument B, and this one also attacks a third argument C\n* through the argument B1 we have to consider an attack from A to B1 (transitive attack)\n*/\nconvertAttacks(Attacks) :-\n conversion(Attacks),\n standard_af::buildTransitiveAttacks.\nconversion(List) :-\n member((T, A, B, B), List),\n generateDirectAttackArgument(T, A, B, B),\n fail.\nconversion(List) :-\n member((T, A, B, C), List),\n C \\= B,\n generateTransitiveAttackArgument(T, A, B, C),\n fail.\nconversion(_).\ngenerateTransitiveAttackArgument(T, A, B, C) :-\n context_check(argument([Id, attack, [attack(T, A, C, C)], G, I])),\n standard_af::saveAttack(T, [Id, attack, [attack(T, A, C, C)], G, I], B, C),\n standard_af::removeAttack(T, A, B, C).\ngenerateDirectAttackArgument(T, A, B, B) :-\n RArgument = [[attack], attack, [attack(T, A, B, B)], [], [[attack], [attack], []]],\n standard_af::saveArgument(a, [attack(T, A, B, B)], RArgument),\n standard_af::saveSupport(A, RArgument),\n standard_af::saveAttack(T, RArgument, B, B),\n standard_af::removeAttack(T, A, B, B).\n/*\n* Computes the pref attack. If an Argument A has a conclusion in the form sup(a, b), we verify if\n* the attacks involving arguments built on the rules a or b are compatible with this preference.\n* If there are some contradictions we add an attack from the argument A towards the incompatible attack\n*/\nbuildPrefAttacks :-\n context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n invalid(T, A, B, C, SupSet),\n member(X, SupSet),\n context_check(argument([IdA, TRA, [X], GG, II])),\n standard_af::saveAttack(pref, [IdA, TRA, [X], GG, II], [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n fail.\nbuildPrefAttacks.';
4536
4552
  }
4537
4553
  var DefPreferences_instance;
4538
4554
  function DefPreferences_getInstance() {
4539
4555
  return DefPreferences_instance;
4540
4556
  }
4541
4557
  function GenericDefPreferences() {
4542
- this.p3l_1 = 'modifyArgumentationGraph :-\n defeasiblePref::assertAllSup,\n findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n defeasiblePref::filterSupRelatedAttacks(Attacks, InvalidAttacks),\n defeasiblePref::convertAttacks(InvalidAttacks),\n buildPrefAttacks,\n standard_af::buildTransitiveAttacks.\nbuildPrefAttacks :-\n context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n defeasiblePref::invalid(T, A, B, C, SupSet),\n createSuperiorityArgument(SupSet, Arg),\n standard_af::saveAttack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n fail.\nbuildPrefAttacks.\ncreateSuperiorityArgument(SupSet, Argument) :-\n findall([Id, TR, [X], G, I], (\n member(X, SupSet),\n context_check(argument([Id, TR, [X], G, I]))\n ), SupportArguments),\n mergeIds(SupportArguments, MergedId),\n Argument = [MergedId, pref, [preference(SupSet)], [], [[pref], MergedId, []]],\n standard_af::saveArgument(a, [preference(SupSet)], Argument),\n findall(_, (\n member(A, SupportArguments),\n standard_af::saveSupport(A, Argument)\n ), _).\nmergeIds([], [pref]).\nmergeIds(Arguments, [pref|MergedId]) :-\n findall(Id, member([Id, _, _, _, _], Arguments), Res),\n utils::appendLists(Res, MergedId).';
4558
+ this.q3l_1 = 'modifyArgumentationGraph :-\n defeasiblePref::assertAllSup,\n findall((T, A, B, C), context_check(attack(T, A, B, C)), Attacks),\n defeasiblePref::filterSupRelatedAttacks(Attacks, InvalidAttacks),\n defeasiblePref::convertAttacks(InvalidAttacks),\n buildPrefAttacks,\n standard_af::buildTransitiveAttacks.\nbuildPrefAttacks :-\n context_check(argument([IdB, attack, [attack(T, A, B, C)], G, I])),\n defeasiblePref::invalid(T, A, B, C, SupSet),\n createSuperiorityArgument(SupSet, Arg),\n standard_af::saveAttack(pref, Arg, [IdB, attack, [attack(T, A, B, C)], G, I], [IdB, attack, [attack(T, A, B, C)], G, I]),\n fail.\nbuildPrefAttacks.\ncreateSuperiorityArgument(SupSet, Argument) :-\n findall([Id, TR, [X], G, I], (\n member(X, SupSet),\n context_check(argument([Id, TR, [X], G, I]))\n ), SupportArguments),\n mergeIds(SupportArguments, MergedId),\n Argument = [MergedId, pref, [preference(SupSet)], [], [[pref], MergedId, []]],\n standard_af::saveArgument(a, [preference(SupSet)], Argument),\n findall(_, (\n member(A, SupportArguments),\n standard_af::saveSupport(A, Argument)\n ), _).\nmergeIds([], [pref]).\nmergeIds(Arguments, [pref|MergedId]) :-\n findall(Id, member([Id, _, _, _, _], Arguments), Res),\n utils::appendLists(Res, MergedId).';
4543
4559
  }
4544
4560
  var GenericDefPreferences_instance;
4545
4561
  function GenericDefPreferences_getInstance() {
4546
4562
  return GenericDefPreferences_instance;
4547
4563
  }
4548
4564
  function Grounded() {
4549
- this.n3m_1 = 'argumentLabelling :-\n findall(X, context_check(argument(X)), Arguments),\n groundedLabelling(Arguments).\ngroundedLabelling(UND) :-\n member(A, UND),\n allAttacksOUT(A), !,\n utils::subtract(UND, [A], NewUND),\n context_assert(in(A)),\n groundedLabelling(NewUND).\ngroundedLabelling(UND) :-\n member(A, UND),\n oneAttackIN(A), !,\n utils::subtract(UND, [A], NewUND),\n context_assert(out(A)),\n groundedLabelling(NewUND).\ngroundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\nallAttacksOUT(A) :-\n \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\noneAttackIN(A) :-\n context_check(attack(_, B, A, _)),\n context_check(in(B)), !.\noneAttackIN(A) :-\n context_check(attack(_, A, B, _)),\n context_check(in(B)), !.';
4565
+ this.o3m_1 = 'argumentLabelling :-\n findall(X, context_check(argument(X)), Arguments),\n groundedLabelling(Arguments).\ngroundedLabelling(UND) :-\n member(A, UND),\n allAttacksOUT(A), !,\n utils::subtract(UND, [A], NewUND),\n context_assert(in(A)),\n groundedLabelling(NewUND).\ngroundedLabelling(UND) :-\n member(A, UND),\n oneAttackIN(A), !,\n utils::subtract(UND, [A], NewUND),\n context_assert(out(A)),\n groundedLabelling(NewUND).\ngroundedLabelling(Args) :- findall(_, (member(A, Args), context_assert(und(A))), _).\nallAttacksOUT(A) :-\n \\+ ( context_check(attack(_, B, A, _)), \\+ (context_check(out(B)))).\noneAttackIN(A) :-\n context_check(attack(_, B, A, _)),\n context_check(in(B)), !.\noneAttackIN(A) :-\n context_check(attack(_, A, B, _)),\n context_check(in(B)), !.';
4550
4566
  }
4551
4567
  var Grounded_instance;
4552
4568
  function Grounded_getInstance() {
4553
4569
  return Grounded_instance;
4554
4570
  }
4555
4571
  function GroundedOptimized() {
4556
- this.r3m_1 = 'argumentLabelling :-\n groundedLabelling.\ngroundedLabelling :-\n findall(t, evaluateIn, I),\n findall(t, evaluateOut, O),\n finalize(I, O).\nevaluateIn :-\n argument_to_evaluate(A, IdA),\n allAttacksOUT(IdA),\n context_assert(in(A)),\n context_assert(inId(IdA)).\nevaluateOut :-\n argument_to_evaluate(A, IdA),\n oneAttackIN(IdA),\n context_assert(out(A)),\n context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n argument_to_evaluate(A, _),\n context_assert(und(A)),\n fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n context_check(clause(arg(IdX), argument(X))),\n \\+ context_check(outId(IdX)),\n \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n context_check(clause(att(B, A), _)),\n context_check(inId(B)), !.\noneAttackIN(A) :-\n context_check(clause(att(A, B), _)),\n context_check(inId(B)), !.';
4572
+ this.s3m_1 = 'argumentLabelling :-\n groundedLabelling.\ngroundedLabelling :-\n findall(t, evaluateIn, I),\n findall(t, evaluateOut, O),\n finalize(I, O).\nevaluateIn :-\n argument_to_evaluate(A, IdA),\n allAttacksOUT(IdA),\n context_assert(in(A)),\n context_assert(inId(IdA)).\nevaluateOut :-\n argument_to_evaluate(A, IdA),\n oneAttackIN(IdA),\n context_assert(out(A)),\n context_assert(outId(IdA)).\nfinalize(I, O) :- I \\= [], !, groundedLabelling.\nfinalize(I, O) :- O \\= [], !, groundedLabelling.\nfinalize([], []) :-\n argument_to_evaluate(A, _),\n context_assert(und(A)),\n fail.\nfinalize(_, _).\nargument_to_evaluate(X, IdX) :-\n context_check(clause(arg(IdX), argument(X))),\n \\+ context_check(outId(IdX)),\n \\+ context_check(inId(IdX)).\nallAttacksOUT(A) :-\n \\+ ( context_check(clause(att(B, A), _)), \\+ (context_check(outId(B)))).\noneAttackIN(A) :-\n context_check(clause(att(B, A), _)),\n context_check(inId(B)), !.\noneAttackIN(A) :-\n context_check(clause(att(A, B), _)),\n context_check(inId(B)), !.';
4557
4573
  }
4558
4574
  var GroundedOptimized_instance;
4559
4575
  function GroundedOptimized_getInstance() {
4560
4576
  return GroundedOptimized_instance;
4561
4577
  }
4562
4578
  function Preferences() {
4563
- this.t3l_1 = 'modifyArgumentationGraph :-\n findall(_, (\n context_check(attack(T, A, B, C)),\n checkStandardPreference(T, A, B, C)\n ), _).\ncheckStandardPreference(T, A, B, C) :-\n \\+ standardPreferences(T, A, B, C),\n standard_af::removeAttack(T, A, B, C).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).';
4579
+ this.u3l_1 = 'modifyArgumentationGraph :-\n findall(_, (\n context_check(attack(T, A, B, C)),\n checkStandardPreference(T, A, B, C)\n ), _).\ncheckStandardPreference(T, A, B, C) :-\n \\+ standardPreferences(T, A, B, C),\n standard_af::removeAttack(T, A, B, C).\nstandardPreferences(rebut, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(undermine, A, _, C) :- \\+ superiority::superiorArgument(C, A).\nstandardPreferences(contrary_rebut, _, _, _).\nstandardPreferences(contrary_undermine, _, _, _).\nstandardPreferences(undercut, _, _, _).';
4564
4580
  }
4565
4581
  var Preferences_instance;
4566
4582
  function Preferences_getInstance() {
4567
4583
  return Preferences_instance;
4568
4584
  }
4569
4585
  function QueryMode_0() {
4570
- this.c3n_1 = 'computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n \\+ queryMode,\n abstract:::computeGlobalAcceptance,\n mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n queryMode,\n argumentLabellingMode(grounded),\n findall(_, query(Goal, _), _),\n (ambiguityBlocking ->\n statement_binary:::statementLabelling;\n statementLabellingMode(Y),\n Y:::statementLabelling\n ),\n mineResults(Goal, YesResult, NoResult, UndResult).\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n findall(Goal, context_check(statIn([Goal])), In),\n findall(Goal, context_check(statOut([Goal])), Out),\n findall(Goal, context_check(statUnd([Goal])), Und),\n utils::sort(In, YesResult),\n utils::sort(Out, NoResult),\n utils::sort(Und, UndResult).\nquery(Query, Res) :-\n buildArgument(Query, Argument),\n once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n findAttacker(Argument, QueryChain, Attacker, yes),\n once(defend(Attacker, [Argument|QueryChain], X)),\n X == yes,\n bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n findAttacker(Argument, QueryChain, Attacker, yes),\n once(defend(Attacker, [Argument|QueryChain], X)),\n X == und,\n ambiguityCheck(Argument, Attacker, Res),\n bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n attack::expanded_conflict(ConclusionA, ConclusionB).\nambiguityCheck(A, B, no) :- ambiguityBlocking,\n \\+ complementary(A, B),\n context_check(attack(direct, B, A, _)), !.\nambiguityCheck(_, _, und).\ndefend(Argument, QueryChain, und) :-\n findAttacker(Argument, QueryChain, Attacker, no),\n bufferResult(Argument, und), !.\ndefend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\nbufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\nbufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\nbufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\nbufferResult(_, _).\nfindAttacker(Target, QueryChain, Attacker, IsValid) :-\n attacker(Target, Attacker, Type),\n bufferAttacker(Attacker, Target, Type),\n detectCycle(Attacker, QueryChain, IsValid).\nbufferAttacker(Attacker, Target, Type) :-\n \\+ context_check(attack(Type, Attacker, Target, none)),\n context_assert(attack(Type, Attacker, Target, none)), !.\nbufferAttacker(_, _, _).\ndetectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\ndetectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n member(X, Rules),\n \\+ parser::strict(X),\n attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n member(X, Groundings),\n attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattackerOnRule(Rule, _, Argument, undercut) :-\n parser::undercut(Undercut, Rule),\n buildArgument(Undercut, Argument).\nattackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n \\+ parser::contrary(Term, _),\n \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n (graphExtension(rebutRestriction) ->\n (\n getSubArgument(Term, TargetRules, SubArgument),\n rebutRestriction(SubArgument)\n );\n true\n ),\n attack::expanded_conflict(Term, [X]),\n buildArgument(X, Attacker),\n (graphExtension(standardPref) ->\n (\n once(getSubArgument(Term, TargetRules, SubArgument)),\n \\+ superiorArgument(SubArgument, Attacker)\n );\n true\n ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n parser::contrary(Unless, X),\n buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n graphExtension(rebutRestriction),\n TopRule \\= none,\n rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n \\+ context_check(explored(Query)),\n findall(_, (\n buildSingleArgument([Query], Argument),\n context_assert(argument(Argument))\n ), _),\n context_assert(explored(Query)),\n fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n utils::deduplicate(DefRules, CDefRules),\n utils::deduplicate(DefPremises, CDefPremises),\n utils::deduplicate(Groundings, CGroundings),\n Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n parser::premise(Id, Conclusion),\n premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n parser::rule(Id, Premises, Conclusion),\n \\+ member(Id, Ids),\n buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n build([H], Ids, HConclusions, HRules),\n buildPremises(T, Ids, TConclusions, TRules),\n utils::appendLists([HConclusions, TConclusions], Conclusions),\n mergeRules(HRules, TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n utils::appendLists([HAR, TAR], AR),\n utils::appendLists([HLDR, TLDR], LDR),\n utils::appendLists([HDR, TDR], DR),\n utils::appendLists([HDP, TDP], DP).';
4586
+ this.d3n_1 = 'computeStatementAcceptance(Goal, Res) :-\n computeStatementAcceptance(Goal),\n mineResults(Goal, Res).\ncomputeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n computeStatementAcceptance(Goal),\n mineResults(Goal, YesResult, NoResult, UndResult).\ncomputeStatementAcceptance(Goal) :-\n \\+ queryMode,\n abstract:::computeGlobalAcceptance.\ncomputeStatementAcceptance(Goal) :-\n queryMode,\n findall(_, buildSubGraph(Goal, _), _),\n graphBuildMode(X),\n X:::buildAttacks,\n abstract:::modifyGraph,\n abstract:::buildArgumentLabelling,\n abstract:::buildStatementLabelling.\nmineResults(Goal, YesResult, NoResult, UndResult) :-\n findall(Goal, context_check(statIn([Goal])), In),\n findall(Goal, context_check(statOut([Goal])), Out),\n findall(Goal, context_check(statUnd([Goal])), Und),\n utils::sort(In, YesResult),\n utils::sort(Out, NoResult),\n utils::sort(Und, UndResult).\nmineResults(Goal, Result) :-\n findall(in(Goal), context_check(statIn([Goal])), In),\n findall(out(Goal), context_check(statOut([Goal])), Out),\n findall(und(Goal), context_check(statUnd([Goal])), Und),\n utils::appendLists([In, Out, Und], Result).\nground_vars(Term, Grounded) :-\n copy_term(Term, Copy),\n ground_vars(Copy, Grounded, 0, _).\nground_vars(Var, var, N0, N) :-\n var(Var), !,\n N is N0 + 1.\nground_vars(Term, Grounded, N0, N) :-\n compound(Term), !,\n Term =.. [F|Args],\n ground_vars_list(Args, GArgs, N0, N),\n Grounded =.. [F|GArgs].\nground_vars(Term, Term, N, N) :-\n atomic(Term).\nground_vars_list([], [], N, N).\nground_vars_list([X|Xs], [GX|GXs], N0, N) :-\n ground_vars(X, GX, N0, N1),\n ground_vars_list(Xs, GXs, N1, N).\nbuildSubGraph(Query, Argument) :-\n ground_vars(Query, Normalized),\n \\+ context_check(explored(Normalized)),\n findall(_, (\n findSingleArgument([Query], Argument, Support),\n saveArgument(query, [Query], Argument),\n saveSupports(Argument, Support),\n attack::findPossibleAttackers(Argument, [Conflict]),\n buildSubGraph(Conflict, _)\n ), _),\n context_assert(explored(Query)),\n fail.\nbuildSubGraph(Query, Argument) :- context_check(clause(conc([Query]), argument(Argument))).\nfindSingleArgument(Query, Argument, Support) :-\n findArgument(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises], Support),\n utils::deduplicate(DefRules, CDefRules),\n utils::deduplicate(DefPremises, CDefPremises),\n utils::deduplicate(Groundings, CGroundings),\n Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nfindArgument(Conclusion, _, [], [AllRules, TopRule, LastDefRules, DefRules, DefPremises], []) :-\n parser::premise(Id, Conclusion),\n premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]).\nfindArgument(Conclusion, Ids, Conclusions, [AllRules, TopRule, LastDefRules, DefRules, DefPremises], Support) :-\n parser::rule(Id, Premises, Conclusion),\n findPremises(Premises, [Id|Ids], Conclusions, ResRules, Support),\n ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]).\nfindPremises([], _, [], [[], [], [], []], []).\nfindPremises([H|T], Ids, TConclusions, TRules, TSupport) :-\n parser::prolog([H], Term), !,\n findPremises(T, Ids, TConclusions, TRules, TSupport),\n (callable(Term) -> call(Term); Term).\nfindPremises([H|T], Ids, [H|TConclusions], TRules, TSupport) :-\n parser::contrary([H], _), !,\n findPremises(T, Ids, TConclusions, TRules, TSupport).\nfindPremises([H|T], Ids, [PP|TConclusions], Rules, [[AllRules, P, [PP], HConclusions, [LastDefRules, DefRules, DefPremises]]|TSupport]) :-\n findPremises(T, Ids, TConclusions, TRules, TSupport),\n buildSubGraph(H, [AllRules, P, [PP], HConclusions, [LastDefRules, DefRules, DefPremises]]),\n mergeRules([AllRules, [], LastDefRules, DefRules, DefPremises], TRules, Rules).\npremiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ parser::check_strict(Id), !.\npremiseRules(Id, [[Id], none, [], [], []]) :- parser::check_strict(Id).\nruleRules(Id, [AllRules, _, DefRules, DefPremises],\n [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ parser::check_strict(Id), !.\nruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises],\n [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- parser::check_strict(Id).\nmergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]) :- !.\nmergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n utils::appendLists([HAR, TAR], AR),\n utils::appendLists([HLDR, TLDR], LDR),\n utils::appendLists([HDR, TDR], DR),\n utils::appendLists([HDP, TDP], DP).\nsaveArgument(T, Conclusion, Argument) :-\n \\+ context_check(clause(conc(Conclusion), argument(Argument))),\n context_assert(newConc(T, Conclusion)),\n utils::hash(argument(Argument), Id),\n context_assert(argument(Argument)),\n context_assert(conc(Conclusion) :- argument(Argument)),\n context_assert(arg(Id) :- argument(Argument)).\nsaveSupports(_, []).\nsaveSupports(A, [B|T]) :-\n saveSupport(B, A),\n saveSupports(A, T).\nsaveSupport(A, B) :-\n \\+ context_check(support(A, B)),\n context_assert(support(A, B)).\nquery(Query, Res) :-\n buildArgument(Query, Argument),\n once(defend(Argument, [], Res)).\nquery(Query, und) :- \\+ buildArgument(Query, _).\ndefend(Argument, _, no) :- context_check(out(Argument)).\ndefend(Argument, _, und) :- context_check(und(Argument)).\ndefend(Argument, _, yes) :- context_check(in(Argument)).\ndefend(Argument, QueryChain, no) :-\n findAttacker(Argument, QueryChain, Attacker, yes),\n once(defend(Attacker, [Argument|QueryChain], X)),\n X == yes,\n bufferResult(Argument, no), !.\ndefend(Argument, QueryChain, Res) :-\n findAttacker(Argument, QueryChain, Attacker, yes),\n once(defend(Attacker, [Argument|QueryChain], X)),\n X == und,\n ambiguityCheck(Argument, Attacker, Res),\n bufferResult(Argument, Res), !.\ncomplementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n attack::expanded_conflict(ConclusionA, ConclusionB).\nambiguityCheck(A, B, no) :- ambiguityBlocking,\n \\+ complementary(A, B),\n context_check(attack(direct, B, A, _)), !.\nambiguityCheck(_, _, und).\ndefend(Argument, QueryChain, und) :-\n findAttacker(Argument, QueryChain, Attacker, no),\n bufferResult(Argument, und), !.\ndefend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\nbufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\nbufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\nbufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\nbufferResult(_, _).\nfindAttacker(Target, QueryChain, Attacker, IsValid) :-\n attacker(Target, Attacker, Type),\n bufferAttacker(Attacker, Target, Type),\n detectCycle(Attacker, QueryChain, IsValid).\nbufferAttacker(Attacker, Target, Type) :-\n \\+ context_check(attack(Type, Attacker, Target, none)),\n context_assert(attack(Type, Attacker, Target, none)), !.\nbufferAttacker(_, _, _).\ndetectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\ndetectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n member(X, Rules),\n \\+ parser::strict(X),\n attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n member(X, Groundings),\n attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\nattackerOnRule(Rule, _, Argument, undercut) :-\n parser::undercut(Undercut, Rule),\n buildArgument(Undercut, Argument).\nattackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n \\+ parser::contrary(Term, _),\n \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n (graphExtension(rebutRestriction) ->\n (\n getSubArgument(Term, TargetRules, SubArgument),\n rebutRestriction(SubArgument)\n );\n true\n ),\n attack::expanded_conflict(Term, [X]),\n buildArgument(X, Attacker),\n (graphExtension(standardPref) ->\n (\n once(getSubArgument(Term, TargetRules, SubArgument)),\n \\+ superiorArgument(SubArgument, Attacker)\n );\n true\n ).\nattackerOnTerm(Unless, _, Attacker, contrary) :-\n parser::contrary(Unless, X),\n buildArgument(X, Attacker).\nstrict([_, _, _, _, [_, [], []]]).\nrebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n graphExtension(rebutRestriction).\nrebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n graphExtension(rebutRestriction),\n TopRule \\= none,\n rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\nrebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\nsuperiorArgument(SubArgument, Attacker) :-\n superiority::superiorArgument(SubArgument, Attacker).\ngetSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n context_check(clause(support(Term), argument([SubRules, SubTopRule, SubConclusion, SubGrounds, Info]))),\n contained(SubRules, Rules).\ncontained([], _).\ncontained([H|T], Target) :- member(H, Target), contained(T, Target).\nbuildArgument(Query, Argument) :-\n \\+ context_check(explored(Query)),\n findall(_, (\n buildSingleArgument([Query], Argument),\n context_assert(argument(Argument))\n ), _),\n context_assert(explored(Query)),\n fail.\nbuildArgument(Query, [R, T, [Query], B, I]) :- context_check(argument([R, T, [Query], B, I])).\nbuildSingleArgument(Query, Argument) :-\n build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n utils::deduplicate(DefRules, CDefRules),\n utils::deduplicate(DefPremises, CDefPremises),\n utils::deduplicate(Groundings, CGroundings),\n Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\nbuild(Check, _, [], []) :- parser::prolog(Check, Term), (callable(Term) -> call(Term); Term), !.\nbuild(Unless, _, [Unless], []) :- parser::contrary(Unless, _), !.\nbuild(Conclusion, _, [Conclusion], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n parser::premise(Id, Conclusion),\n premiseRules(Id, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion], [LastDefRules, DefRules, DefPremises]])).\nbuild(Conclusion, Ids, [Conclusion|Conclusions], [AllRules, TopRule, LastDefRules, DefRules, DefPremises]) :-\n parser::rule(Id, Premises, Conclusion),\n \\+ member(Id, Ids),\n buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n ruleRules(Id, ResRules, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n context_assert(support(Conclusion) :- argument([AllRules, TopRule, Conclusion, [Conclusion|Conclusions], [LastDefRules, DefRules, DefPremises]])).\nbuildPremises([], _, [], [[], [], [], []]).\nbuildPremises([H|T], Ids, Conclusions, Rules) :-\n build([H], Ids, HConclusions, HRules),\n buildPremises(T, Ids, TConclusions, TRules),\n utils::appendLists([HConclusions, TConclusions], Conclusions),\n mergeRules(HRules, TRules, Rules).';
4571
4587
  }
4572
4588
  var QueryMode_instance_0;
4573
4589
  function QueryMode_getInstance_0() {
4574
4590
  return QueryMode_instance_0;
4575
4591
  }
4576
4592
  function RuleTranslator() {
4577
- this.z3m_1 = "/*\n * Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n * or (Name : Effects) and then if:\n * - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n * - It is a bp rule, translate it to (abstractBp([Effects]))\n * During the process, clean them from the unallowed symbols (-, o, p).\n */\nconvertAllRules(ArgRules) :-\n defeasibleRules(DefeasibleRules),\n strictRules(StrictRules, RulesIds),\n ordinaryPremises(Premises),\n axiomPremises(Axioms, AxiomsIds),\n specialRules(SpecialRules),\n utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms], Rules),\n rule_to_clause(Rules, Clauses),\n findall(sup(X, Y), sup(X, Y), Sup),\n utils::appendLists([Clauses, AxiomsIds, RulesIds, Sup, SpecialRules], ArgRules),\n utils::assert_all(ArgRules), !.\ndefeasibleRules(DefeasibleRules) :-\n findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n prologDefeasibleRules(DefeasibleRulesNew),\n utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\nstrictRules(CtrRules, Ids) :-\n findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n prologStrictRules(StrictRulesNew),\n utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n transpose(StrictRules, StrictRules, CtrRules),\n extract_id(CtrRules, Ids).\nordinaryPremises(Premises) :-\n findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n prologPremises(PremisesNew),\n utils::append_fast(PremisesOld, PremisesNew, Premises).\naxiomPremises(Axioms, Ids) :-\n findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n prologAxioms(AxiomsNew),\n utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n extract_id(Axioms, Ids).\nspecialRules(SpecialRules) :-\n bpsNew(SpecialRules).\ntranspose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\ntranspose([], CtrRules, CtrRules).\ntranspose([H|T], TempCtrRules, CtrRules) :-\n transpose(T, TempCtrRules, CR),\n findall(TrH, transposition(H, TrH), Tran),\n mergeCtrRules(CR, Tran, CtrRules).\nmergeCtrRules(All, ToMerge, X) :-\n utils::append_fast(All, ToMerge, XT),\n deduplicate(XT, X).\ndeduplicate([], []).\ndeduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \ntransposition([Id, Prec, Effect], [Id, Prec, Effect]).\ntransposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n compound(Prec),\n tuple_to_list(Prec, LPrec),!,\n transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\ntransposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n \\+ compound(Prec),\n Prec \\== [],\n prologEscape(Prec),\n negate(Prec, XNegated),\n negate(Effect, EffectNegated),\n atom_concat(Id, '_i', NewId).\ntransposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\ntransposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n prologEscape(X),\n utils::append_fast(Skipped, T, CleanedPrec),\n negate(X, XNegated),\n negate(Effect, EffectNegated),\n list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n newIdentifier(Skipped, Id, NewId).\nnewIdentifier(List, OldId, NewId) :-\n modifier(List, Mod),\n atom_concat(OldId, Mod, NewId).\nmodifier([], '_i').\nmodifier([_|Tail], Index):-\n modifier(Tail, Index1),\n atom_concat(Index1, 'i', Index).\nnegate(X, Arg) :-\n functor(X, '-', _) -> (\n arg(1, X, Arg));\n functor(X, 'p', _) -> (\n arg(1, X, PX),\n (functor(PX, '-', _) -> (\n arg(1, PX, PNX),\n Arg = o(PNX)\n );\n Arg = o(-(PX))));\n Arg = -(X).\nprologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n/*\n * Standard rules (RuleName : Preconditions => Effects)\n * Special rules (RuleName : Effects)\n */\nconvertAllRules([], []).\nconvertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\nconvertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n/*\n * Convert the given rule to the standard format\n * Example:\n * r2: followedGuidelines(X), doctor(X) => -liable(X)\n * rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n */\nconvertRule(RuleName, Preconditions, Effects, rule(List)) :-\n tuple_to_list(Preconditions, Lprecond),\n tuple_to_list(Effects, Leffects),\n check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n/*\n * Convert the given special rule\n * Example:\n * bp(-liable(X)).\n * abastractBp([[neg, liable(X_e4149)]]).\n */\nconvertRule(bps, Effects, abstractBp(Checked)) :-\n functor(Effects, 'bp', _),\n Effects =.. L,\n removehead(L, LC),\n check_modifiers_in_list(effects, LC, Checked), !.\nconvertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n tuple_to_list(Effects, Leffects),\n check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n/*\n * Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n * raplace them with the assigned literal (neg, obl, perm)\n */\ncheck_modifiers_in_list(MODE, [], []) :- !.\ncheck_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\ncheck_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n check_modifiers_once(H, LH),\n check_modifiers_in_list(MODE, T, LT),\n utils::append_fast([LH], LT, L),\n R = L.\ncheck_modifiers_once(H, List) :- once(check_modifiers(H, List)).\ncheck_modifiers([], []).\ncheck_modifiers(H, List) :-\n functor(H, '-', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lobl),\n utils::append_fast([neg], Lobl, Lf),\n List = Lf);\n functor(H, 'o', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lobl),\n List = [obl|[Lobl]]);\n functor(H, 'p', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lper),\n List = [perm|[Lper]]);\n functor(H, '~', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lper),\n List = [unless|[Lper]]);\n functor(H, 'bp', _) -> (\n H =.. [_|Arg],\n check_modifiers_in_list(effects, Arg, Lper),\n List = [bp|[Lper]]);\n List = [H].\nlist_to_tuple([H], (H)) :- !.\nlist_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n/*\n * Replace all the occurences of a given element with the given argument\n */\nreplace(_, _, [],[]) :- !.\nreplace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\nreplace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\nflatten_first_level([X], X) :- !.\nflatten_first_level.\nremovehead([_|Tail], Tail).\nin(A, A) :- nonvar(A), A \\= (_ , _), !.\nin(A, (A, _)) :- !.\nin(A, (_ , Cs)) :- in(A, Cs).\ncheck_admissibility(preconditions, H, LH) :-\n \\+ defeasible_admissible(LH),\n throw(['Premise ', H, ' is not a well formed member of the argumentation language.']).\ncheck_admissibility(effects, H, LH) :-\n \\+ admissible(LH),\n throw(['Conclusion ', H, ' is not a well formed member of the argumentation language.']).\ncheck_admissibility(_, _, _).\ndefeasible_admissible([unless, Term]) :- admissible(Term).\ndefeasible_admissible(Term) :- admissible(Term).\nadmissible([neg, bp, Term]) :- admissible_terms_complete(Term).\nadmissible([bp, Term]) :- admissible_terms_complete(Term).\nadmissible([neg, Term]) :- admissible_term(Term).\nadmissible([obl, [Term]]) :- admissible_term(Term).\nadmissible([obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([perm, [Term]]) :- admissible_term(Term).\nadmissible([perm, [neg, Term]]) :- admissible_term(Term).\nadmissible([Term]) :- admissible_term(Term).\nadmissible_term(Term) :-\n atomic(Term),\n Term \\== neg,\n Term \\== obl,\n Term \\== perm,\n Term \\== unless,\n Term \\== bp.\nadmissible_term(Term) :- var(Term).\nadmissible_term(Term) :-\n compound(Term),\n \\+ functor(Term, 'o', _),\n \\+ functor(Term, 'p', _),\n \\+ functor(Term, '-', _),\n \\+ functor(Term, '~', _),\n \\+ functor(Term, 'bp', _),\n Term =.. [_|Args],\n admissible_terms(Args).\nadmissible_terms([]).\nadmissible_terms([H|T]) :-\n admissible_term(H),\n admissible_terms(T).\nadmissible_terms_complete([]).\nadmissible_terms_complete([H|T]) :-\n admissible(H),\n admissible_terms_complete(T).\nrule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\npremise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\ncheck_strict(Id) :- context_check(strict(Id)).\nprolog([prolog(Term)], Term).\ncontrary([~(Term)], Term).\nundercut(undercut(Rule), Rule).\nsuperiority(sup(Id1, Id2), Id1, Id2).\n/*\n * Convert the given tuple to list\n */\ntuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\ntuple_to_list((A,B),L) :-\n tuple_to_list(A, La),\n tuple_to_list(B, Lb),\n utils::append_fast(La, Lb,L).\nff([[]], []) :- !.\nff([[X]], [X]) :- !.\nff(X, X).\nclassic_rule(X, [applicable(X)|Y], Z) :- metaRules, !, rule(X, Y, Z).\nclassic_rule(X, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).\nclassic_conflict([A], [B], C) :- metaConflicts,\n context_check(clause(conc([conflict(A, B, C)]), _)).\nclassic_conflict([A], [B]) :- metaConflicts,\n context_check(clause(conc([conflict(A, B)]), _)).\nclassic_conflict(A, B, C) :-\n \\+ metaConflicts,\n member(conflict(A, B, C), [\n conflict([Atom], [-Atom], (Atom \\= -_)),\n conflict([-Atom], [Atom], true),\n conflict([o(Atom)], [o(-Atom)], (Atom \\= -_)), % O(x) <-> O(-x)\n conflict([o(-Atom)], [o(Atom)], true),\n conflict([p(Atom)], [o(-Atom)], (Atom \\= -_)), % P(x) <-> O(-x)\n conflict([o(-Atom)], [p(Atom)], true),\n conflict([o(Atom)], [p(-Atom)], (Atom \\= -_)), % O(x) <-> P(-x)\n conflict([p(-Atom)], [o(Atom)], true),\n conflict([o(Atom)], [-p(Atom)], true), % O(x) <-> O(-x) (-P(x))\n conflict([-p(Atom)], [o(Atom)], true),\n conflict([sup(X, Y)], [sup(Y, X)], true)\n ]).\nclassic_conflict(A, B, C) :-\n \\+ metaConflicts,\n conflict(A, B, C).\nclassic_conflict(A, B) :-\n \\+ metaConflicts,\n conflict(A, B).";
4593
+ this.a3n_1 = "/*\n * Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n * or (Name : Effects) and then if:\n * - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n * - It is a bp rule, translate it to (abstractBp([Effects]))\n * During the process, clean them from the unallowed symbols (-, o, p).\n */\nconvertAllRules(ArgRules) :-\n defeasibleRules(DefeasibleRules),\n strictRules(StrictRules, RulesIds),\n ordinaryPremises(Premises),\n axiomPremises(Axioms, AxiomsIds),\n specialRules(SpecialRules),\n utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms], Rules),\n rule_to_clause(Rules, Clauses),\n findall(sup(X, Y), sup(X, Y), Sup),\n utils::appendLists([Clauses, AxiomsIds, RulesIds, Sup, SpecialRules], ArgRules),\n utils::assert_all(ArgRules), !.\ndefeasibleRules(DefeasibleRules) :-\n findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n prologDefeasibleRules(DefeasibleRulesNew),\n utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\nstrictRules(CtrRules, Ids) :-\n findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n prologStrictRules(StrictRulesNew),\n utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n transpose(StrictRules, StrictRules, CtrRules),\n extract_id(CtrRules, Ids).\nordinaryPremises(Premises) :-\n findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n prologPremises(PremisesNew),\n utils::append_fast(PremisesOld, PremisesNew, Premises).\naxiomPremises(Axioms, Ids) :-\n findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n prologAxioms(AxiomsNew),\n utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n extract_id(Axioms, Ids).\nspecialRules(SpecialRules) :-\n bpsNew(SpecialRules).\ntranspose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\ntranspose([], CtrRules, CtrRules).\ntranspose([H|T], TempCtrRules, CtrRules) :-\n transpose(T, TempCtrRules, CR),\n findall(TrH, transposition(H, TrH), Tran),\n mergeCtrRules(CR, Tran, CtrRules).\nmergeCtrRules(All, ToMerge, X) :-\n utils::append_fast(All, ToMerge, XT),\n deduplicate(XT, X).\ndeduplicate([], []).\ndeduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \ntransposition([Id, Prec, Effect], [Id, Prec, Effect]).\ntransposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n compound(Prec),\n tuple_to_list(Prec, LPrec),!,\n transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\ntransposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n \\+ compound(Prec),\n Prec \\== [],\n prologEscape(Prec),\n negate(Prec, XNegated),\n negate(Effect, EffectNegated),\n atom_concat(Id, '_i', NewId).\ntransposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\ntransposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n prologEscape(X),\n utils::append_fast(Skipped, T, CleanedPrec),\n negate(X, XNegated),\n negate(Effect, EffectNegated),\n list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n newIdentifier(Skipped, Id, NewId).\nnewIdentifier(List, OldId, NewId) :-\n modifier(List, Mod),\n atom_concat(OldId, Mod, NewId).\nmodifier([], '_i').\nmodifier([_|Tail], Index):-\n modifier(Tail, Index1),\n atom_concat(Index1, 'i', Index).\nnegate(X, Arg) :-\n functor(X, '-', _) -> (\n arg(1, X, Arg));\n functor(X, 'p', _) -> (\n arg(1, X, PX),\n (functor(PX, '-', _) -> (\n arg(1, PX, PNX),\n Arg = o(PNX)\n );\n Arg = o(-(PX))));\n Arg = -(X).\nprologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n/*\n * Standard rules (RuleName : Preconditions => Effects)\n * Special rules (RuleName : Effects)\n */\nconvertAllRules([], []).\nconvertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\nconvertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n/*\n * Convert the given rule to the standard format\n * Example:\n * r2: followedGuidelines(X), doctor(X) => -liable(X)\n * rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n */\nconvertRule(RuleName, Preconditions, Effects, rule(List)) :-\n tuple_to_list(Preconditions, Lprecond),\n tuple_to_list(Effects, Leffects),\n check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n/*\n * Convert the given special rule\n * Example:\n * bp(-liable(X)).\n * abastractBp([[neg, liable(X_e4149)]]).\n */\nconvertRule(bps, Effects, abstractBp(Checked)) :-\n functor(Effects, 'bp', _),\n Effects =.. L,\n removehead(L, LC),\n check_modifiers_in_list(effects, LC, Checked), !.\nconvertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n tuple_to_list(Effects, Leffects),\n check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n/*\n * Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n * raplace them with the assigned literal (neg, obl, perm)\n */\ncheck_modifiers_in_list(MODE, [], []) :- !.\ncheck_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\ncheck_modifiers_in_list(MODE, [H|T], R) :- H \\== [],\n check_modifiers_once(H, LH),\n check_modifiers_in_list(MODE, T, LT),\n utils::append_fast([LH], LT, L),\n R = L.\ncheck_modifiers_once(H, List) :- once(check_modifiers(H, List)).\ncheck_modifiers([], []).\ncheck_modifiers(H, List) :-\n functor(H, '-', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lobl),\n utils::append_fast([neg], Lobl, Lf),\n List = Lf);\n functor(H, 'o', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lobl),\n List = [obl|[Lobl]]);\n functor(H, 'p', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lper),\n List = [perm|[Lper]]);\n functor(H, '~', _) -> (\n arg(1, H, Arg),\n check_modifiers_once(Arg, Lper),\n List = [unless|[Lper]]);\n functor(H, 'bp', _) -> (\n H =.. [_|Arg],\n check_modifiers_in_list(effects, Arg, Lper),\n List = [bp|[Lper]]);\n List = [H].\nlist_to_tuple([H], (H)) :- !.\nlist_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n/*\n * Replace all the occurences of a given element with the given argument\n */\nreplace(_, _, [],[]) :- !.\nreplace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\nreplace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\nflatten_first_level([X], X) :- !.\nflatten_first_level.\nremovehead([_|Tail], Tail).\nin(A, A) :- nonvar(A), A \\= (_ , _), !.\nin(A, (A, _)) :- !.\nin(A, (_ , Cs)) :- in(A, Cs).\ncheck_admissibility(preconditions, H, LH) :-\n \\+ defeasible_admissible(LH),\n throw(['Premise ', H, ' is not a well formed member of the argumentation language.']).\ncheck_admissibility(effects, H, LH) :-\n \\+ admissible(LH),\n throw(['Conclusion ', H, ' is not a well formed member of the argumentation language.']).\ncheck_admissibility(_, _, _).\ndefeasible_admissible([unless, Term]) :- admissible(Term).\ndefeasible_admissible(Term) :- admissible(Term).\nadmissible([neg, bp, Term]) :- admissible_terms_complete(Term).\nadmissible([bp, Term]) :- admissible_terms_complete(Term).\nadmissible([neg, Term]) :- admissible_term(Term).\nadmissible([obl, [Term]]) :- admissible_term(Term).\nadmissible([obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [Term]]) :- admissible_term(Term).\nadmissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\nadmissible([perm, [Term]]) :- admissible_term(Term).\nadmissible([perm, [neg, Term]]) :- admissible_term(Term).\nadmissible([Term]) :- admissible_term(Term).\nadmissible_term(Term) :-\n atomic(Term),\n Term \\== neg,\n Term \\== obl,\n Term \\== perm,\n Term \\== unless,\n Term \\== bp.\nadmissible_term(Term) :- var(Term).\nadmissible_term(Term) :-\n compound(Term),\n \\+ functor(Term, 'o', _),\n \\+ functor(Term, 'p', _),\n \\+ functor(Term, '-', _),\n \\+ functor(Term, '~', _),\n \\+ functor(Term, 'bp', _),\n Term =.. [_|Args],\n admissible_terms(Args).\nadmissible_terms([]).\nadmissible_terms([H|T]) :-\n admissible_term(H),\n admissible_terms(T).\nadmissible_terms_complete([]).\nadmissible_terms_complete([H|T]) :-\n admissible(H),\n admissible_terms_complete(T).\nrule(Id, PP, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Premises, Conclusion])), tuple_to_list(Premises, P), ff(P, PP).\npremise(Id, [Conclusion]) :- context_check(clause(rl(Conclusion), [Id, Conclusion])).\ncheck_strict(Id) :- context_check(strict(Id)).\nprolog([prolog(Term)], Term).\ncontrary([~(Term)], Term).\nundercut(undercut(Rule), Rule).\nsuperiority(sup(Id1, Id2), Id1, Id2).\n/*\n * Convert the given tuple to list\n */\ntuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\ntuple_to_list((A,B),L) :-\n tuple_to_list(A, La),\n tuple_to_list(B, Lb),\n utils::append_fast(La, Lb,L).\nff([[]], []) :- !.\nff([[X]], [X]) :- !.\nff(X, X).\nclassic_rule(X, [applicable(X)|Y], Z) :- metaRules, !, rule(X, Y, Z).\nclassic_rule(X, Y, Z) :- rule(X, Y, Z).\nclassic_rule(X, Y) :- premise(X, Y).\nclassic_conflict([A], [B], C) :- metaConflicts,\n context_check(clause(conc([conflict(A, B, C)]), _)).\nclassic_conflict([A], [B]) :- metaConflicts,\n context_check(clause(conc([conflict(A, B)]), _)).\nclassic_conflict(A, B, C) :-\n \\+ metaConflicts,\n member(conflict(A, B, C), [\n conflict([Atom], [-Atom], (Atom \\= -_)),\n conflict([-Atom], [Atom], true),\n conflict([o(Atom)], [o(-Atom)], (Atom \\= -_)), % O(x) <-> O(-x)\n conflict([o(-Atom)], [o(Atom)], true),\n conflict([p(Atom)], [o(-Atom)], (Atom \\= -_)), % P(x) <-> O(-x)\n conflict([o(-Atom)], [p(Atom)], true),\n conflict([o(Atom)], [p(-Atom)], (Atom \\= -_)), % O(x) <-> P(-x)\n conflict([p(-Atom)], [o(Atom)], true),\n conflict([o(Atom)], [-p(Atom)], true), % O(x) <-> O(-x) (-P(x))\n conflict([-p(Atom)], [o(Atom)], true),\n conflict([sup(X, Y)], [sup(Y, X)], true)\n ]).\nclassic_conflict(A, B, C) :-\n \\+ metaConflicts,\n conflict(A, B, C).\nclassic_conflict(A, B) :-\n \\+ metaConflicts,\n conflict(A, B).";
4578
4594
  }
4579
4595
  var RuleTranslator_instance;
4580
4596
  function RuleTranslator_getInstance() {
4581
4597
  return RuleTranslator_instance;
4582
4598
  }
4583
4599
  function StatementLabelling() {
4584
- this.v3m_1 = 'statementLabelling :-\n findall(_, (\n context_check(in([_, _, Conc, _, _])),\n \\+ context_check(statIn(Conc)),\n context_assert(statIn(Conc))\n ), _),\n findall(_, (\n context_check(out([_, _, Conc, _, _])),\n \\+ context_check(statIn(Conc)),\n \\+ context_check(statOut(Conc)),\n context_assert(statOut(Conc))\n ), _),\n findall(_, (\n context_check(und([_, _, Conc, _, _])),\n \\+ context_check(statIn(Conc)),\n \\+ context_check(statOut(Conc)),\n \\+ context_check(statUnd(Conc)),\n context_assert(statUnd(Conc))\n ), _).';
4600
+ this.w3m_1 = 'statementLabelling :-\n findall(_, (\n context_check(in([_, _, Conc, _, _])),\n \\+ context_check(statIn(Conc)),\n context_assert(statIn(Conc))\n ), _),\n findall(_, (\n context_check(out([_, _, Conc, _, _])),\n \\+ context_check(statIn(Conc)),\n \\+ context_check(statOut(Conc)),\n context_assert(statOut(Conc))\n ), _),\n findall(_, (\n context_check(und([_, _, Conc, _, _])),\n \\+ context_check(statIn(Conc)),\n \\+ context_check(statOut(Conc)),\n \\+ context_check(statUnd(Conc)),\n context_assert(statUnd(Conc))\n ), _).';
4585
4601
  }
4586
4602
  var StatementLabelling_instance;
4587
4603
  function StatementLabelling_getInstance() {
4588
4604
  return StatementLabelling_instance;
4589
4605
  }
4590
4606
  function SuperiorityRelation() {
4591
- this.d3n_1 = 'superiorArgument(A, B) :- superiorArgumentSupportBuffered(A, B, _).\nsuperiorArgument(A, B, SupSet) :- superiorArgumentSupportBuffered(A, B, SupSet).\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n context_check(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n context_check(superior(A, B, SupSet, false)),\n fail, !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n \\+ context_check(superior(A, B, _, _)),\n superiorArgumentSupport(A, B, SupSet),\n context_assert(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n \\+ cache_check(superior(A, B, _, _)),\n context_assert(superior(A, B, [], false)),\n fail, !.\nsuperiorArgumentSupport([_, _, _, _, [LastDefRulesA, DefRulesA, DefPremisesA]], [_, _, _, _, [LastDefRulesB, DefRulesB, DefPremisesB]], SupSet) :-\n\tsuperiorArgumentSupport(LastDefRulesA, DefRulesA, DefPremisesA, LastDefRulesB, DefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(LastDefRulesA, _, DefPremisesA, LastDefRulesB, _, DefPremisesB, SupSet) :-\n orderingPrinciple(last),\n\tsuperior(LastDefRulesA, DefPremisesA, LastDefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(_, DefRulesA, DefPremisesA, _, DefRulesB, DefPremisesB, SupSet) :-\n orderingPrinciple(weakest),\n\tsuperior(DefRulesA, DefPremisesA, DefRulesB, DefPremisesB, SupSet).\nsuperior([], PremisesA, [], PremisesB, SupSet) :-\n\tweaker(PremisesB, PremisesA, SupSet).\nsuperior(DefRulesA, _, DefRulesB, _, SupSet) :-\n\torderingPrinciple(last),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, [], DefRulesB, [], SupSet) :-\n\torderingPrinciple(weakest),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, PremisesA, DefRulesB, PremisesB, SupSet) :-\n\torderingPrinciple(weakest),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\t(PremisesA \\== []; PremisesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSetA),\n\tweaker(PremisesB, PremisesA, SupSetB),\n\tutils::appendLists([SupSetA, SupSetB], SupSet).\nweaker(RulesA, [], []) :-\n\tRulesA \\== [].\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(elitist),\n\tmember(Rule, RulesA),\n\tallStronger(Rule, RulesB, SupSet), !.\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(democrat),\n\tweakerDemo(RulesA, RulesB, SupSet).\nweaker(RulesA, RulesB, [sup(X, W)]) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(normal),\n\tmember(W, RulesA),\n\tmember(X, RulesB),\n\tcontext_check(sup(X, W)), !.\nweakerDemo([], _, []).\nweakerDemo([H|T], Rules, [Sup|SupSet]) :-\n\tsingleStronger(H, Rules, Sup),\n\tweakerDemo(T, Rules, SupSet).\nsingleStronger(Target, Rules, sup(Rule, Target)) :-\n\tmember(Rule, Rules),\n\tcontext_check(sup(Rule, Target)), !.\nallStronger(_, [], []).\nallStronger(Target, [Rule|Rules], [sup(Rule, Target)|SupSet]) :-\n\tcontext_check(sup(Rule, Target)),\n\tallStronger(Target, Rules, SupSet).';
4607
+ this.e3n_1 = 'superiorArgument(A, B) :- superiorArgumentSupportBuffered(A, B, _).\nsuperiorArgument(A, B, SupSet) :- superiorArgumentSupportBuffered(A, B, SupSet).\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n context_check(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n context_check(superior(A, B, SupSet, false)),\n fail, !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n \\+ context_check(superior(A, B, _, _)),\n superiorArgumentSupport(A, B, SupSet),\n context_assert(superior(A, B, SupSet, true)), !.\nsuperiorArgumentSupportBuffered(A, B, SupSet) :-\n \\+ cache_check(superior(A, B, _, _)),\n context_assert(superior(A, B, [], false)),\n fail, !.\nsuperiorArgumentSupport([_, _, _, _, [LastDefRulesA, DefRulesA, DefPremisesA]], [_, _, _, _, [LastDefRulesB, DefRulesB, DefPremisesB]], SupSet) :-\n\tsuperiorArgumentSupport(LastDefRulesA, DefRulesA, DefPremisesA, LastDefRulesB, DefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(LastDefRulesA, _, DefPremisesA, LastDefRulesB, _, DefPremisesB, SupSet) :-\n orderingPrinciple(last),\n\tsuperior(LastDefRulesA, DefPremisesA, LastDefRulesB, DefPremisesB, SupSet).\nsuperiorArgumentSupport(_, DefRulesA, DefPremisesA, _, DefRulesB, DefPremisesB, SupSet) :-\n orderingPrinciple(weakest),\n\tsuperior(DefRulesA, DefPremisesA, DefRulesB, DefPremisesB, SupSet).\nsuperior([], PremisesA, [], PremisesB, SupSet) :-\n\tweaker(PremisesB, PremisesA, SupSet).\nsuperior(DefRulesA, _, DefRulesB, _, SupSet) :-\n\torderingPrinciple(last),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, [], DefRulesB, [], SupSet) :-\n\torderingPrinciple(weakest),\n\tweaker(DefRulesB, DefRulesA, SupSet).\nsuperior(DefRulesA, PremisesA, DefRulesB, PremisesB, SupSet) :-\n\torderingPrinciple(weakest),\n\t(DefRulesA \\== []; DefRulesB \\== []),\n\t(PremisesA \\== []; PremisesB \\== []),\n\tweaker(DefRulesB, DefRulesA, SupSetA),\n\tweaker(PremisesB, PremisesA, SupSetB),\n\tutils::appendLists([SupSetA, SupSetB], SupSet).\nweaker(RulesA, [], []) :-\n\tRulesA \\== [].\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(elitist),\n\tmember(Rule, RulesA),\n\tallStronger(Rule, RulesB, SupSet), !.\nweaker(RulesA, RulesB, SupSet) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(democrat),\n\tweakerDemo(RulesA, RulesB, SupSet).\nweaker(RulesA, RulesB, [sup(X, W)]) :-\n\tRulesA \\== [],\n\tRulesB \\== [],\n\torderingComparator(normal),\n\tmember(W, RulesA),\n\tmember(X, RulesB),\n\tcontext_check(sup(X, W)), !.\nweakerDemo([], _, []).\nweakerDemo([H|T], Rules, [Sup|SupSet]) :-\n\tsingleStronger(H, Rules, Sup),\n\tweakerDemo(T, Rules, SupSet).\nsingleStronger(Target, Rules, sup(Rule, Target)) :-\n\tmember(Rule, Rules),\n\tcontext_check(sup(Rule, Target)), !.\nallStronger(_, [], []).\nallStronger(Target, [Rule|Rules], [sup(Rule, Target)|SupSet]) :-\n\tcontext_check(sup(Rule, Target)),\n\tallStronger(Target, Rules, SupSet).';
4592
4608
  }
4593
4609
  var SuperiorityRelation_instance;
4594
4610
  function SuperiorityRelation_getInstance() {
4595
4611
  return SuperiorityRelation_instance;
4596
4612
  }
4597
4613
  function Utils() {
4598
- this.e3n_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nsortDistinct(List, Sorted) :-\n deduplicate(List, Deduplicated),\n sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n List \\== [],\n setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n H @>= X,\n pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n X @> H,\n pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n member(Head, L2), !,\n subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n appendLists(T, AT),\n append_fast(H, AT, R).\nsearch(F, L, S) :-\n between(1, L, N),\n functor(S, F, N),\n call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n findall(X, context_check(argument(X)), TempArgs),\n findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n findall((A, B), context_check(support(A, B)), TempSupports),\n utils::sort(TempArgs, Args),\n utils::sort(TempAttacks, Attacks),\n utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n findall(X, context_check(in(X)), TempArgsIn),\n findall(X, context_check(out(X)), TempArgsOut),\n findall(X, context_check(und(X)), TempArgsUnd),\n utils::sort(TempArgsIn, ArgsIn),\n utils::sort(TempArgsOut, ArgsOut),\n utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n findall(X, context_check(statIn(X)), TempIn),\n findall(X, context_check(statOut(X)), TempOut),\n findall(X, context_check(statUnd(X)), TempUnd),\n utils::sort(TempIn, In),\n utils::sort(TempOut, Out),\n utils::sort(TempUnd, Und).';
4614
+ this.f3n_1 = 'writeList([]) :- nl.\nwriteList([X|Others]) :-\n\twrite(X),\n\twriteList(Others).\nwriteListNl([]).\nwriteListNl([X|Others]) :-\n\twrite(X),nl,\n\twriteListNl(Others).\nsortDistinct(List, Sorted) :-\n deduplicate(List, Deduplicated),\n sort(Deduplicated, Sorted).\ndeduplicate([], []).\ndeduplicate(List, Output) :-\n List \\== [],\n setof(X, member(X, List), Output).\nsort(List,Sorted) :- q_sort(List, [], Sorted).\nq_sort([], Acc, Acc).\nq_sort([H|T], Acc, Sorted) :-\n\tpivoting(H, T, L1, L2),\n\tq_sort(L1, Acc, Sorted1),\n\tq_sort(L2, [H|Sorted1], Sorted).\npivoting(H,[],[],[]).\npivoting(H, [X|T], [X|L], G) :-\n H @>= X,\n pivoting(H, T, L, G).\npivoting(H, [X|T], L, [X|G]) :-\n X @> H,\n pivoting(H, T, L, G).\nsubtract([], _, []).\nsubtract([Head|Tail], L2, L3) :-\n member(Head, L2), !,\n subtract(Tail, L2, L3).\nsubtract([Head|Tail1], L2, [Head|Tail3]) :-\n subtract(Tail1, L2, Tail3).\nisEmptyList([]).\nappendLists([], []).\nappendLists([H|T], R) :-\n appendLists(T, AT),\n append_fast(H, AT, R).\nsearch(F, L, S) :-\n between(1, L, N),\n functor(S, F, N),\n call(S).\nbetween(N, M, K) :- N < M, K = N.\nbetween(N, M, K) :- N == M, !, K = N.\nbetween(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\nrecoverGraph(Args, Attacks, Supports) :-\n findall(X, context_check(argument(X)), TempArgs),\n findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n findall((A, B), context_check(support(A, B)), TempSupports),\n utils::sort(TempArgs, Args),\n utils::sort(TempAttacks, Attacks),\n utils::sort(TempSupports, Supports).\nrecoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n findall(X, context_check(in(X)), TempArgsIn),\n findall(X, context_check(out(X)), TempArgsOut),\n findall(X, context_check(und(X)), TempArgsUnd),\n utils::sort(TempArgsIn, ArgsIn),\n utils::sort(TempArgsOut, ArgsOut),\n utils::sort(TempArgsUnd, ArgsUnd).\nrecoverStatementLabelling(In, Out, Und) :-\n findall(X, context_check(statIn(X)), TempIn),\n findall(X, context_check(statOut(X)), TempOut),\n findall(X, context_check(statUnd(X)), TempUnd),\n utils::sort(TempIn, In),\n utils::sort(TempOut, Out),\n utils::sort(TempUnd, Und).';
4599
4615
  }
4600
4616
  var Utils_instance;
4601
4617
  function Utils_getInstance() {
@@ -4605,8 +4621,8 @@
4605
4621
  StructuredMode_instance = this;
4606
4622
  StructuredModeBase.call(this);
4607
4623
  }
4608
- protoOf(StructuredMode).c3a = function () {
4609
- return QueryMode_instance_0.c3n_1;
4624
+ protoOf(StructuredMode).b3a = function () {
4625
+ return QueryMode_instance_0.d3n_1;
4610
4626
  };
4611
4627
  var StructuredMode_instance;
4612
4628
  function StructuredMode_getInstance() {
@@ -4618,8 +4634,8 @@
4618
4634
  AttackRelation_instance_0 = this;
4619
4635
  AttackRelationBase.call(this);
4620
4636
  }
4621
- protoOf(AttackRelation_0).c3a = function () {
4622
- return AttackRelation_instance.a3n_1;
4637
+ protoOf(AttackRelation_0).b3a = function () {
4638
+ return AttackRelation_instance.b3n_1;
4623
4639
  };
4624
4640
  var AttackRelation_instance_0;
4625
4641
  function AttackRelation_getInstance_0() {
@@ -4631,8 +4647,8 @@
4631
4647
  Debug_instance_0 = this;
4632
4648
  DebugBase.call(this);
4633
4649
  }
4634
- protoOf(Debug_0).c3a = function () {
4635
- return Debug_instance.b3n_1;
4650
+ protoOf(Debug_0).b3a = function () {
4651
+ return Debug_instance.c3n_1;
4636
4652
  };
4637
4653
  var Debug_instance_0;
4638
4654
  function Debug_getInstance_0() {
@@ -4644,8 +4660,8 @@
4644
4660
  SuperiorityRelation_instance_0 = this;
4645
4661
  SuperiorityRelationBase.call(this);
4646
4662
  }
4647
- protoOf(SuperiorityRelation_0).c3a = function () {
4648
- return SuperiorityRelation_instance.d3n_1;
4663
+ protoOf(SuperiorityRelation_0).b3a = function () {
4664
+ return SuperiorityRelation_instance.e3n_1;
4649
4665
  };
4650
4666
  var SuperiorityRelation_instance_0;
4651
4667
  function SuperiorityRelation_getInstance_0() {
@@ -4657,8 +4673,8 @@
4657
4673
  Utils_instance_0 = this;
4658
4674
  UtilsBase.call(this);
4659
4675
  }
4660
- protoOf(Utils_0).c3a = function () {
4661
- return Utils_instance.e3n_1;
4676
+ protoOf(Utils_0).b3a = function () {
4677
+ return Utils_instance.f3n_1;
4662
4678
  };
4663
4679
  var Utils_instance_0;
4664
4680
  function Utils_getInstance_0() {
@@ -4750,7 +4766,8 @@
4750
4766
  _.$_$.h = ArgLibrary;
4751
4767
  _.$_$.i = Loadable;
4752
4768
  _.$_$.j = mineGraph;
4753
- _.$_$.k = Graph;
4769
+ _.$_$.k = mineActiveGraph;
4770
+ _.$_$.l = Graph;
4754
4771
  //endregion
4755
4772
  return _;
4756
4773
  }));