@tuprolog/arg2p 0.10.0

package/2p-dsl-core.js

@@ -0,0 +1,1630 @@
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './2p-core.js', './2p-utils.js', './kt-math.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-core.js'), require('./2p-utils.js'), require('./kt-math.js'));
+  else {
+    if (typeof this['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module '2p-dsl-core'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to '2p-dsl-core'.");
+    }
+    if (typeof this['2p-core'] === 'undefined') {
+      throw new Error("Error loading module '2p-dsl-core'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to '2p-dsl-core'.");
+    }
+    if (typeof this['2p-utils'] === 'undefined') {
+      throw new Error("Error loading module '2p-dsl-core'. Its dependency '2p-utils' was not found. Please, check whether '2p-utils' is loaded prior to '2p-dsl-core'.");
+    }
+    if (typeof this['kt-math'] === 'undefined') {
+      throw new Error("Error loading module '2p-dsl-core'. Its dependency 'kt-math' was not found. Please, check whether 'kt-math' is loaded prior to '2p-dsl-core'.");
+    }
+    root['2p-dsl-core'] = factory(typeof this['2p-dsl-core'] === 'undefined' ? {} : this['2p-dsl-core'], this['kotlin-kotlin-stdlib'], this['2p-core'], this['2p-utils'], this['kt-math']);
+  }
+}(this, function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_utils, kotlin_io_github_gciatto_kt_math) {
+  'use strict';
+  //region block: imports
+  var THROW_CCE = kotlin_kotlin.$_$.y9;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.h;
+  var protoOf = kotlin_kotlin.$_$.b6;
+  var Unit_instance = kotlin_kotlin.$_$.s1;
+  var toString = kotlin_kotlin.$_$.g6;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.s;
+  var Term = kotlin_it_unibo_tuprolog_core.$_$.r2;
+  var isInterface = kotlin_kotlin.$_$.r5;
+  var TermConvertible = kotlin_it_unibo_tuprolog_core.$_$.u1;
+  var getKClassFromExpression = kotlin_kotlin.$_$.b;
+  var getKClass = kotlin_kotlin.$_$.c;
+  var toString_0 = kotlin_kotlin.$_$.j1;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.a1;
+  var asIterable = kotlin_kotlin.$_$.c2;
+  var assertItemsAreNotNull = kotlin_it_unibo_tuprolog_utils.$_$.q;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j2;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.e;
+  var assertItemsAreNotNull_0 = kotlin_it_unibo_tuprolog_utils.$_$.p;
+  var map = kotlin_kotlin.$_$.v7;
+  var assertItemsAreNotNull_1 = kotlin_it_unibo_tuprolog_utils.$_$.r;
+  var Char = kotlin_kotlin.$_$.m9;
+  var PrimitiveClasses_getInstance = kotlin_kotlin.$_$.p1;
+  var BigInteger = kotlin_io_github_gciatto_kt_math.$_$.g;
+  var BigDecimal = kotlin_io_github_gciatto_kt_math.$_$.f;
+  var Sequence = kotlin_kotlin.$_$.y6;
+  var Iterable = kotlin_kotlin.$_$.u1;
+  var List = kotlin_kotlin.$_$.v1;
+  var Set = kotlin_kotlin.$_$.y1;
+  var Pair = kotlin_kotlin.$_$.w9;
+  var Triple = kotlin_kotlin.$_$.aa;
+  var Entry = kotlin_kotlin.$_$.w1;
+  var Map = kotlin_kotlin.$_$.x1;
+  var classMeta = kotlin_kotlin.$_$.f5;
+  var setMetadataFor = kotlin_kotlin.$_$.c6;
+  var VOID = kotlin_kotlin.$_$.d;
+  var Struct = kotlin_it_unibo_tuprolog_core.$_$.s1;
+  var Scope = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var interfaceMeta = kotlin_kotlin.$_$.o5;
+  var Companion_instance = kotlin_it_unibo_tuprolog_core.$_$.t;
+  var Companion_instance_0 = kotlin_it_unibo_tuprolog_core.$_$.b1;
+  var objectMeta = kotlin_kotlin.$_$.a6;
+  var logicListFromFrom = kotlin_it_unibo_tuprolog_core.$_$.d;
+  var logicListFromIterable = kotlin_it_unibo_tuprolog_core.$_$.b;
+  var logicListFromSequence = kotlin_it_unibo_tuprolog_core.$_$.c;
+  var plus = kotlin_kotlin.$_$.b4;
+  var Tuple = kotlin_it_unibo_tuprolog_core.$_$.s2;
+  var Companion_instance_1 = kotlin_it_unibo_tuprolog_core.$_$.z;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var Var = kotlin_it_unibo_tuprolog_core.$_$.t2;
+  var arrayConcat = kotlin_kotlin.$_$.a;
+  var sequenceOf = kotlin_kotlin.$_$.b8;
+  var copyToArray = kotlin_kotlin.$_$.r2;
+  var listOf = kotlin_kotlin.$_$.k3;
+  var Rule = kotlin_it_unibo_tuprolog_core.$_$.q1;
+  var Directive = kotlin_it_unibo_tuprolog_core.$_$.j1;
+  var Fact = kotlin_it_unibo_tuprolog_core.$_$.k1;
+  var NumberTypeTester = kotlin_it_unibo_tuprolog_utils.$_$.i;
+  //endregion
+  //region block: pre-declaration
+  function copy(scope, $super) {
+    scope = scope === VOID ? this.z1g() : scope;
+    return $super === VOID ? this.a1h(scope) : $super.a1h.call(this, scope);
+  }
+  setMetadataFor(Termificator, 'Termificator', interfaceMeta);
+  setMetadataFor(AbstractTermificator, 'AbstractTermificator', classMeta, VOID, [Termificator]);
+  function convertToTerm(_this__u8e3s4) {
+    return this.x1i().toTerm(_this__u8e3s4);
+  }
+  function convertToSpecificSubTypeOfTerm(_this__u8e3s4, type, converter) {
+    var t = this.convertToTerm(_this__u8e3s4);
+    var tmp;
+    if (type.p6(t)) {
+      tmp = isInterface(t, Term) ? t : THROW_CCE();
+    } else {
+      if (isInterface(t, Struct)) {
+        tmp = converter(t);
+      } else {
+        raiseErrorConvertingTo(_this__u8e3s4, type);
+      }
+    }
+    return tmp;
+  }
+  setMetadataFor(BaseLogicProgrammingScope, 'BaseLogicProgrammingScope', interfaceMeta, VOID, [Scope]);
+  setMetadataFor(Companion, 'Companion', objectMeta);
+  function stringInvoke(_this__u8e3s4, term, terms) {
+    var tmp = sequenceOf(arrayConcat([[term], terms]));
+    return this.structOfSequence(_this__u8e3s4, map(tmp, MinimalLogicProgrammingScope$invoke$lambda(this)));
+  }
+  function structOfAny(functor, args) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(args.length);
+    var inductionVariable = 0;
+    var last = args.length;
+    while (inductionVariable < last) {
+      var item = args[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.structOf.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    var tmp$ret$3 = copyToArray(destination);
+    return this.structOf(functor, tmp$ret$3.slice());
+  }
+  function tupleOfAny(terms) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(terms.length);
+    var inductionVariable = 0;
+    var last = terms.length;
+    while (inductionVariable < last) {
+      var item = terms[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.tupleOf.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    var tmp$ret$3 = copyToArray(destination);
+    return this.tupleOf(tmp$ret$3.slice());
+  }
+  function logicListOfAny(terms) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(terms.length);
+    var inductionVariable = 0;
+    var last = terms.length;
+    while (inductionVariable < last) {
+      var item = terms[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.logicListOf.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    var tmp$ret$3 = copyToArray(destination);
+    return this.logicListOf(tmp$ret$3.slice());
+  }
+  function blockOfAny(terms) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(terms.length);
+    var inductionVariable = 0;
+    var last = terms.length;
+    while (inductionVariable < last) {
+      var item = terms[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.blockOf.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    var tmp$ret$3 = copyToArray(destination);
+    return this.blockOf(tmp$ret$3.slice());
+  }
+  function factOfAny(term) {
+    var tmp = this.convertToTerm(term);
+    return this.factOf(isInterface(tmp, Struct) ? tmp : THROW_CCE());
+  }
+  function consOfAny(head, tail) {
+    return this.consOf(this.convertToTerm(head), this.convertToTerm(tail));
+  }
+  function directiveOfAny(term, terms) {
+    var tmp = this.convertToTerm(term);
+    // Inline function 'kotlin.collections.toTypedArray' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(terms.length);
+    var inductionVariable = 0;
+    var last = terms.length;
+    while (inductionVariable < last) {
+      var item = terms[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.directiveOf.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    var tmp$ret$3 = copyToArray(destination);
+    return this.directiveOf(tmp, tmp$ret$3.slice());
+  }
+  function withScope(function_0) {
+    return function_0(this.newScope());
+  }
+  function logicList(items, tail) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = listOf(items.slice());
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.logicList.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.dsl.MinimalLogicProgrammingScope.logicList.<anonymous>' call
+    var tmp;
+    if (!(tail == null)) {
+      tmp = this.w10(destination, this.convertToTerm(tail));
+    } else {
+      tmp = this.logicListOfIterable(destination);
+    }
+    return tmp;
+  }
+  function logicList_0(items, tail, $super) {
+    tail = tail === VOID ? null : tail;
+    return $super === VOID ? this.d1j(items, tail) : logicList(items, tail);
+  }
+  function rule(function_0) {
+    var tmp = this.convertToTerm(function_0(this.newScope()));
+    return isInterface(tmp, Rule) ? tmp : THROW_CCE();
+  }
+  function directive(function_0) {
+    var tmp = function_0(this.newScope());
+    var tmp_0 = getKClass(Directive);
+    return this.convertToSpecificSubTypeOfTerm(tmp, tmp_0, MinimalLogicProgrammingScope$directive$directiveOf$ref(this));
+  }
+  function fact(function_0) {
+    var tmp = function_0(this.newScope());
+    var tmp_0 = getKClass(Fact);
+    return this.convertToSpecificSubTypeOfTerm(tmp, tmp_0, MinimalLogicProgrammingScope$factOf$ref(this));
+  }
+  setMetadataFor(MinimalLogicProgrammingScope, 'MinimalLogicProgrammingScope', interfaceMeta, VOID, [BaseLogicProgrammingScope]);
+  function at_end_of_stream1(alias) {
+    return this.structOf('at_end_of_stream', [this.convertToTerm(alias)]);
+  }
+  function call1(goal) {
+    return this.structOf('call', [this.convertToTerm(goal)]);
+  }
+  function catch3(goal, error, continuation) {
+    return this.structOf('catch', [this.convertToTerm(goal), this.convertToTerm(error), this.convertToTerm(continuation)]);
+  }
+  function throw1(error) {
+    return this.structOf('throw', [this.convertToTerm(error)]);
+  }
+  function not1(goal) {
+    return this.structOf('not', [this.convertToTerm(goal)]);
+  }
+  function naf1(goal) {
+    return this.structOf('\\+', [this.convertToTerm(goal)]);
+  }
+  function assert1(clause) {
+    return this.structOf('assert', [this.convertToTerm(clause)]);
+  }
+  function asserta1(clause) {
+    return this.structOf('asserta', [this.convertToTerm(clause)]);
+  }
+  function assertz1(clause) {
+    return this.structOf('assertz', [this.convertToTerm(clause)]);
+  }
+  function arg3(index, compound, argument) {
+    return this.structOf('arg', [this.convertToTerm(index), this.convertToTerm(compound), this.convertToTerm(argument)]);
+  }
+  function atom1(atom) {
+    return this.structOf('atom', [this.convertToTerm(atom)]);
+  }
+  function atomic1(atomic) {
+    return this.structOf('atomic', [this.convertToTerm(atomic)]);
+  }
+  function between3(min, max, number) {
+    return this.structOf('between', [this.convertToTerm(min), this.convertToTerm(max), this.convertToTerm(number)]);
+  }
+  function callable1(goal) {
+    return this.structOf('callable', [this.convertToTerm(goal)]);
+  }
+  function compound1(struct) {
+    return this.structOf('compound', [this.convertToTerm(struct)]);
+  }
+  function current_op3(precedence, specifier, functor) {
+    return this.structOf('current_op', [this.convertToTerm(precedence), this.convertToTerm(specifier), this.convertToTerm(functor)]);
+  }
+  function op3(precedence, specifier, functor) {
+    return this.structOf('op', [this.convertToTerm(precedence), this.convertToTerm(specifier), this.convertToTerm(functor)]);
+  }
+  function findall3(template, goal, bag) {
+    return this.structOf('findall', [this.convertToTerm(template), this.convertToTerm(goal), this.convertToTerm(bag)]);
+  }
+  function float1(number) {
+    return this.structOf('float', [this.convertToTerm(number)]);
+  }
+  function functor3(struct, functor, arity) {
+    return this.structOf('functor', [this.convertToTerm(struct), this.convertToTerm(functor), this.convertToTerm(arity)]);
+  }
+  function ground1(term) {
+    return this.structOf('ground', [this.convertToTerm(term)]);
+  }
+  function integer1(number) {
+    return this.structOf('integer', [this.convertToTerm(number)]);
+  }
+  function natural(number) {
+    return this.structOf('natural', [this.convertToTerm(number)]);
+  }
+  function nonvar1(number) {
+    return this.structOf('nonvar', [this.convertToTerm(number)]);
+  }
+  function number1(number) {
+    return this.structOf('number', [this.convertToTerm(number)]);
+  }
+  function var1(term) {
+    return this.structOf('var', [this.convertToTerm(term)]);
+  }
+  function write1(term) {
+    return this.structOf('write', [this.convertToTerm(term)]);
+  }
+  function univ2(_this__u8e3s4, other) {
+    return this.structOf('=..', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function eq2(_this__u8e3s4, right) {
+    return this.structOf('=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(right)]);
+  }
+  function neq2(_this__u8e3s4, right) {
+    return this.structOf('\\=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(right)]);
+  }
+  function id2(_this__u8e3s4, right) {
+    return this.structOf('==', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(right)]);
+  }
+  function nid2(_this__u8e3s4, right) {
+    return this.structOf('\\==', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(right)]);
+  }
+  function arithEq2(_this__u8e3s4, right) {
+    return this.structOf('=:=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(right)]);
+  }
+  function arithNeq2(_this__u8e3s4, right) {
+    return this.structOf('=\\=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(right)]);
+  }
+  function member2(item, list) {
+    return this.structOf('member', [this.convertToTerm(item), this.convertToTerm(list)]);
+  }
+  function retract1(clause) {
+    return this.structOf('retract', [this.convertToTerm(clause)]);
+  }
+  function append3(left, right, result) {
+    return this.structOf('append', [this.convertToTerm(left), this.convertToTerm(right), this.convertToTerm(result)]);
+  }
+  function retractall1(clause) {
+    return this.structOf('retractall', [this.convertToTerm(clause)]);
+  }
+  function abolish1(indicator) {
+    return this.structOf('abolish', [this.convertToTerm(indicator)]);
+  }
+  function atom_chars2(atom, chars) {
+    return this.structOf('atom_chars', [this.convertToTerm(atom), this.convertToTerm(chars)]);
+  }
+  function atom_codes2(atom, codes) {
+    return this.structOf('atom_codes', [this.convertToTerm(atom), this.convertToTerm(codes)]);
+  }
+  function atom_concat3(first, second, result) {
+    return this.structOf('atom_concat', [this.convertToTerm(first), this.convertToTerm(second), this.convertToTerm(result)]);
+  }
+  function atom_length2(atom, length) {
+    return this.structOf('atom_length', [this.convertToTerm(atom), this.convertToTerm(length)]);
+  }
+  function char_code2(char, code) {
+    return this.structOf('char_code', [this.convertToTerm(char), this.convertToTerm(code)]);
+  }
+  function clause2(head, body) {
+    return this.structOf('clause', [this.convertToTerm(head), this.convertToTerm(body)]);
+  }
+  function copy_term2(term, copy) {
+    return this.structOf('copy_term', [this.convertToTerm(term), this.convertToTerm(copy)]);
+  }
+  function current_flag2(name, value) {
+    return this.structOf('current_flag', [this.convertToTerm(name), this.convertToTerm(value)]);
+  }
+  function current_prolog_flag2(name, value) {
+    return this.structOf('current_prolog_flag', [this.convertToTerm(name), this.convertToTerm(value)]);
+  }
+  function sub_atom5(atom, before, length, after, sub_atom) {
+    return this.structOf('sub_atom', [this.convertToTerm(atom), this.convertToTerm(before), this.convertToTerm(length), this.convertToTerm(after), this.convertToTerm(sub_atom)]);
+  }
+  function number_chars2(first, second) {
+    return this.structOf('number_chars', [this.convertToTerm(first), this.convertToTerm(second)]);
+  }
+  function number_codes2(first, second) {
+    return this.structOf('number_codes', [this.convertToTerm(first), this.convertToTerm(second)]);
+  }
+  function bagof3(template, goal, bag) {
+    return this.structOf('bagof', [this.convertToTerm(template), this.convertToTerm(goal), this.convertToTerm(bag)]);
+  }
+  function setof3(template, goal, bag) {
+    return this.structOf('setof', [this.convertToTerm(template), this.convertToTerm(goal), this.convertToTerm(bag)]);
+  }
+  function consult1(url) {
+    return this.structOf('consult', [this.convertToTerm(url)]);
+  }
+  function set_flag2(name, value) {
+    return this.structOf('set_flag', [this.convertToTerm(name), this.convertToTerm(value)]);
+  }
+  function set_prolog_flag2(name, value) {
+    return this.structOf('set_prolog_flag', [this.convertToTerm(name), this.convertToTerm(value)]);
+  }
+  function dynamic1(indicator) {
+    return this.structOf('dynamic', [this.convertToTerm(indicator)]);
+  }
+  function static1(indicator) {
+    return this.structOf('static', [this.convertToTerm(indicator)]);
+  }
+  function solve1(goal) {
+    return this.structOf('solve', [this.convertToTerm(goal)]);
+  }
+  function initialization1(goal) {
+    return this.structOf('initialization', [this.convertToTerm(goal)]);
+  }
+  function load1(url) {
+    return this.structOf('load', [this.convertToTerm(url)]);
+  }
+  function include1(url) {
+    return this.structOf('include', [this.convertToTerm(url)]);
+  }
+  setMetadataFor(LogicProgrammingScopeWithPrologStandardLibrary, 'LogicProgrammingScopeWithPrologStandardLibrary', interfaceMeta, VOID, [BaseLogicProgrammingScope]);
+  function varTo(_this__u8e3s4, termObject) {
+    return Companion_getInstance_0().of(_this__u8e3s4, this.convertToTerm(termObject));
+  }
+  function stringTo(_this__u8e3s4, termObject) {
+    return Companion_getInstance_0().of(this.varOf(_this__u8e3s4), this.convertToTerm(termObject));
+  }
+  function substitutionGet(_this__u8e3s4, term) {
+    var t = this.convertToTerm(term);
+    var tmp;
+    if (isInterface(t, Var)) {
+      tmp = _this__u8e3s4.x2(t);
+    } else {
+      raiseErrorConvertingTo(term, getKClass(Var));
+    }
+    return tmp;
+  }
+  function substitutionContainsKey(_this__u8e3s4, term) {
+    var t = this.convertToTerm(term);
+    var tmp;
+    if (isInterface(t, Var)) {
+      tmp = _this__u8e3s4.u2(t);
+    } else {
+      raiseErrorConvertingTo(term, getKClass(Var));
+    }
+    return tmp;
+  }
+  function substitutionContains(_this__u8e3s4, term) {
+    return this.substitutionContainsKey(_this__u8e3s4, term);
+  }
+  function substitutionContainsValue(_this__u8e3s4, term) {
+    return _this__u8e3s4.v2(this.convertToTerm(term));
+  }
+  setMetadataFor(LogicProgrammingScopeWithSubstitutions, 'LogicProgrammingScopeWithSubstitutions', interfaceMeta, VOID, [BaseLogicProgrammingScope]);
+  function termPlus(_this__u8e3s4, other) {
+    return this.structOf('+', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function number(_this__u8e3s4, other) {
+    return this.termPlus(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function booleanPlus(_this__u8e3s4, other) {
+    return this.termPlus(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function charPlus(_this__u8e3s4, other) {
+    return this.termPlus(this.convertToTerm(new Char(_this__u8e3s4)), other);
+  }
+  function termMinus(_this__u8e3s4, other) {
+    return this.structOf('-', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function numberMinus(_this__u8e3s4, other) {
+    return this.termMinus(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function booleanMinus(_this__u8e3s4, other) {
+    return this.termMinus(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function charMinus(_this__u8e3s4, other) {
+    return this.termMinus(this.convertToTerm(new Char(_this__u8e3s4)), other);
+  }
+  function stringMinus(_this__u8e3s4, other) {
+    return this.termMinus(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function termTimes(_this__u8e3s4, other) {
+    return this.structOf('*', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function numberTimes(_this__u8e3s4, other) {
+    return this.termTimes(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function booleanTimes(_this__u8e3s4, other) {
+    return this.termTimes(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function charTimes(_this__u8e3s4, other) {
+    return this.termTimes(this.convertToTerm(new Char(_this__u8e3s4)), other);
+  }
+  function stringTimes(_this__u8e3s4, other) {
+    return this.termTimes(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function termDiv(_this__u8e3s4, other) {
+    return this.indicatorOf(this.convertToTerm(_this__u8e3s4), this.convertToTerm(other));
+  }
+  function numberDiv(_this__u8e3s4, other) {
+    return this.termDiv(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function booleanDiv(_this__u8e3s4, other) {
+    return this.termDiv(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function charDiv(_this__u8e3s4, other) {
+    return this.termDiv(this.convertToTerm(new Char(_this__u8e3s4)), other);
+  }
+  function stringDiv(_this__u8e3s4, other) {
+    return this.termDiv(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function anyEqualsTo(_this__u8e3s4, other) {
+    return this.structOf('=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyNotEqualsTo(_this__u8e3s4, other) {
+    return this.structOf('\\=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyGreaterThan(_this__u8e3s4, other) {
+    return this.structOf('>', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyGreaterThanOrEqualsTo(_this__u8e3s4, other) {
+    return this.structOf('>=', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyNonLowerThan(_this__u8e3s4, other) {
+    return this.anyGreaterThanOrEqualsTo(_this__u8e3s4, other);
+  }
+  function anyLowerThan(_this__u8e3s4, other) {
+    return this.structOf('<', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyLowerThanOrEqualsTo(_this__u8e3s4, other) {
+    return this.structOf('=<', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyNonGreaterThan(_this__u8e3s4, other) {
+    return this.anyLowerThanOrEqualsTo(_this__u8e3s4, other);
+  }
+  function anyIntDiv(_this__u8e3s4, other) {
+    return this.structOf('//', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function termRem(_this__u8e3s4, other) {
+    return this.structOf('rem', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function numberRem(_this__u8e3s4, other) {
+    return this.termRem(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function booleanRem(_this__u8e3s4, other) {
+    return this.termRem(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function charRem(_this__u8e3s4, other) {
+    return this.termRem(this.convertToTerm(new Char(_this__u8e3s4)), other);
+  }
+  function stringRem(_this__u8e3s4, other) {
+    return this.termRem(this.convertToTerm(_this__u8e3s4), other);
+  }
+  function anyAnd(_this__u8e3s4, other) {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'it.unibo.tuprolog.dsl.LogicProgrammingScopeWithOperators.and.<anonymous>' call
+    var it = this.convertToTerm(_this__u8e3s4);
+    var otherTerm = this.convertToTerm(other);
+    var tmp;
+    if (isInterface(it, Tuple)) {
+      tmp = this.tupleOfIterable(plus(it.sw(), otherTerm));
+    } else {
+      tmp = this.tupleOf([this.convertToTerm(_this__u8e3s4), otherTerm]);
+    }
+    return tmp;
+  }
+  function anyOr(_this__u8e3s4, other) {
+    return this.structOf(';', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyPow(_this__u8e3s4, other) {
+    return this.structOf('**', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anySup(_this__u8e3s4, other) {
+    return this.structOf('^', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyIs(_this__u8e3s4, other) {
+    return this.structOf('is', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyThen(_this__u8e3s4, other) {
+    return this.structOf('->', [this.convertToTerm(_this__u8e3s4), this.convertToTerm(other)]);
+  }
+  function anyImpliedBy(_this__u8e3s4, other) {
+    var t = this.convertToTerm(_this__u8e3s4);
+    var tmp;
+    if (isInterface(t, Struct)) {
+      tmp = this.ruleOf(t, this.convertToTerm(other), []);
+    } else {
+      raiseErrorConvertingTo(_this__u8e3s4, getKClass(Struct));
+    }
+    return tmp;
+  }
+  function anyIf(_this__u8e3s4, other) {
+    return this.anyImpliedBy(_this__u8e3s4, other);
+  }
+  function anyImpliedByVararg(_this__u8e3s4, other) {
+    var tmp = Companion_instance_1;
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(other.length);
+    var inductionVariable = 0;
+    var last = other.length;
+    while (inductionVariable < last) {
+      var item = other[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'it.unibo.tuprolog.dsl.LogicProgrammingScopeWithOperators.impliedBy.<anonymous>' call
+      var tmp$ret$0 = this.convertToTerm(item);
+      destination.o(tmp$ret$0);
+    }
+    return this.anyImpliedBy(_this__u8e3s4, tmp.wrapIterableIfNeeded(destination));
+  }
+  function anyIfVararg(_this__u8e3s4, other) {
+    return this.anyImpliedByVararg(_this__u8e3s4, other.slice());
+  }
+  setMetadataFor(LogicProgrammingScopeWithOperators, 'LogicProgrammingScopeWithOperators', interfaceMeta, VOID, [BaseLogicProgrammingScope]);
+  setMetadataFor(LogicProgrammingScopeImpl, 'LogicProgrammingScopeImpl', classMeta, VOID, [MinimalLogicProgrammingScope, BaseLogicProgrammingScope, LogicProgrammingScopeWithPrologStandardLibrary, LogicProgrammingScopeWithSubstitutions, LogicProgrammingScopeWithOperators, Scope]);
+  setMetadataFor(Companion_0, 'Companion', objectMeta);
+  setMetadataFor(DefaultTermificator, 'DefaultTermificator', classMeta, AbstractTermificator);
+  //endregion
+  function AbstractTermificator$handleType$lambda($conversion) {
+    return function (it) {
+      return $conversion(!(it == null) ? it : THROW_CCE());
+    };
+  }
+  function AbstractTermificator$handleSequenceAsList$lambda(this$0) {
+    return function (it) {
+      return this$0.d1i(it);
+    };
+  }
+  function AbstractTermificator$handleCharAsString$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.e1i(p0.j9_1);
+    };
+    l.callableName = 'handleCharAsString';
+    return l;
+  }
+  function AbstractTermificator$handleBooleanAsTruth$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.f1i(p0);
+    };
+    l.callableName = 'handleBooleanAsTruth';
+    return l;
+  }
+  function AbstractTermificator$handleStringAsAtomOrVariable$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.g1i(p0);
+    };
+    l.callableName = 'handleStringAsAtomOrVariable';
+    return l;
+  }
+  function AbstractTermificator$handleBigIntegerAsInteger$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.h1i(p0);
+    };
+    l.callableName = 'handleBigIntegerAsInteger';
+    return l;
+  }
+  function AbstractTermificator$handleBigDecimalAsReal$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.i1i(p0);
+    };
+    l.callableName = 'handleBigDecimalAsReal';
+    return l;
+  }
+  function AbstractTermificator$handleNumberAsNumeric$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.j1i(p0);
+    };
+    l.callableName = 'handleNumberAsNumeric';
+    return l;
+  }
+  function AbstractTermificator$handleArrayAsList$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.k1i(p0);
+    };
+    l.callableName = 'handleArrayAsList';
+    return l;
+  }
+  function AbstractTermificator$handleSequenceAsList$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.l1i(p0);
+    };
+    l.callableName = 'handleSequenceAsList';
+    return l;
+  }
+  function AbstractTermificator$handleIterableAsList$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.m1i(p0);
+    };
+    l.callableName = 'handleIterableAsList';
+    return l;
+  }
+  function AbstractTermificator$handleCharAsString$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.e1i(p0.j9_1);
+    };
+    l.callableName = 'handleCharAsString';
+    return l;
+  }
+  function AbstractTermificator$handleBooleanAsTruth$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.f1i(p0);
+    };
+    l.callableName = 'handleBooleanAsTruth';
+    return l;
+  }
+  function AbstractTermificator$handleStringAsAtomOrVariable$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.g1i(p0);
+    };
+    l.callableName = 'handleStringAsAtomOrVariable';
+    return l;
+  }
+  function AbstractTermificator$handleBigIntegerAsInteger$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.h1i(p0);
+    };
+    l.callableName = 'handleBigIntegerAsInteger';
+    return l;
+  }
+  function AbstractTermificator$handleBigDecimalAsReal$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.i1i(p0);
+    };
+    l.callableName = 'handleBigDecimalAsReal';
+    return l;
+  }
+  function AbstractTermificator$handleNumberAsNumeric$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.j1i(p0);
+    };
+    l.callableName = 'handleNumberAsNumeric';
+    return l;
+  }
+  function AbstractTermificator$handleArrayAsList$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.k1i(p0);
+    };
+    l.callableName = 'handleArrayAsList';
+    return l;
+  }
+  function AbstractTermificator$handleSequenceAsList$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.l1i(p0);
+    };
+    l.callableName = 'handleSequenceAsList';
+    return l;
+  }
+  function AbstractTermificator$handleKotlinListAsLogicList$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.n1i(p0);
+    };
+    l.callableName = 'handleKotlinListAsLogicList';
+    return l;
+  }
+  function AbstractTermificator$handleSetAsBlock$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.o1i(p0);
+    };
+    l.callableName = 'handleSetAsBlock';
+    return l;
+  }
+  function AbstractTermificator$handlePairAsTuple$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.p1i(p0);
+    };
+    l.callableName = 'handlePairAsTuple';
+    return l;
+  }
+  function AbstractTermificator$handleTripletAsTuple$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.q1i(p0);
+    };
+    l.callableName = 'handleTripletAsTuple';
+    return l;
+  }
+  function AbstractTermificator$handleKeyValuePairAsStruct$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.r1i(p0);
+    };
+    l.callableName = 'handleKeyValuePairAsStruct';
+    return l;
+  }
+  function AbstractTermificator$handleMapAsBlock$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.s1i(p0);
+    };
+    l.callableName = 'handleMapAsBlock';
+    return l;
+  }
+  function AbstractTermificator$handleIterableAsList$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.m1i(p0);
+    };
+    l.callableName = 'handleIterableAsList';
+    return l;
+  }
+  function AbstractTermificator(scope) {
+    this.b1i_1 = scope;
+    var tmp = this;
+    // Inline function 'kotlin.collections.linkedMapOf' call
+    tmp.c1i_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(AbstractTermificator).z1g = function () {
+    return this.b1i_1;
+  };
+  protoOf(AbstractTermificator).t1i = function (type, conversion) {
+    // Inline function 'kotlin.collections.set' call
+    var this_0 = this.c1i_1;
+    var value = AbstractTermificator$handleType$lambda(conversion);
+    this_0.o2(type, value);
+  };
+  protoOf(AbstractTermificator).d1i = function (value) {
+    $l$block: {
+      // Inline function 'kotlin.requireNotNull' call
+      // Inline function 'kotlin.contracts.contract' call
+      if (value == null) {
+        // Inline function 'it.unibo.tuprolog.dsl.AbstractTermificator.termify.<anonymous>' call
+        var message = 'Cannot termify null';
+        throw IllegalArgumentException_init_$Create$(toString(message));
+      } else {
+        break $l$block;
+      }
+    }
+    if (!(value == null) ? isInterface(value, Term) : false) {
+      return value;
+    }
+    if (!(value == null) ? isInterface(value, TermConvertible) : false) {
+      return value.toTerm();
+    }
+    var type = getKClassFromExpression(value);
+    var exactConverter = this.c1i_1.x2(type);
+    if (!(exactConverter == null)) {
+      return exactConverter(value);
+    }
+    // Inline function 'kotlin.collections.iterator' call
+    var tmp0_iterator = this.c1i_1.n2().r();
+    while (tmp0_iterator.s()) {
+      var tmp1_loop_parameter = tmp0_iterator.u();
+      // Inline function 'kotlin.collections.component1' call
+      var superType = tmp1_loop_parameter.q2();
+      // Inline function 'kotlin.collections.component2' call
+      var converter = tmp1_loop_parameter.r2();
+      if (superType.p6(value)) {
+        return converter(value);
+      }
+    }
+    raiseErrorConvertingTo(value, getKClass(Term));
+  };
+  protoOf(AbstractTermificator).toTerm = function (value) {
+    return this.d1i(value);
+  };
+  protoOf(AbstractTermificator).f1i = function (value) {
+    return this.z1g().truthOf(value);
+  };
+  protoOf(AbstractTermificator).e1i = function (value) {
+    return this.d1i(toString_0(value));
+  };
+  protoOf(AbstractTermificator).g1i = function (value) {
+    var tmp;
+    // Inline function 'kotlin.text.matches' call
+    if (Companion_getInstance().q13_1.i8(value)) {
+      tmp = this.z1g().varOf(value);
+    } else {
+      tmp = this.z1g().atomOf(value);
+    }
+    return tmp;
+  };
+  protoOf(AbstractTermificator).h1i = function (value) {
+    return this.z1g().intOfBigInteger(value);
+  };
+  protoOf(AbstractTermificator).i1i = function (value) {
+    return this.z1g().realOfBigDecimal(value);
+  };
+  protoOf(AbstractTermificator).k1i = function (value) {
+    var tmp = this.z1g();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = assertItemsAreNotNull(asIterable(value));
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.dsl.AbstractTermificator.handleArrayAsList.<anonymous>' call
+      var tmp$ret$0 = this.d1i(item);
+      destination.o(tmp$ret$0);
+    }
+    return tmp.logicListOfIterable(destination);
+  };
+  protoOf(AbstractTermificator).l1i = function (value) {
+    var tmp = this.z1g();
+    var tmp_0 = assertItemsAreNotNull_0(value);
+    return tmp.logicListOfSequence(map(tmp_0, AbstractTermificator$handleSequenceAsList$lambda(this)));
+  };
+  protoOf(AbstractTermificator).m1i = function (value) {
+    var tmp = this.z1g();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = assertItemsAreNotNull(value);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.dsl.AbstractTermificator.handleIterableAsList.<anonymous>' call
+      var tmp$ret$0 = this.d1i(item);
+      destination.o(tmp$ret$0);
+    }
+    return tmp.logicListOfIterable(destination);
+  };
+  protoOf(AbstractTermificator).n1i = function (value) {
+    var tmp = this.z1g();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = assertItemsAreNotNull_1(value);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.dsl.AbstractTermificator.handleKotlinListAsLogicList.<anonymous>' call
+      var tmp$ret$0 = this.d1i(item);
+      destination.o(tmp$ret$0);
+    }
+    return tmp.logicListOfIterable(destination);
+  };
+  protoOf(AbstractTermificator).o1i = function (value) {
+    var tmp = this.z1g();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = assertItemsAreNotNull(value);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.dsl.AbstractTermificator.handleSetAsBlock.<anonymous>' call
+      var tmp$ret$0 = this.d1i(item);
+      destination.o(tmp$ret$0);
+    }
+    return tmp.blockOfIterable(destination);
+  };
+  protoOf(AbstractTermificator).p1i = function (value) {
+    return this.z1g().tupleOf([this.d1i(value.qd_1), this.d1i(value.rd_1)]);
+  };
+  protoOf(AbstractTermificator).q1i = function (value) {
+    return this.z1g().tupleOf([this.d1i(value.ei_1), this.d1i(value.fi_1), this.d1i(value.gi_1)]);
+  };
+  protoOf(AbstractTermificator).r1i = function (value) {
+    return this.z1g().structOf(':', [this.d1i(value.q2()), this.d1i(value.r2())]);
+  };
+  protoOf(AbstractTermificator).s1i = function (value) {
+    var tmp = this.z1g();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = assertItemsAreNotNull(value.n2());
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.r();
+    while (tmp0_iterator.s()) {
+      var item = tmp0_iterator.u();
+      // Inline function 'it.unibo.tuprolog.dsl.AbstractTermificator.handleMapAsBlock.<anonymous>' call
+      var tmp$ret$0 = this.r1i(item);
+      destination.o(tmp$ret$0);
+    }
+    return tmp.blockOfIterable(destination);
+  };
+  protoOf(AbstractTermificator).u1i = function () {
+    var tmp = getKClass(Char);
+    this.t1i(tmp, AbstractTermificator$handleCharAsString$ref(this));
+    var tmp_0 = PrimitiveClasses_getInstance().c7();
+    this.t1i(tmp_0, AbstractTermificator$handleBooleanAsTruth$ref(this));
+    var tmp_1 = PrimitiveClasses_getInstance().j7();
+    this.t1i(tmp_1, AbstractTermificator$handleStringAsAtomOrVariable$ref(this));
+    var tmp_2 = getKClass(BigInteger);
+    this.t1i(tmp_2, AbstractTermificator$handleBigIntegerAsInteger$ref(this));
+    var tmp_3 = getKClass(BigDecimal);
+    this.t1i(tmp_3, AbstractTermificator$handleBigDecimalAsReal$ref(this));
+    var tmp_4 = PrimitiveClasses_getInstance().a7();
+    this.t1i(tmp_4, AbstractTermificator$handleNumberAsNumeric$ref(this));
+    var tmp_5 = PrimitiveClasses_getInstance().i7();
+    this.t1i(tmp_5, AbstractTermificator$handleArrayAsList$ref(this));
+    var tmp_6 = getKClass(Sequence);
+    this.t1i(tmp_6, AbstractTermificator$handleSequenceAsList$ref(this));
+    var tmp_7 = getKClass(Iterable);
+    this.t1i(tmp_7, AbstractTermificator$handleIterableAsList$ref(this));
+  };
+  protoOf(AbstractTermificator).v1i = function () {
+    var tmp = getKClass(Char);
+    this.t1i(tmp, AbstractTermificator$handleCharAsString$ref_0(this));
+    var tmp_0 = PrimitiveClasses_getInstance().c7();
+    this.t1i(tmp_0, AbstractTermificator$handleBooleanAsTruth$ref_0(this));
+    var tmp_1 = PrimitiveClasses_getInstance().j7();
+    this.t1i(tmp_1, AbstractTermificator$handleStringAsAtomOrVariable$ref_0(this));
+    var tmp_2 = getKClass(BigInteger);
+    this.t1i(tmp_2, AbstractTermificator$handleBigIntegerAsInteger$ref_0(this));
+    var tmp_3 = getKClass(BigDecimal);
+    this.t1i(tmp_3, AbstractTermificator$handleBigDecimalAsReal$ref_0(this));
+    var tmp_4 = PrimitiveClasses_getInstance().a7();
+    this.t1i(tmp_4, AbstractTermificator$handleNumberAsNumeric$ref_0(this));
+    var tmp_5 = PrimitiveClasses_getInstance().i7();
+    this.t1i(tmp_5, AbstractTermificator$handleArrayAsList$ref_0(this));
+    var tmp_6 = getKClass(Sequence);
+    this.t1i(tmp_6, AbstractTermificator$handleSequenceAsList$ref_0(this));
+    var tmp_7 = getKClass(List);
+    this.t1i(tmp_7, AbstractTermificator$handleKotlinListAsLogicList$ref(this));
+    var tmp_8 = getKClass(Set);
+    this.t1i(tmp_8, AbstractTermificator$handleSetAsBlock$ref(this));
+    var tmp_9 = getKClass(Pair);
+    this.t1i(tmp_9, AbstractTermificator$handlePairAsTuple$ref(this));
+    var tmp_10 = getKClass(Triple);
+    this.t1i(tmp_10, AbstractTermificator$handleTripletAsTuple$ref(this));
+    var tmp_11 = getKClass(Entry);
+    this.t1i(tmp_11, AbstractTermificator$handleKeyValuePairAsStruct$ref(this));
+    var tmp_12 = getKClass(Map);
+    this.t1i(tmp_12, AbstractTermificator$handleMapAsBlock$ref(this));
+    var tmp_13 = getKClass(Iterable);
+    this.t1i(tmp_13, AbstractTermificator$handleIterableAsList$ref_0(this));
+  };
+  protoOf(AbstractTermificator).w1i = function (novel) {
+    if (novel) {
+      this.v1i();
+    } else {
+      this.u1i();
+    }
+  };
+  function BaseLogicProgrammingScope() {
+  }
+  function logicProgramming(function_0) {
+    return function_0(Companion_instance_2.empty());
+  }
+  function raiseErrorConvertingTo(_this__u8e3s4, class_0) {
+    throw IllegalArgumentException_init_$Create$('Cannot convert ' + getKClassFromExpression(_this__u8e3s4) + ' into ' + class_0);
+  }
+  function Companion() {
+  }
+  protoOf(Companion).empty = function () {
+    return this.of();
+  };
+  protoOf(Companion).y1i = function (scope, termificator, variablesProvider) {
+    return new LogicProgrammingScopeImpl(scope, termificator.z1g() === scope ? termificator : termificator.a1h(scope), variablesProvider.z1g() === scope ? variablesProvider : variablesProvider.a1h(scope));
+  };
+  protoOf(Companion).of = function (scope, termificator, variablesProvider, $super) {
+    scope = scope === VOID ? Companion_instance.empty() : scope;
+    termificator = termificator === VOID ? Companion_instance_3.default(scope) : termificator;
+    variablesProvider = variablesProvider === VOID ? Companion_instance_0.v13(scope) : variablesProvider;
+    return $super === VOID ? this.y1i(scope, termificator, variablesProvider) : $super.y1i.call(this, scope, termificator, variablesProvider);
+  };
+  var Companion_instance_2;
+  function Companion_getInstance_1() {
+    return Companion_instance_2;
+  }
+  function LogicProgrammingScopeImpl(scope, termificator, variablesProvider) {
+    this.z1i_1 = scope;
+    this.a1j_1 = termificator;
+    this.b1j_1 = variablesProvider;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.z1i_1 === this.b1j_1.z1g() ? this.z1i_1 === this.a1j_1.z1g() : false)) {
+      // Inline function 'it.unibo.tuprolog.dsl.LogicProgrammingScopeImpl.<anonymous>' call
+      var message = 'The provided Scope should be the same object for both Termificator and VariablesProvider';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(LogicProgrammingScopeImpl).z1g = function () {
+    return this.z1i_1;
+  };
+  protoOf(LogicProgrammingScopeImpl).x1i = function () {
+    return this.a1j_1;
+  };
+  protoOf(LogicProgrammingScopeImpl).c1h = function () {
+    return this.b1j_1.c1h();
+  };
+  protoOf(LogicProgrammingScopeImpl).d1h = function () {
+    return this.b1j_1.d1h();
+  };
+  protoOf(LogicProgrammingScopeImpl).u10 = function () {
+    return this.b1j_1.u10();
+  };
+  protoOf(LogicProgrammingScopeImpl).t10 = function () {
+    return this.b1j_1.t10();
+  };
+  protoOf(LogicProgrammingScopeImpl).anonymous = function () {
+    return this.b1j_1.anonymous();
+  };
+  protoOf(LogicProgrammingScopeImpl).atomOfChar = function (value) {
+    return this.b1j_1.atomOfChar(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).atomOf = function (value) {
+    return this.b1j_1.atomOf(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).blockOf = function (terms) {
+    return this.b1j_1.blockOf(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).blockOfIterable = function (terms) {
+    return this.b1j_1.blockOfIterable(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).blockOfSequence = function (terms) {
+    return this.b1j_1.blockOfSequence(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).clauseOf = function (head, body) {
+    return this.b1j_1.clauseOf(head, body);
+  };
+  protoOf(LogicProgrammingScopeImpl).consOf = function (head, tail) {
+    return this.b1j_1.consOf(head, tail);
+  };
+  protoOf(LogicProgrammingScopeImpl).containsVar = function (variable) {
+    return this.b1j_1.containsVar(variable);
+  };
+  protoOf(LogicProgrammingScopeImpl).contains = function (variable) {
+    return this.b1j_1.contains(variable);
+  };
+  protoOf(LogicProgrammingScopeImpl).directiveOf = function (body1, body) {
+    return this.b1j_1.directiveOf(body1, body);
+  };
+  protoOf(LogicProgrammingScopeImpl).factOf = function (head) {
+    return this.b1j_1.factOf(head);
+  };
+  protoOf(LogicProgrammingScopeImpl).get = function (variable) {
+    return this.b1j_1.get(variable);
+  };
+  protoOf(LogicProgrammingScopeImpl).getValue = function (thisRef, property) {
+    return this.b1j_1.getValue(thisRef, property);
+  };
+  protoOf(LogicProgrammingScopeImpl).indicatorOf = function (name, arity) {
+    return this.b1j_1.indicatorOf(name, arity);
+  };
+  protoOf(LogicProgrammingScopeImpl).indicatorOfStringInt = function (name, arity) {
+    return this.b1j_1.indicatorOfStringInt(name, arity);
+  };
+  protoOf(LogicProgrammingScopeImpl).intOfByte = function (value) {
+    return this.b1j_1.intOfByte(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).intOf = function (value) {
+    return this.b1j_1.intOf(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).intOfLong = function (value) {
+    return this.b1j_1.intOfLong(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).intOfShort = function (value) {
+    return this.b1j_1.intOfShort(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).parseInt = function (value) {
+    return this.b1j_1.parseInt(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).parseIntRadix = function (value, radix) {
+    return this.b1j_1.parseIntRadix(value, radix);
+  };
+  protoOf(LogicProgrammingScopeImpl).intOfBigInteger = function (value) {
+    return this.b1j_1.intOfBigInteger(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).v10 = function (terms, last) {
+    return this.b1j_1.v10(terms, last);
+  };
+  protoOf(LogicProgrammingScopeImpl).w10 = function (terms, last) {
+    return this.b1j_1.w10(terms, last);
+  };
+  protoOf(LogicProgrammingScopeImpl).x10 = function (terms, last) {
+    return this.b1j_1.x10(terms, last);
+  };
+  protoOf(LogicProgrammingScopeImpl).logicListOf = function (terms) {
+    return this.b1j_1.logicListOf(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).logicListOfIterable = function (terms) {
+    return this.b1j_1.logicListOfIterable(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).logicListOfSequence = function (terms) {
+    return this.b1j_1.logicListOfSequence(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfByte = function (value) {
+    return this.b1j_1.numOfByte(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfDouble = function (value) {
+    return this.b1j_1.numOfDouble(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfFloat = function (value) {
+    return this.b1j_1.numOfFloat(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfInt = function (value) {
+    return this.b1j_1.numOfInt(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfLong = function (value) {
+    return this.b1j_1.numOfLong(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOf = function (value) {
+    return this.b1j_1.numOf(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfShort = function (value) {
+    return this.b1j_1.numOfShort(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).parseNum = function (value) {
+    return this.b1j_1.parseNum(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfBigDecimal = function (value) {
+    return this.b1j_1.numOfBigDecimal(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).numOfBigInteger = function (value) {
+    return this.b1j_1.numOfBigInteger(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).realOf = function (value) {
+    return this.b1j_1.realOf(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).realOfFloat = function (value) {
+    return this.b1j_1.realOfFloat(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).parseReal = function (value) {
+    return this.b1j_1.parseReal(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).realOfBigDecimal = function (value) {
+    return this.b1j_1.realOfBigDecimal(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).ruleOf = function (head, body1, body) {
+    return this.b1j_1.ruleOf(head, body1, body);
+  };
+  protoOf(LogicProgrammingScopeImpl).structOf = function (functor, args) {
+    return this.b1j_1.structOf(functor, args);
+  };
+  protoOf(LogicProgrammingScopeImpl).structOfIterable = function (functor, args) {
+    return this.b1j_1.structOfIterable(functor, args);
+  };
+  protoOf(LogicProgrammingScopeImpl).structOfList = function (functor, args) {
+    return this.b1j_1.structOfList(functor, args);
+  };
+  protoOf(LogicProgrammingScopeImpl).structOfSequence = function (functor, args) {
+    return this.b1j_1.structOfSequence(functor, args);
+  };
+  protoOf(LogicProgrammingScopeImpl).substitutionOf = function (assignments) {
+    return this.b1j_1.substitutionOf(assignments);
+  };
+  protoOf(LogicProgrammingScopeImpl).substitutionOfIterable = function (assignments) {
+    return this.b1j_1.substitutionOfIterable(assignments);
+  };
+  protoOf(LogicProgrammingScopeImpl).substitutionOfSequence = function (assignments) {
+    return this.b1j_1.substitutionOfSequence(assignments);
+  };
+  protoOf(LogicProgrammingScopeImpl).truthOf = function (value) {
+    return this.b1j_1.truthOf(value);
+  };
+  protoOf(LogicProgrammingScopeImpl).tupleOf = function (terms) {
+    return this.b1j_1.tupleOf(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).tupleOfIterable = function (terms) {
+    return this.b1j_1.tupleOfIterable(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).tupleOfSequence = function (terms) {
+    return this.b1j_1.tupleOfSequence(terms);
+  };
+  protoOf(LogicProgrammingScopeImpl).unifierOf = function (assignments) {
+    return this.b1j_1.unifierOf(assignments);
+  };
+  protoOf(LogicProgrammingScopeImpl).unifierOfIterable = function (assignments) {
+    return this.b1j_1.unifierOfIterable(assignments);
+  };
+  protoOf(LogicProgrammingScopeImpl).unifierOfSequence = function (assignments) {
+    return this.b1j_1.unifierOfSequence(assignments);
+  };
+  protoOf(LogicProgrammingScopeImpl).varOfChar = function (name) {
+    return this.b1j_1.varOfChar(name);
+  };
+  protoOf(LogicProgrammingScopeImpl).varOf = function (name) {
+    return this.b1j_1.varOf(name);
+  };
+  protoOf(LogicProgrammingScopeImpl).whatever = function () {
+    return this.b1j_1.whatever();
+  };
+  protoOf(LogicProgrammingScopeImpl).where = function (lambda) {
+    return this.b1j_1.where(lambda);
+  };
+  protoOf(LogicProgrammingScopeImpl).with = function (lambda) {
+    return this.b1j_1.with(lambda);
+  };
+  protoOf(LogicProgrammingScopeImpl).a1h = function (scope) {
+    return new LogicProgrammingScopeImpl(scope, this.a1j_1.a1h(scope), this.b1j_1.a1h(scope));
+  };
+  protoOf(LogicProgrammingScopeImpl).c1j = function () {
+    return this.a1h(Companion_instance.empty());
+  };
+  protoOf(LogicProgrammingScopeImpl).newScope = function () {
+    return this.c1j();
+  };
+  function LogicProgrammingScopeWithOperators() {
+  }
+  function LogicProgrammingScopeWithPrologStandardLibrary() {
+  }
+  function LogicProgrammingScopeWithSubstitutions() {
+  }
+  function directive$directiveOf(receiver, p0) {
+    return receiver.directiveOf(p0, []);
+  }
+  function MinimalLogicProgrammingScope$invoke$lambda(this$0) {
+    return function (it) {
+      return this$0.convertToTerm(it);
+    };
+  }
+  function MinimalLogicProgrammingScope$directive$directiveOf$ref($boundThis) {
+    return function (p0) {
+      return directive$directiveOf($boundThis, p0);
+    };
+  }
+  function MinimalLogicProgrammingScope$factOf$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.factOf(p0);
+    };
+    l.callableName = 'factOf';
+    return l;
+  }
+  function MinimalLogicProgrammingScope() {
+  }
+  function Companion_0() {
+  }
+  protoOf(Companion_0).default = function (scope) {
+    return new DefaultTermificator(scope, true);
+  };
+  protoOf(Companion_0).legacy = function (scope) {
+    return new DefaultTermificator(scope, false);
+  };
+  var Companion_instance_3;
+  function Companion_getInstance_2() {
+    return Companion_instance_3;
+  }
+  function Termificator() {
+  }
+  function DefaultTermificator(scope, novel) {
+    novel = novel === VOID ? false : novel;
+    AbstractTermificator.call(this, scope);
+    this.g1j_1 = novel;
+    this.w1i(this.g1j_1);
+    this.h1j_1 = new NumberTypeTester();
+  }
+  protoOf(DefaultTermificator).j1i = function (value) {
+    var tmp;
+    if (this.h1j_1.os(value)) {
+      tmp = this.z1g().intOfBigInteger(this.h1j_1.ps(value));
+    } else {
+      tmp = this.z1g().realOfBigDecimal(this.h1j_1.qs(value));
+    }
+    return tmp;
+  };
+  protoOf(DefaultTermificator).a1h = function (scope) {
+    return new DefaultTermificator(scope, this.g1j_1);
+  };
+  //region block: post-declaration
+  protoOf(AbstractTermificator).copy = copy;
+  protoOf(LogicProgrammingScopeImpl).logicListFromFrom = logicListFromFrom;
+  protoOf(LogicProgrammingScopeImpl).logicListFromIterable = logicListFromIterable;
+  protoOf(LogicProgrammingScopeImpl).logicListFromSequence = logicListFromSequence;
+  protoOf(LogicProgrammingScopeImpl).stringInvoke = stringInvoke;
+  protoOf(LogicProgrammingScopeImpl).structOfAny = structOfAny;
+  protoOf(LogicProgrammingScopeImpl).tupleOfAny = tupleOfAny;
+  protoOf(LogicProgrammingScopeImpl).logicListOfAny = logicListOfAny;
+  protoOf(LogicProgrammingScopeImpl).blockOfAny = blockOfAny;
+  protoOf(LogicProgrammingScopeImpl).factOfAny = factOfAny;
+  protoOf(LogicProgrammingScopeImpl).consOfAny = consOfAny;
+  protoOf(LogicProgrammingScopeImpl).directiveOfAny = directiveOfAny;
+  protoOf(LogicProgrammingScopeImpl).withScope = withScope;
+  protoOf(LogicProgrammingScopeImpl).d1j = logicList;
+  protoOf(LogicProgrammingScopeImpl).logicList = logicList_0;
+  protoOf(LogicProgrammingScopeImpl).rule = rule;
+  protoOf(LogicProgrammingScopeImpl).clause2 = clause2;
+  protoOf(LogicProgrammingScopeImpl).directive = directive;
+  protoOf(LogicProgrammingScopeImpl).fact = fact;
+  protoOf(LogicProgrammingScopeImpl).convertToTerm = convertToTerm;
+  protoOf(LogicProgrammingScopeImpl).convertToSpecificSubTypeOfTerm = convertToSpecificSubTypeOfTerm;
+  protoOf(LogicProgrammingScopeImpl).substitutionContains = substitutionContains;
+  protoOf(LogicProgrammingScopeImpl).substitutionGet = substitutionGet;
+  protoOf(LogicProgrammingScopeImpl).varTo = varTo;
+  protoOf(LogicProgrammingScopeImpl).stringTo = stringTo;
+  protoOf(LogicProgrammingScopeImpl).substitutionContainsKey = substitutionContainsKey;
+  protoOf(LogicProgrammingScopeImpl).substitutionContainsValue = substitutionContainsValue;
+  protoOf(LogicProgrammingScopeImpl).at_end_of_stream1 = at_end_of_stream1;
+  protoOf(LogicProgrammingScopeImpl).call1 = call1;
+  protoOf(LogicProgrammingScopeImpl).catch3 = catch3;
+  protoOf(LogicProgrammingScopeImpl).throw1 = throw1;
+  protoOf(LogicProgrammingScopeImpl).not1 = not1;
+  protoOf(LogicProgrammingScopeImpl).naf1 = naf1;
+  protoOf(LogicProgrammingScopeImpl).assert1 = assert1;
+  protoOf(LogicProgrammingScopeImpl).asserta1 = asserta1;
+  protoOf(LogicProgrammingScopeImpl).assertz1 = assertz1;
+  protoOf(LogicProgrammingScopeImpl).arg3 = arg3;
+  protoOf(LogicProgrammingScopeImpl).atom1 = atom1;
+  protoOf(LogicProgrammingScopeImpl).atomic1 = atomic1;
+  protoOf(LogicProgrammingScopeImpl).between3 = between3;
+  protoOf(LogicProgrammingScopeImpl).callable1 = callable1;
+  protoOf(LogicProgrammingScopeImpl).compound1 = compound1;
+  protoOf(LogicProgrammingScopeImpl).current_op3 = current_op3;
+  protoOf(LogicProgrammingScopeImpl).op3 = op3;
+  protoOf(LogicProgrammingScopeImpl).findall3 = findall3;
+  protoOf(LogicProgrammingScopeImpl).float1 = float1;
+  protoOf(LogicProgrammingScopeImpl).functor3 = functor3;
+  protoOf(LogicProgrammingScopeImpl).ground1 = ground1;
+  protoOf(LogicProgrammingScopeImpl).integer1 = integer1;
+  protoOf(LogicProgrammingScopeImpl).natural = natural;
+  protoOf(LogicProgrammingScopeImpl).nonvar1 = nonvar1;
+  protoOf(LogicProgrammingScopeImpl).number1 = number1;
+  protoOf(LogicProgrammingScopeImpl).var1 = var1;
+  protoOf(LogicProgrammingScopeImpl).write1 = write1;
+  protoOf(LogicProgrammingScopeImpl).univ2 = univ2;
+  protoOf(LogicProgrammingScopeImpl).eq2 = eq2;
+  protoOf(LogicProgrammingScopeImpl).neq2 = neq2;
+  protoOf(LogicProgrammingScopeImpl).id2 = id2;
+  protoOf(LogicProgrammingScopeImpl).nid2 = nid2;
+  protoOf(LogicProgrammingScopeImpl).arithEq2 = arithEq2;
+  protoOf(LogicProgrammingScopeImpl).arithNeq2 = arithNeq2;
+  protoOf(LogicProgrammingScopeImpl).member2 = member2;
+  protoOf(LogicProgrammingScopeImpl).retract1 = retract1;
+  protoOf(LogicProgrammingScopeImpl).append3 = append3;
+  protoOf(LogicProgrammingScopeImpl).retractall1 = retractall1;
+  protoOf(LogicProgrammingScopeImpl).abolish1 = abolish1;
+  protoOf(LogicProgrammingScopeImpl).atom_chars2 = atom_chars2;
+  protoOf(LogicProgrammingScopeImpl).atom_codes2 = atom_codes2;
+  protoOf(LogicProgrammingScopeImpl).atom_concat3 = atom_concat3;
+  protoOf(LogicProgrammingScopeImpl).atom_length2 = atom_length2;
+  protoOf(LogicProgrammingScopeImpl).char_code2 = char_code2;
+  protoOf(LogicProgrammingScopeImpl).copy_term2 = copy_term2;
+  protoOf(LogicProgrammingScopeImpl).current_flag2 = current_flag2;
+  protoOf(LogicProgrammingScopeImpl).current_prolog_flag2 = current_prolog_flag2;
+  protoOf(LogicProgrammingScopeImpl).sub_atom5 = sub_atom5;
+  protoOf(LogicProgrammingScopeImpl).number_chars2 = number_chars2;
+  protoOf(LogicProgrammingScopeImpl).number_codes2 = number_codes2;
+  protoOf(LogicProgrammingScopeImpl).bagof3 = bagof3;
+  protoOf(LogicProgrammingScopeImpl).setof3 = setof3;
+  protoOf(LogicProgrammingScopeImpl).consult1 = consult1;
+  protoOf(LogicProgrammingScopeImpl).set_flag2 = set_flag2;
+  protoOf(LogicProgrammingScopeImpl).set_prolog_flag2 = set_prolog_flag2;
+  protoOf(LogicProgrammingScopeImpl).dynamic1 = dynamic1;
+  protoOf(LogicProgrammingScopeImpl).static1 = static1;
+  protoOf(LogicProgrammingScopeImpl).solve1 = solve1;
+  protoOf(LogicProgrammingScopeImpl).initialization1 = initialization1;
+  protoOf(LogicProgrammingScopeImpl).load1 = load1;
+  protoOf(LogicProgrammingScopeImpl).include1 = include1;
+  protoOf(LogicProgrammingScopeImpl).termPlus = termPlus;
+  protoOf(LogicProgrammingScopeImpl).number = number;
+  protoOf(LogicProgrammingScopeImpl).booleanPlus = booleanPlus;
+  protoOf(LogicProgrammingScopeImpl).charPlus = charPlus;
+  protoOf(LogicProgrammingScopeImpl).termMinus = termMinus;
+  protoOf(LogicProgrammingScopeImpl).numberMinus = numberMinus;
+  protoOf(LogicProgrammingScopeImpl).booleanMinus = booleanMinus;
+  protoOf(LogicProgrammingScopeImpl).charMinus = charMinus;
+  protoOf(LogicProgrammingScopeImpl).stringMinus = stringMinus;
+  protoOf(LogicProgrammingScopeImpl).termTimes = termTimes;
+  protoOf(LogicProgrammingScopeImpl).numberTimes = numberTimes;
+  protoOf(LogicProgrammingScopeImpl).booleanTimes = booleanTimes;
+  protoOf(LogicProgrammingScopeImpl).charTimes = charTimes;
+  protoOf(LogicProgrammingScopeImpl).stringTimes = stringTimes;
+  protoOf(LogicProgrammingScopeImpl).termDiv = termDiv;
+  protoOf(LogicProgrammingScopeImpl).numberDiv = numberDiv;
+  protoOf(LogicProgrammingScopeImpl).booleanDiv = booleanDiv;
+  protoOf(LogicProgrammingScopeImpl).charDiv = charDiv;
+  protoOf(LogicProgrammingScopeImpl).stringDiv = stringDiv;
+  protoOf(LogicProgrammingScopeImpl).anyEqualsTo = anyEqualsTo;
+  protoOf(LogicProgrammingScopeImpl).anyNotEqualsTo = anyNotEqualsTo;
+  protoOf(LogicProgrammingScopeImpl).anyGreaterThan = anyGreaterThan;
+  protoOf(LogicProgrammingScopeImpl).anyGreaterThanOrEqualsTo = anyGreaterThanOrEqualsTo;
+  protoOf(LogicProgrammingScopeImpl).anyNonLowerThan = anyNonLowerThan;
+  protoOf(LogicProgrammingScopeImpl).anyLowerThan = anyLowerThan;
+  protoOf(LogicProgrammingScopeImpl).anyLowerThanOrEqualsTo = anyLowerThanOrEqualsTo;
+  protoOf(LogicProgrammingScopeImpl).anyNonGreaterThan = anyNonGreaterThan;
+  protoOf(LogicProgrammingScopeImpl).anyIntDiv = anyIntDiv;
+  protoOf(LogicProgrammingScopeImpl).termRem = termRem;
+  protoOf(LogicProgrammingScopeImpl).numberRem = numberRem;
+  protoOf(LogicProgrammingScopeImpl).booleanRem = booleanRem;
+  protoOf(LogicProgrammingScopeImpl).charRem = charRem;
+  protoOf(LogicProgrammingScopeImpl).stringRem = stringRem;
+  protoOf(LogicProgrammingScopeImpl).anyAnd = anyAnd;
+  protoOf(LogicProgrammingScopeImpl).anyOr = anyOr;
+  protoOf(LogicProgrammingScopeImpl).anyPow = anyPow;
+  protoOf(LogicProgrammingScopeImpl).anySup = anySup;
+  protoOf(LogicProgrammingScopeImpl).anyIs = anyIs;
+  protoOf(LogicProgrammingScopeImpl).anyThen = anyThen;
+  protoOf(LogicProgrammingScopeImpl).anyImpliedBy = anyImpliedBy;
+  protoOf(LogicProgrammingScopeImpl).anyImpliedByVararg = anyImpliedByVararg;
+  protoOf(LogicProgrammingScopeImpl).anyIf = anyIf;
+  protoOf(LogicProgrammingScopeImpl).anyIfVararg = anyIfVararg;
+  //endregion
+  //region block: init
+  Companion_instance_2 = new Companion();
+  Companion_instance_3 = new Companion_0();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = logicList_0;
+  _.$_$.b = Companion_instance_3;
+  _.$_$.c = convertToSpecificSubTypeOfTerm;
+  _.$_$.d = convertToTerm;
+  _.$_$.e = BaseLogicProgrammingScope;
+  _.$_$.f = anyAnd;
+  _.$_$.g = termDiv;
+  _.$_$.h = stringDiv;
+  _.$_$.i = charDiv;
+  _.$_$.j = numberDiv;
+  _.$_$.k = booleanDiv;
+  _.$_$.l = anyEqualsTo;
+  _.$_$.m = anyGreaterThanOrEqualsTo;
+  _.$_$.n = anyGreaterThan;
+  _.$_$.o = anyIf;
+  _.$_$.p = anyIfVararg;
+  _.$_$.q = anyImpliedBy;
+  _.$_$.r = anyImpliedByVararg;
+  _.$_$.s = anyIntDiv;
+  _.$_$.t = anyIs;
+  _.$_$.u = anyLowerThanOrEqualsTo;
+  _.$_$.v = anyLowerThan;
+  _.$_$.w = numberMinus;
+  _.$_$.x = termMinus;
+  _.$_$.y = charMinus;
+  _.$_$.z = stringMinus;
+  _.$_$.a1 = booleanMinus;
+  _.$_$.b1 = anyNonGreaterThan;
+  _.$_$.c1 = anyNonLowerThan;
+  _.$_$.d1 = anyNotEqualsTo;
+  _.$_$.e1 = anyOr;
+  _.$_$.f1 = booleanPlus;
+  _.$_$.g1 = termPlus;
+  _.$_$.h1 = number;
+  _.$_$.i1 = charPlus;
+  _.$_$.j1 = anyPow;
+  _.$_$.k1 = numberRem;
+  _.$_$.l1 = stringRem;
+  _.$_$.m1 = charRem;
+  _.$_$.n1 = termRem;
+  _.$_$.o1 = booleanRem;
+  _.$_$.p1 = anySup;
+  _.$_$.q1 = anyThen;
+  _.$_$.r1 = numberTimes;
+  _.$_$.s1 = charTimes;
+  _.$_$.t1 = booleanTimes;
+  _.$_$.u1 = stringTimes;
+  _.$_$.v1 = termTimes;
+  _.$_$.w1 = LogicProgrammingScopeWithOperators;
+  _.$_$.x1 = abolish1;
+  _.$_$.y1 = append3;
+  _.$_$.z1 = arg3;
+  _.$_$.a2 = arithEq2;
+  _.$_$.b2 = arithNeq2;
+  _.$_$.c2 = asserta1;
+  _.$_$.d2 = assertz1;
+  _.$_$.e2 = assert1;
+  _.$_$.f2 = at_end_of_stream1;
+  _.$_$.g2 = atom_chars2;
+  _.$_$.h2 = atom_codes2;
+  _.$_$.i2 = atom_concat3;
+  _.$_$.j2 = atom_length2;
+  _.$_$.k2 = atomic1;
+  _.$_$.l2 = atom1;
+  _.$_$.m2 = bagof3;
+  _.$_$.n2 = between3;
+  _.$_$.o2 = callable1;
+  _.$_$.p2 = call1;
+  _.$_$.q2 = catch3;
+  _.$_$.r2 = char_code2;
+  _.$_$.s2 = clause2;
+  _.$_$.t2 = compound1;
+  _.$_$.u2 = consult1;
+  _.$_$.v2 = copy_term2;
+  _.$_$.w2 = current_flag2;
+  _.$_$.x2 = current_op3;
+  _.$_$.y2 = current_prolog_flag2;
+  _.$_$.z2 = dynamic1;
+  _.$_$.a3 = eq2;
+  _.$_$.b3 = findall3;
+  _.$_$.c3 = float1;
+  _.$_$.d3 = functor3;
+  _.$_$.e3 = ground1;
+  _.$_$.f3 = id2;
+  _.$_$.g3 = include1;
+  _.$_$.h3 = initialization1;
+  _.$_$.i3 = integer1;
+  _.$_$.j3 = load1;
+  _.$_$.k3 = member2;
+  _.$_$.l3 = naf1;
+  _.$_$.m3 = natural;
+  _.$_$.n3 = neq2;
+  _.$_$.o3 = nid2;
+  _.$_$.p3 = nonvar1;
+  _.$_$.q3 = not1;
+  _.$_$.r3 = number_chars2;
+  _.$_$.s3 = number_codes2;
+  _.$_$.t3 = number1;
+  _.$_$.u3 = op3;
+  _.$_$.v3 = retractall1;
+  _.$_$.w3 = retract1;
+  _.$_$.x3 = set_flag2;
+  _.$_$.y3 = set_prolog_flag2;
+  _.$_$.z3 = setof3;
+  _.$_$.a4 = solve1;
+  _.$_$.b4 = static1;
+  _.$_$.c4 = sub_atom5;
+  _.$_$.d4 = throw1;
+  _.$_$.e4 = univ2;
+  _.$_$.f4 = var1;
+  _.$_$.g4 = write1;
+  _.$_$.h4 = LogicProgrammingScopeWithPrologStandardLibrary;
+  _.$_$.i4 = substitutionContainsKey;
+  _.$_$.j4 = substitutionContainsValue;
+  _.$_$.k4 = substitutionContains;
+  _.$_$.l4 = substitutionGet;
+  _.$_$.m4 = stringTo;
+  _.$_$.n4 = varTo;
+  _.$_$.o4 = LogicProgrammingScopeWithSubstitutions;
+  _.$_$.p4 = blockOfAny;
+  _.$_$.q4 = consOfAny;
+  _.$_$.r4 = directiveOfAny;
+  _.$_$.s4 = directive;
+  _.$_$.t4 = factOfAny;
+  _.$_$.u4 = fact;
+  _.$_$.v4 = stringInvoke;
+  _.$_$.w4 = logicListOfAny;
+  _.$_$.x4 = logicList;
+  _.$_$.y4 = rule;
+  _.$_$.z4 = withScope;
+  _.$_$.a5 = structOfAny;
+  _.$_$.b5 = tupleOfAny;
+  _.$_$.c5 = MinimalLogicProgrammingScope;
+  _.$_$.d5 = logicProgramming;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-dsl-core.js.map