npm - @tuprolog/arg2p-core - Versions diffs - 0.17.2 → 0.18.0 - Mend

@tuprolog/arg2p-core 0.17.2 → 0.18.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 (40) hide show

package/2p-core.js +3479 -3225
package/2p-core.js.map +1 -1
package/2p-dsl-core.js +1511 -5
package/2p-dsl-core.js.map +1 -1
package/2p-dsl-solve.js +945 -5
package/2p-dsl-solve.js.map +1 -1
package/2p-dsl-theory.js +791 -5
package/2p-dsl-theory.js.map +1 -1
package/2p-dsl-unify.js +68 -5
package/2p-dsl-unify.js.map +1 -1
package/2p-io-lib.js +3700 -5
package/2p-io-lib.js.map +1 -1
package/2p-parser-core.js +624 -5
package/2p-parser-core.js.map +1 -1
package/2p-parser-impl.js +5647 -5
package/2p-parser-impl.js.map +1 -1
package/2p-parser-theory.js +295 -5
package/2p-parser-theory.js.map +1 -1
package/2p-solve.js +4813 -4264
package/2p-solve.js.map +1 -1
package/2p-theory.js +1486 -1471
package/2p-theory.js.map +1 -1
package/2p-unify.js +362 -359
package/2p-unify.js.map +1 -1
package/2p-utils.js +559 -473
package/2p-utils.js.map +1 -1
package/README.md +26 -19
package/arg2p-core.js +14797 -9
package/arg2p-core.js.map +1 -1
package/kotlin-kotlin-stdlib.js +5015 -2702
package/kotlin-kotlin-stdlib.js.map +1 -1
package/kt-math.js +1542 -1539
package/kt-math.js.map +1 -1
package/okio-parent-okio-nodefilesystem.js +201 -5
package/okio-parent-okio-nodefilesystem.js.map +1 -1
package/okio-parent-okio.js +3863 -5
package/okio-parent-okio.js.map +1 -1
package/package.json +1 -1
package/2p-solve-prolog.js +0 -2854
package/2p-solve-prolog.js.map +0 -1

package/2p-io-lib.js CHANGED Viewed

@@ -1,13 +1,3708 @@
 (function (factory) {
   if (typeof define === 'function' && define.amd)
-    define(['exports'], factory);
+    define(['exports', './kotlin-kotlin-stdlib.js', './2p-parser-impl.js', './2p-solve.js', './2p-parser-core.js', './2p-core.js', './okio-parent-okio.js', './2p-parser-theory.js', './2p-theory.js', './okio-parent-okio-nodefilesystem.js'], factory);
   else if (typeof exports === 'object')
-    factory(module.exports);
-  else
-    globalThis['2p-io-lib'] = factory(typeof globalThis['2p-io-lib'] === 'undefined' ? {} : globalThis['2p-io-lib']);
-}(function (_) {
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-parser-impl.js'), require('./2p-solve.js'), require('./2p-parser-core.js'), require('./2p-core.js'), require('./okio-parent-okio.js'), require('./2p-parser-theory.js'), require('./2p-theory.js'), require('./okio-parent-okio-nodefilesystem.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['2p-parser-impl'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-parser-impl' was not found. Please, check whether '2p-parser-impl' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['2p-solve'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-solve' was not found. Please, check whether '2p-solve' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['2p-parser-core'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-parser-core' was not found. Please, check whether '2p-parser-core' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['2p-core'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['okio-parent-okio'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency 'okio-parent-okio' was not found. Please, check whether 'okio-parent-okio' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['2p-parser-theory'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-parser-theory' was not found. Please, check whether '2p-parser-theory' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['2p-theory'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-theory' was not found. Please, check whether '2p-theory' is loaded prior to '2p-io-lib'.");
+    }
+    if (typeof globalThis['okio-parent-okio-nodefilesystem'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency 'okio-parent-okio-nodefilesystem' was not found. Please, check whether 'okio-parent-okio-nodefilesystem' is loaded prior to '2p-io-lib'.");
+    }
+    globalThis['2p-io-lib'] = factory(typeof globalThis['2p-io-lib'] === 'undefined' ? {} : globalThis['2p-io-lib'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-parser-impl'], globalThis['2p-solve'], globalThis['2p-parser-core'], globalThis['2p-core'], globalThis['okio-parent-okio'], globalThis['2p-parser-theory'], globalThis['2p-theory'], globalThis['okio-parent-okio-nodefilesystem']);
+  }
+}(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_parser_impl, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_parser_core, kotlin_it_unibo_tuprolog_core, kotlin_com_squareup_okio_okio, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_theory, kotlin_com_squareup_okio_okio_nodefilesystem) {
   'use strict';
+  //region block: imports
+  var VOID = kotlin_kotlin.$_$.b;
+  var buildParserFor = kotlin_it_unibo_tuprolog_parser_impl.$_$.a1;
+  var Companion_instance = kotlin_it_unibo_tuprolog_solve.$_$.s;
+  var Unit_instance = kotlin_kotlin.$_$.r;
+  var protoOf = kotlin_kotlin.$_$.d8;
+  var equals = kotlin_kotlin.$_$.j7;
+  var FunctionAdapter = kotlin_kotlin.$_$.y6;
+  var isInterface = kotlin_kotlin.$_$.x7;
+  var TextChunkSource = kotlin_it_unibo_tuprolog_parser_impl.$_$.y;
+  var hashCode = kotlin_kotlin.$_$.p7;
+  var initMetadataForClass = kotlin_kotlin.$_$.q7;
+  var CoroutineImpl = kotlin_kotlin.$_$.e6;
+  var THROW_CCE = kotlin_kotlin.$_$.nc;
+  var SequenceScope = kotlin_kotlin.$_$.y8;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.d6;
+  var toParseException = kotlin_it_unibo_tuprolog_parser_core.$_$.j;
+  var PrologSyntaxException = kotlin_it_unibo_tuprolog_parser_impl.$_$.n;
+  var initMetadataForLambda = kotlin_kotlin.$_$.t7;
+  var constructCallableReference = kotlin_kotlin.$_$.h7;
+  var toOperatorTable = kotlin_it_unibo_tuprolog_parser_core.$_$.i;
+  var Companion_instance_0 = kotlin_it_unibo_tuprolog_core.$_$.t;
+  var PrologTermParserVisitor = kotlin_it_unibo_tuprolog_parser_core.$_$.b;
+  var sequence = kotlin_kotlin.$_$.da;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.a1;
+  var AbstractLibrary = kotlin_it_unibo_tuprolog_solve.$_$.o2;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.k1;
+  var listOf = kotlin_kotlin.$_$.f4;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.x2;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.t;
+  var to = kotlin_kotlin.$_$.bd;
+  var initMetadataForObject = kotlin_kotlin.$_$.u7;
+  var Companion_instance_1 = kotlin_kotlin.$_$.p;
+  var asSequence = kotlin_kotlin.$_$.t2;
+  var map = kotlin_kotlin.$_$.v9;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.k;
+  var toSet = kotlin_kotlin.$_$.la;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.r7;
+  var THROW_IAE = kotlin_kotlin.$_$.oc;
+  var enumEntries = kotlin_kotlin.$_$.f6;
+  var Enum = kotlin_kotlin.$_$.dc;
+  var toString = kotlin_kotlin.$_$.g8;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.n1;
+  var startsWith = kotlin_kotlin.$_$.kb;
+  var initMetadataForInterface = kotlin_kotlin.$_$.s7;
+  var AbstractOutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.h2;
+  var AbstractInputChannel = kotlin_it_unibo_tuprolog_solve.$_$.g2;
+  var ArrayDeque_init_$Create$ = kotlin_kotlin.$_$.s;
+  var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.c;
+  var Char__toInt_impl_vasixd = kotlin_kotlin.$_$.g;
+  var numberToChar = kotlin_kotlin.$_$.a8;
+  var Char = kotlin_kotlin.$_$.ac;
+  var toString_0 = kotlin_kotlin.$_$.h;
+  var TuPrologException_init_$Init$ = kotlin_it_unibo_tuprolog_core.$_$.h1;
+  var objectCreate = kotlin_kotlin.$_$.c8;
+  var captureStack = kotlin_kotlin.$_$.a7;
+  var TuPrologException_init_$Init$_0 = kotlin_it_unibo_tuprolog_core.$_$.i1;
+  var TuPrologException = kotlin_it_unibo_tuprolog_core.$_$.l1;
+  var Companion_instance_2 = kotlin_it_unibo_tuprolog_solve.$_$.d1;
+  var Companion_instance_3 = kotlin_it_unibo_tuprolog_solve.$_$.e1;
+  var Expected_URL_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.q;
+  var Predicative = kotlin_it_unibo_tuprolog_solve.$_$.t2;
+  var Predicative_0 = kotlin_it_unibo_tuprolog_solve.$_$.z2;
+  var NonBacktrackable = kotlin_it_unibo_tuprolog_solve.$_$.q2;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_solve.$_$.m1;
+  var InputChannel = kotlin_it_unibo_tuprolog_solve.$_$.i2;
+  var OutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.j2;
+  var NonBacktrackable_0 = kotlin_it_unibo_tuprolog_solve.$_$.y2;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.q1;
+  var IllegalStateException = kotlin_kotlin.$_$.gc;
+  var Atom = kotlin_it_unibo_tuprolog_core.$_$.o1;
+  var KProperty1 = kotlin_kotlin.$_$.x8;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.n7;
+  var sequenceOf = kotlin_kotlin.$_$.ba;
+  var flatMap = kotlin_kotlin.$_$.m9;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.u;
+  var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.b1;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.z;
+  var Companion_instance_4 = kotlin_it_unibo_tuprolog_core.$_$.p;
+  var filter = kotlin_kotlin.$_$.j9;
+  var Sequence = kotlin_kotlin.$_$.z8;
+  var firstOrNull = kotlin_kotlin.$_$.k9;
+  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.u;
+  var asSequence_0 = kotlin_kotlin.$_$.s2;
+  var addAll = kotlin_kotlin.$_$.k2;
+  var toList = kotlin_kotlin.$_$.o5;
+  var Struct = kotlin_it_unibo_tuprolog_core.$_$.b2;
+  var Companion_instance_5 = kotlin_it_unibo_tuprolog_solve.$_$.u;
+  var filterNot = kotlin_kotlin.$_$.i9;
+  var Truth = kotlin_it_unibo_tuprolog_core.$_$.b3;
+  var lazy = kotlin_kotlin.$_$.wc;
+  var Companion_instance_6 = kotlin_it_unibo_tuprolog_solve.$_$.x;
+  var Expected_STREAM_PROPERTY_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.g;
+  var Expected_WRITE_OPTION_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.i;
+  var Expected_READ_OPTION_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.d;
+  var List = kotlin_it_unibo_tuprolog_core.$_$.w1;
+  var Var = kotlin_it_unibo_tuprolog_core.$_$.d3;
+  var FuncFormat_LITERAL_getInstance = kotlin_it_unibo_tuprolog_core.$_$.b;
+  var FuncFormat_QUOTED_IF_NECESSARY_getInstance = kotlin_it_unibo_tuprolog_core.$_$.c;
+  var OpFormat_EXPRESSIONS_getInstance = kotlin_it_unibo_tuprolog_core.$_$.d;
+  var OpFormat_IGNORE_OPERATORS_getInstance = kotlin_it_unibo_tuprolog_core.$_$.e;
+  var Companion_instance_7 = kotlin_it_unibo_tuprolog_core.$_$.y;
+  var VarFormat_UNDERSCORE_getInstance = kotlin_it_unibo_tuprolog_core.$_$.f;
+  var Expected_SOURCE_SINK_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.e;
+  var Expected_IO_MODE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.b;
+  var Companion_instance_8 = kotlin_it_unibo_tuprolog_solve.$_$.y;
+  var Expected_STREAM_OR_ALIAS_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.f;
+  var Expected_IN_CHARACTER_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.o;
+  var Companion_instance_9 = kotlin_it_unibo_tuprolog_solve.$_$.b1;
+  var Limit_CHARACTER_CODE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.k;
+  var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_core.$_$.o;
+  var Integer = kotlin_it_unibo_tuprolog_core.$_$.v1;
+  var KtMap = kotlin_kotlin.$_$.h2;
+  var Expected_STREAM_TYPE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.h;
+  var format = kotlin_it_unibo_tuprolog_core.$_$.e3;
+  var charCodeAt = kotlin_kotlin.$_$.d7;
+  var emptyList = kotlin_kotlin.$_$.l3;
+  var get_lastIndex = kotlin_kotlin.$_$.z3;
+  var toList_0 = kotlin_kotlin.$_$.ja;
+  var last = kotlin_kotlin.$_$.b4;
+  var Companion_instance_10 = kotlin_it_unibo_tuprolog_solve.$_$.c1;
+  var ParseException = kotlin_it_unibo_tuprolog_parser_core.$_$.a;
+  var emptySet = kotlin_kotlin.$_$.n3;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.xc;
+  var ObjectType_SOURCE_SINK_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.j;
+  var ExistenceError_init_$Create$ = kotlin_it_unibo_tuprolog_solve.$_$.c2;
+  var FileNotFoundException = kotlin_com_squareup_okio_okio.$_$.d;
+  var NonBacktrackable_1 = kotlin_it_unibo_tuprolog_solve.$_$.w2;
+  var NonBacktrackable_2 = kotlin_it_unibo_tuprolog_solve.$_$.u2;
+  var Companion_instance_11 = kotlin_it_unibo_tuprolog_parser_theory.$_$.a;
+  var Companion_instance_12 = kotlin_it_unibo_tuprolog_theory.$_$.b;
+  var Companion_instance_13 = kotlin_it_unibo_tuprolog_theory.$_$.a;
+  var charSequenceLength = kotlin_kotlin.$_$.f7;
+  var titlecase = kotlin_kotlin.$_$.qb;
+  var isLowerCase = kotlin_kotlin.$_$.ya;
+  var substring = kotlin_kotlin.$_$.ob;
+  var BinaryRelation = kotlin_it_unibo_tuprolog_solve.$_$.s2;
+  var distinct = kotlin_kotlin.$_$.e9;
+  var removeSuffix = kotlin_kotlin.$_$.eb;
+  var toIntOrNull = kotlin_kotlin.$_$.tb;
+  var removePrefix = kotlin_kotlin.$_$.cb;
+  var buffer = kotlin_com_squareup_okio_okio.$_$.g;
+  var addSuppressed = kotlin_kotlin.$_$.qc;
+  var IOException = kotlin_com_squareup_okio_okio.$_$.f;
+  var getStringHashCode = kotlin_kotlin.$_$.o7;
+  var KProperty0 = kotlin_kotlin.$_$.w8;
+  var Info_getInstance = kotlin_it_unibo_tuprolog_core.$_$.d1;
+  var Platform_BROWSER_getInstance = kotlin_it_unibo_tuprolog_core.$_$.g;
+  var Companion_getInstance_7 = kotlin_com_squareup_okio_okio.$_$.a;
+  var buffer_0 = kotlin_com_squareup_okio_okio.$_$.h;
+  var NodeJsFileSystem_getInstance = kotlin_com_squareup_okio_okio_nodefilesystem.$_$.a;
+  //endregion
   //region block: pre-declaration
+  initMetadataForClass(sam$it_unibo_tuprolog_parser_TextChunkSource$0, 'sam$it_unibo_tuprolog_parser_TextChunkSource$0', VOID, VOID, [TextChunkSource, FunctionAdapter]);
+  initMetadataForLambda(asTermChannel$lambda$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForObject(IOLib, 'IOLib', VOID, AbstractLibrary);
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(IOMode, 'IOMode', VOID, Enum);
+  initMetadataForObject(LocalFileSystem, 'LocalFileSystem');
+  initMetadataForCompanion(Companion_0);
+  function resolve(child) {
+    return Companion_instance_15.k3u(this.o3u(), this.p3u(), this.r3u(), this.q3u() + '/' + child, this.w1z());
+  }
+  function div(child) {
+    return this.resolve(child);
+  }
+  function get_isFile() {
+    return this.o3u() === 'file';
+  }
+  function get_isHttp() {
+    return startsWith(this.o3u(), 'http');
+  }
+  initMetadataForInterface(Url, 'Url');
+  initMetadataForClass(SinkOutputChannel, 'SinkOutputChannel', VOID, AbstractOutputChannel);
+  initMetadataForClass(SourceInputChannel, 'SourceInputChannel', VOID, AbstractInputChannel);
+  initMetadataForClass(IOException_0, 'IOException', VOID, TuPrologException);
+  initMetadataForClass(InvalidUrlException, 'InvalidUrlException', VOID, TuPrologException);
+  initMetadataForObject(AtEndOfStream0, 'AtEndOfStream0', VOID, Predicative);
+  initMetadataForObject(AtEndOfStream1, 'AtEndOfStream1', VOID, Predicative_0);
+  initMetadataForObject(CharConversion, 'CharConversion', VOID, NonBacktrackable);
+  initMetadataForObject(Close1, 'Close1', VOID, NonBacktrackable_0);
+  initMetadataForObject(Close2, 'Close2', VOID, NonBacktrackable);
+  initMetadataForObject(Consult, 'Consult', VOID, NonBacktrackable_0);
+  initMetadataForObject(CurrentCharConversion, 'CurrentCharConversion', VOID, NonBacktrackable);
+  initMetadataForObject(CurrentInput, 'CurrentInput', VOID, NonBacktrackable_0);
+  initMetadataForObject(CurrentOutput, 'CurrentOutput', VOID, NonBacktrackable_0);
+  initMetadataForObject(FlushOutput, 'FlushOutput', VOID, NonBacktrackable_0);
+  initMetadataForObject(GetByte1, 'GetByte1', VOID, NonBacktrackable_0);
+  initMetadataForObject(GetByte2, 'GetByte2', VOID, NonBacktrackable);
+  initMetadataForObject(GetChar1, 'GetChar1', VOID, NonBacktrackable_0);
+  initMetadataForObject(GetChar2, 'GetChar2', VOID, NonBacktrackable);
+  initMetadataForObject(GetCode1, 'GetCode1', VOID, NonBacktrackable_0);
+  initMetadataForObject(GetCode2, 'GetCode2', VOID, NonBacktrackable);
+  initMetadataForLambda(IOPrimitiveUtils$propertiesOf$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForObject(IOPrimitiveUtils, 'IOPrimitiveUtils');
+  initMetadataForObject(Nl1, 'Nl1', VOID, NonBacktrackable_0);
+  initMetadataForObject(Open3, 'Open3', VOID, NonBacktrackable_1);
+  initMetadataForObject(Open4, 'Open4', VOID, NonBacktrackable_2);
+  initMetadataForObject(PeekByte1, 'PeekByte1', VOID, NonBacktrackable_0);
+  initMetadataForObject(PeekByte2, 'PeekByte2', VOID, NonBacktrackable);
+  initMetadataForObject(PeekChar1, 'PeekChar1', VOID, NonBacktrackable_0);
+  initMetadataForObject(PeekChar2, 'PeekChar2', VOID, NonBacktrackable);
+  initMetadataForObject(PeekCode1, 'PeekCode1', VOID, NonBacktrackable_0);
+  initMetadataForObject(PeekCode2, 'PeekCode2', VOID, NonBacktrackable);
+  initMetadataForObject(PutByte1, 'PutByte1', VOID, NonBacktrackable_0);
+  initMetadataForObject(PutByte2, 'PutByte2', VOID, NonBacktrackable);
+  initMetadataForObject(PutChar1, 'PutChar1', VOID, NonBacktrackable_0);
+  initMetadataForObject(PutChar2, 'PutChar2', VOID, NonBacktrackable);
+  initMetadataForObject(PutCode1, 'PutCode1', VOID, NonBacktrackable_0);
+  initMetadataForObject(PutCode2, 'PutCode2', VOID, NonBacktrackable);
+  initMetadataForObject(Read1, 'Read1', VOID, NonBacktrackable_0);
+  initMetadataForObject(Read2, 'Read2', VOID, NonBacktrackable);
+  initMetadataForObject(ReadTerm2, 'ReadTerm2', VOID, NonBacktrackable);
+  initMetadataForObject(ReadTerm3, 'ReadTerm3', VOID, NonBacktrackable_1);
+  initMetadataForObject(SetInput, 'SetInput', VOID, NonBacktrackable_0);
+  initMetadataForObject(SetOutput, 'SetOutput', VOID, NonBacktrackable_0);
+  initMetadataForObject(SetTheory, 'SetTheory', VOID, NonBacktrackable_0);
+  initMetadataForObject(StreamProperty, 'StreamProperty', VOID, BinaryRelation);
+  initMetadataForObject(Write2, 'Write2', VOID, NonBacktrackable);
+  initMetadataForObject(WriteCanonical1, 'WriteCanonical1', VOID, NonBacktrackable_0);
+  initMetadataForObject(WriteCanonical2, 'WriteCanonical2', VOID, NonBacktrackable);
+  initMetadataForObject(WriteEq1, 'WriteEq1', VOID, NonBacktrackable_0);
+  initMetadataForObject(WriteEq2, 'WriteEq2', VOID, NonBacktrackable);
+  initMetadataForObject(WriteTerm2, 'WriteTerm2', VOID, NonBacktrackable);
+  initMetadataForObject(WriteTerm3, 'WriteTerm3', VOID, NonBacktrackable_1);
+  initMetadataForClass(JsUrl, 'JsUrl', VOID, VOID, [Url]);
+  //endregion
+  function get_cache() {
+    _init_properties_ChannelUtils_kt__fqios2();
+    return cache;
+  }
+  var cache;
+  function asTermChannel(_this__u8e3s4, operators) {
+    _init_properties_ChannelUtils_kt__fqios2();
+    // Inline function 'kotlin.collections.getOrPut' call
+    var this_0 = get_cache();
+    var value = this_0.k2(_this__u8e3s4);
+    var tmp;
+    if (value == null) {
+      var tmp_0 = asTermChannel$lambda(_this__u8e3s4);
+      var tmp_1 = new sam$it_unibo_tuprolog_parser_TextChunkSource$0(tmp_0);
+      var termIterator = buildParserFor(tmp_1, VOID, VOID, asTermChannel$lambda_0(operators)).n();
+      var tmp_2 = Companion_instance;
+      var tmp_3 = asTermChannel$lambda_1(termIterator);
+      var answer = tmp_2.ofWithAvailabilityChecker(tmp_3, Iterator$hasNext$ref(termIterator));
+      this_0.t4(_this__u8e3s4, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    return tmp;
+  }
+  function sam$it_unibo_tuprolog_parser_TextChunkSource$0(function_0) {
+    this.p3t_1 = function_0;
+  }
+  protoOf(sam$it_unibo_tuprolog_parser_TextChunkSource$0).x3e = function () {
+    return this.p3t_1();
+  };
+  protoOf(sam$it_unibo_tuprolog_parser_TextChunkSource$0).s2 = function () {
+    return this.p3t_1;
+  };
+  protoOf(sam$it_unibo_tuprolog_parser_TextChunkSource$0).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, TextChunkSource) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.s2(), other.s2());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(sam$it_unibo_tuprolog_parser_TextChunkSource$0).hashCode = function () {
+    return hashCode(this.s2());
+  };
+  function asTermChannel$lambda($this_asTermChannel) {
+    return function () {
+      return $this_asTermChannel.read();
+    };
+  }
+  function asTermChannel$lambda$slambda($session, $visitor, $lexedSource, resultContinuation) {
+    this.y3t_1 = $session;
+    this.z3t_1 = $visitor;
+    this.a3u_1 = $lexedSource;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(asTermChannel$lambda$slambda).d1r = function ($this$sequence, $completion) {
+    var tmp = this.e1r($this$sequence, $completion);
+    tmp.t8_1 = Unit_instance;
+    tmp.u8_1 = null;
+    return tmp.z8();
+  };
+  protoOf(asTermChannel$lambda$slambda).q9 = function (p1, $completion) {
+    return this.d1r(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(asTermChannel$lambda$slambda).z8 = function () {
+    var suspendResult = this.t8_1;
+    $sm: do
+      try {
+        var tmp = this.r8_1;
+        switch (tmp) {
+          case 0:
+            this.s8_1 = 6;
+            this.s8_1 = 5;
+            this.c3u_1 = this.y3t_1.p3m();
+            this.r8_1 = 1;
+            continue $sm;
+          case 1:
+            if (!!(this.c3u_1 == null)) {
+              this.r8_1 = 3;
+              continue $sm;
+            }
+            this.r8_1 = 2;
+            suspendResult = this.b3u_1.bf(this.c3u_1.v3r_1.d3o(this.z3t_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          case 2:
+            this.c3u_1 = this.y3t_1.p3m();
+            this.r8_1 = 1;
+            continue $sm;
+          case 3:
+            this.s8_1 = 6;
+            this.r8_1 = 4;
+            continue $sm;
+          case 4:
+            this.s8_1 = 6;
+            return Unit_instance;
+          case 5:
+            this.s8_1 = 6;
+            var tmp_0 = this.u8_1;
+            if (tmp_0 instanceof PrologSyntaxException) {
+              var e = this.u8_1;
+              var it = this.a3u_1.m3j();
+              var tmp0_elvis_lhs = it.e16();
+              var input = tmp0_elvis_lhs == null ? it.t3h() : tmp0_elvis_lhs;
+              throw toParseException(e, input);
+            } else {
+              throw this.u8_1;
+            }
+          case 6:
+            throw this.u8_1;
+        }
+      } catch ($p) {
+        var e_0 = $p;
+        if (this.s8_1 === 6) {
+          throw e_0;
+        } else {
+          this.r8_1 = this.s8_1;
+          this.u8_1 = e_0;
+        }
+      }
+     while (true);
+  };
+  protoOf(asTermChannel$lambda$slambda).e1r = function ($this$sequence, completion) {
+    var i = new asTermChannel$lambda$slambda(this.y3t_1, this.z3t_1, this.a3u_1, completion);
+    i.b3u_1 = $this$sequence;
+    return i;
+  };
+  function asTermChannel$lambda$slambda_0($session, $visitor, $lexedSource, resultContinuation) {
+    var i = new asTermChannel$lambda$slambda($session, $visitor, $lexedSource, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.d1r($this$sequence, $completion);
+    }, 1);
+  }
+  function asTermChannel$lambda_0($operators) {
+    return function (parser, lexedSource) {
+      var session = parser.t3m(lexedSource, toOperatorTable($operators));
+      var visitor = new PrologTermParserVisitor(Companion_instance_0.empty());
+      return sequence(asTermChannel$lambda$slambda_0(session, visitor, lexedSource, null));
+    };
+  }
+  function asTermChannel$lambda_1($termIterator) {
+    return function () {
+      return $termIterator.q() ? $termIterator.r() : null;
+    };
+  }
+  function Iterator$hasNext$ref(p0) {
+    return constructCallableReference(function () {
+      return p0.q();
+    }, 0, 0, 84, 'hasNext', [p0]);
+  }
+  var properties_initialized_ChannelUtils_kt_an3chc;
+  function _init_properties_ChannelUtils_kt__fqios2() {
+    if (!properties_initialized_ChannelUtils_kt_an3chc) {
+      properties_initialized_ChannelUtils_kt_an3chc = true;
+      // Inline function 'kotlin.collections.mutableMapOf' call
+      cache = LinkedHashMap_init_$Create$();
+    }
+  }
+  function IOLib() {
+    IOLib_instance = this;
+    AbstractLibrary.call(this);
+    this.e3u_1 = "`library('prolog.io')`\n\nProvides the ISO Prolog stream-based input/output predicates. Streams are opened on files or URLs via `open/3,4` and are denoted by aliases (e.g. `user_input`, `user_output`) or by `$stream(Direction, Id)` terms; `close/1`, `current_input/1`, `current_output/1`, `set_input/1`, `set_output/1`, `stream_property/2`, `at_end_of_stream/0,1` and `flush_output/1` manage them. Only text streams are supported, and writing is only possible to local files on the JVM.\n\nCharacter-level I/O is offered by `get_char/1,2`, `get_code/1,2`, `peek_char/1,2`, `peek_code/1,2`, `put_char/1,2`, `put_code/1,2` and `nl/1`, while term-level I/O is offered by `read/1,2`, `read_term/2,3`, `write/2`, `writeq/1,2`, `write_canonical/1,2` and `write_term/2,3`; the variants without a stream argument use the current input or output stream. The tuProlog-specific `consult/1` adds the clauses of a theory loaded from a file or URL to the knowledge base, whereas `set_theory/1` replaces the knowledge base with a theory given as source text.\n\nThe byte-oriented predicates (`get_byte/1,2`, `peek_byte/1,2`, `put_byte/1,2`), the character conversion predicates (`char_conversion/2`, `current_char_conversion/2`) and `close/2` are registered for ISO conformance, but are not supported: calling them always raises a system error.";
+  }
+  protoOf(IOLib).w1x = function () {
+    return this.e3u_1;
+  };
+  protoOf(IOLib).z2i = function () {
+    return 'prolog.io';
+  };
+  protoOf(IOLib).u2i = function () {
+    var tmp = Companion_getInstance();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = listOf([AtEndOfStream0_getInstance(), AtEndOfStream1_getInstance(), CharConversion_getInstance(), Close1_getInstance(), Close2_getInstance(), Consult_getInstance(), CurrentCharConversion_getInstance(), CurrentInput_getInstance(), CurrentOutput_getInstance(), FlushOutput_getInstance(), GetByte1_getInstance(), GetByte2_getInstance(), GetChar1_getInstance(), GetChar2_getInstance(), GetCode1_getInstance(), GetCode2_getInstance(), Nl1_getInstance(), Open3_getInstance(), Open4_getInstance(), PeekByte1_getInstance(), PeekByte2_getInstance(), PeekChar1_getInstance(), PeekChar2_getInstance(), PeekCode1_getInstance(), PeekCode2_getInstance(), PutByte1_getInstance(), PutByte2_getInstance(), PutChar1_getInstance(), PutChar2_getInstance(), PutCode1_getInstance(), PutCode2_getInstance(), Read1_getInstance(), Read2_getInstance(), ReadTerm2_getInstance(), ReadTerm3_getInstance(), SetInput_getInstance(), SetOutput_getInstance(), SetTheory_getInstance(), StreamProperty_getInstance(), Write2_getInstance(), WriteCanonical1_getInstance(), WriteCanonical2_getInstance(), WriteEq1_getInstance(), WriteEq2_getInstance(), WriteTerm2_getInstance(), WriteTerm3_getInstance()]);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.n();
+    while (_iterator__ex2g4s.q()) {
+      var item = _iterator__ex2g4s.r();
+      // Inline function 'it.unibo.tuprolog.solve.AbstractWrapper.descriptionPair' call
+      var tmp$ret$2 = to(item.signature, item.u1x());
+      destination.l(tmp$ret$2);
+    }
+    return tmp.iterableToMapEnsuringNoDuplicates(destination);
+  };
+  var IOLib_instance;
+  function IOLib_getInstance() {
+    if (IOLib_instance == null)
+      new IOLib();
+    return IOLib_instance;
+  }
+  function IOMode$Companion$atomValues$lambda(it) {
+    // Inline function 'kotlin.text.lowercase' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return it.n2_1.toLowerCase();
+  }
+  function Atom$Companion$of$ref(p0) {
+    return constructCallableReference(function (p0_0) {
+      return p0.of(p0_0);
+    }, 1, 0, 85, 'of', [p0]);
+  }
+  var static_init_called;
+  function static_init() {
+    if (static_init_called)
+      return Unit_instance;
+    static_init_called = true;
+    IOMode_READ_instance = new IOMode('READ', 0);
+    IOMode_WRITE_instance = new IOMode('WRITE', 1);
+    IOMode_APPEND_instance = new IOMode('APPEND', 2);
+    if (Companion_instance_14 == null) {
+      Companion_instance_1;
+      new Companion();
+    }
+  }
+  var IOMode_READ_instance;
+  var IOMode_WRITE_instance;
+  var IOMode_APPEND_instance;
+  function Companion() {
+    Companion_instance_14 = this;
+    var tmp = this;
+    var tmp_0 = asSequence(get_entries());
+    var tmp_1 = map(tmp_0, IOMode$Companion$atomValues$lambda);
+    tmp.f3u_1 = toSet(map(tmp_1, Atom$Companion$of$ref(Companion_getInstance_0())));
+  }
+  var Companion_instance_14;
+  function Companion_getInstance_8() {
+    static_init();
+    return Companion_instance_14;
+  }
+  function values() {
+    static_init();
+    return [IOMode_READ_getInstance(), IOMode_WRITE_getInstance(), IOMode_APPEND_getInstance()];
+  }
+  function valueOf(value) {
+    static_init();
+    switch (value) {
+      case 'READ':
+        return IOMode_READ_getInstance();
+      case 'WRITE':
+        return IOMode_WRITE_getInstance();
+      case 'APPEND':
+        return IOMode_APPEND_getInstance();
+      default:
+        THROW_IAE('No enum constant it.unibo.tuprolog.solve.libs.io.IOMode.' + value);
+        break;
+    }
+  }
+  function get_entries() {
+    static_init();
+    if ($ENTRIES == null)
+      $ENTRIES = enumEntries(values());
+    return $ENTRIES;
+  }
+  var $ENTRIES;
+  function IOMode(name, ordinal) {
+    Enum.call(this, name, ordinal);
+  }
+  function IOMode_READ_getInstance() {
+    static_init();
+    return IOMode_READ_instance;
+  }
+  function IOMode_WRITE_getInstance() {
+    static_init();
+    return IOMode_WRITE_instance;
+  }
+  function IOMode_APPEND_getInstance() {
+    static_init();
+    return IOMode_APPEND_instance;
+  }
+  function LocalFileSystem() {
+    LocalFileSystem_instance = this;
+    this.g3u_1 = get_platformFileSystem();
+  }
+  protoOf(LocalFileSystem).k3c = function (path) {
+    return this.g3u_1.k3c(path);
+  };
+  protoOf(LocalFileSystem).l3c = function (path, mustCreate) {
+    return this.g3u_1.l3c(path, mustCreate);
+  };
+  protoOf(LocalFileSystem).h3u = function (path, mustCreate, $super) {
+    mustCreate = mustCreate === VOID ? false : mustCreate;
+    return $super === VOID ? this.l3c(path, mustCreate) : $super.l3c.call(this, path, mustCreate);
+  };
+  protoOf(LocalFileSystem).m3c = function (path, mustExist) {
+    return this.g3u_1.m3c(path, mustExist);
+  };
+  protoOf(LocalFileSystem).i3u = function (path, mustExist, $super) {
+    mustExist = mustExist === VOID ? false : mustExist;
+    return $super === VOID ? this.m3c(path, mustExist) : $super.m3c.call(this, path, mustExist);
+  };
+  var LocalFileSystem_instance;
+  function LocalFileSystem_getInstance() {
+    if (LocalFileSystem_instance == null)
+      new LocalFileSystem();
+    return LocalFileSystem_instance;
+  }
+  function str($this, $receiver, transformation) {
+    var tmp;
+    if (transformation === VOID) {
+      tmp = Url$Companion$str$lambda;
+    } else {
+      tmp = transformation;
+    }
+    transformation = tmp;
+    return $receiver == null ? '' : transformation($receiver);
+  }
+  function Url$Companion$str$lambda(it) {
+    return toString(it);
+  }
+  function Url$Companion$toString$lambda(it) {
+    return ':' + it;
+  }
+  function Url$Companion$toString$lambda_0(it) {
+    return '?' + it;
+  }
+  function Companion_0() {
+  }
+  protoOf(Companion_0).j3u = function (_this__u8e3s4) {
+    var tmp;
+    if (_this__u8e3s4 < 0) {
+      throw IllegalArgumentException_init_$Create$('Invalid port: ' + _this__u8e3s4);
+    } else {
+      tmp = _this__u8e3s4;
+    }
+    return tmp;
+  };
+  protoOf(Companion_0).file = function (path) {
+    return fileUrl(path);
+  };
+  protoOf(Companion_0).k3u = function (protocol, host, port, path, query) {
+    return remoteUrl(protocol, host, port, path, query);
+  };
+  protoOf(Companion_0).remote = function (protocol, host, port, path, query, $super) {
+    host = host === VOID ? '' : host;
+    port = port === VOID ? null : port;
+    path = path === VOID ? '' : path;
+    query = query === VOID ? null : query;
+    return $super === VOID ? this.k3u(protocol, host, port, path, query) : $super.k3u.call(this, protocol, host, port, path, query);
+  };
+  protoOf(Companion_0).l3u = function (host, port, path, query) {
+    return this.k3u('http', host, port, path, query);
+  };
+  protoOf(Companion_0).http = function (host, port, path, query, $super) {
+    host = host === VOID ? '' : host;
+    port = port === VOID ? null : port;
+    path = path === VOID ? '' : path;
+    query = query === VOID ? null : query;
+    return $super === VOID ? this.l3u(host, port, path, query) : $super.l3u.call(this, host, port, path, query);
+  };
+  protoOf(Companion_0).m3u = function (host, port, path, query) {
+    return this.k3u('https', host, port, path, query);
+  };
+  protoOf(Companion_0).https = function (host, port, path, query, $super) {
+    host = host === VOID ? '' : host;
+    port = port === VOID ? null : port;
+    path = path === VOID ? '' : path;
+    query = query === VOID ? null : query;
+    return $super === VOID ? this.m3u(host, port, path, query) : $super.m3u.call(this, host, port, path, query);
+  };
+  protoOf(Companion_0).of = function (string) {
+    var tmp;
+    try {
+      tmp = parseUrl(string);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof InvalidUrlException) {
+        var e = $p;
+        var tmp_1;
+        try {
+          tmp_1 = parseUrl('file://' + string);
+        } catch ($p_0) {
+          var tmp_2;
+          if ($p_0 instanceof InvalidUrlException) {
+            var _unused_var__etf5q3 = $p_0;
+            throw e;
+          } else {
+            throw $p_0;
+          }
+        }
+        tmp_0 = tmp_1;
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(Companion_0).n3u = function (protocol, host, port, path, query) {
+    var tmp = port == null ? null : this.j3u(port);
+    var tmp_0 = str(this, tmp, Url$Companion$toString$lambda);
+    return protocol + '://' + host + tmp_0 + path + str(this, query, Url$Companion$toString$lambda_0);
+  };
+  var Companion_instance_15;
+  function Companion_getInstance_9() {
+    return Companion_instance_15;
+  }
+  function Url() {
+  }
+  function SinkOutputChannel(sink) {
+    AbstractOutputChannel.call(this);
+    this.y3u_1 = sink;
+  }
+  protoOf(SinkOutputChannel).z3u = function (value) {
+    this.y3u_1.p3b(value);
+  };
+  protoOf(SinkOutputChannel).r23 = function (value) {
+    return this.z3u(typeof value === 'string' ? value : THROW_CCE());
+  };
+  protoOf(SinkOutputChannel).s23 = function () {
+    this.y3u_1.o8();
+  };
+  protoOf(SinkOutputChannel).z22 = function () {
+    this.y3u_1.z22();
+    protoOf(AbstractOutputChannel).z22.call(this);
+  };
+  protoOf(SinkOutputChannel).close = function () {
+    return this.z22();
+  };
+  function SourceInputChannel(source) {
+    AbstractInputChannel.call(this);
+    this.f3v_1 = source;
+    this.g3v_1 = ArrayDeque_init_$Create$();
+  }
+  protoOf(SourceInputChannel).k23 = function () {
+    if (this.g3v_1.i()) {
+      if (this.f3v_1.x3b())
+        return null;
+      var codePoint = this.f3v_1.e3d();
+      // Inline function 'kotlin.code' call
+      var this_0 = _Char___init__impl__6a9atx(65535);
+      if (codePoint > Char__toInt_impl_vasixd(this_0)) {
+        var offset = codePoint - 65536 | 0;
+        this.g3v_1.wd(new Char(numberToChar((offset >> 10) + 55296 | 0)));
+        this.g3v_1.wd(new Char(numberToChar((offset & 1023) + 56320 | 0)));
+      } else {
+        this.g3v_1.wd(new Char(numberToChar(codePoint)));
+      }
+    }
+    return toString_0(this.g3v_1.xd().p1_1);
+  };
+  protoOf(SourceInputChannel).z22 = function () {
+    this.f3v_1.z22();
+    protoOf(AbstractInputChannel).z22.call(this);
+  };
+  protoOf(SourceInputChannel).close = function () {
+    return this.z22();
+  };
+  function IOException_init_$Init$(message, $this) {
+    TuPrologException_init_$Init$(message, $this);
+    IOException_0.call($this);
+    return $this;
+  }
+  function IOException_init_$Create$(message) {
+    var tmp = IOException_init_$Init$(message, objectCreate(protoOf(IOException_0)));
+    captureStack(tmp, IOException_init_$Create$);
+    return tmp;
+  }
+  function IOException_init_$Init$_0(message, cause, $this) {
+    TuPrologException_init_$Init$_0(message, cause, $this);
+    IOException_0.call($this);
+    return $this;
+  }
+  function IOException_init_$Create$_0(message, cause) {
+    var tmp = IOException_init_$Init$_0(message, cause, objectCreate(protoOf(IOException_0)));
+    captureStack(tmp, IOException_init_$Create$_0);
+    return tmp;
+  }
+  protoOf(IOException_0).h3v = function (context) {
+    return Companion_instance_2.forUncaughtKtException(context, this);
+  };
+  function IOException_0() {
+    captureStack(this, IOException_0);
+  }
+  function InvalidUrlException_init_$Init$(message, $this) {
+    TuPrologException_init_$Init$(message, $this);
+    InvalidUrlException.call($this);
+    return $this;
+  }
+  function InvalidUrlException_init_$Create$(message) {
+    var tmp = InvalidUrlException_init_$Init$(message, objectCreate(protoOf(InvalidUrlException)));
+    captureStack(tmp, InvalidUrlException_init_$Create$);
+    return tmp;
+  }
+  function InvalidUrlException_init_$Init$_0(message, cause, $this) {
+    TuPrologException_init_$Init$_0(message, cause, $this);
+    InvalidUrlException.call($this);
+    return $this;
+  }
+  function InvalidUrlException_init_$Create$_0(message, cause) {
+    var tmp = InvalidUrlException_init_$Init$_0(message, cause, objectCreate(protoOf(InvalidUrlException)));
+    captureStack(tmp, InvalidUrlException_init_$Create$_0);
+    return tmp;
+  }
+  protoOf(InvalidUrlException).i3v = function (context, signature, culprit, index) {
+    return Companion_instance_3.o2b(context, signature, Expected_URL_getInstance(), culprit, index);
+  };
+  function InvalidUrlException() {
+    captureStack(this, InvalidUrlException);
+  }
+  function AtEndOfStream0() {
+    AtEndOfStream0_instance = this;
+    Predicative.call(this, 'at_end_of_stream');
+    this.k3v_1 = '`at_end_of_stream`\n\nSucceeds iff the current input stream (standard input, unless changed via `set_input/1`) is closed or has no more characters to read, and fails otherwise. It is deterministic and raises no errors.\n\n**Examples**\n\n```prolog\n% with `foo.` still to be read from standard input\n?- at_end_of_stream.\nno.\n\n% once standard input has been exhausted\n?- at_end_of_stream.\nyes.\n```';
+  }
+  protoOf(AtEndOfStream0).w1x = function () {
+    return this.k3v_1;
+  };
+  protoOf(AtEndOfStream0).l3v = function (_this__u8e3s4) {
+    // Inline function 'kotlin.let' call
+    var it = IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4);
+    return it.l22() || it.yr();
+  };
+  protoOf(AtEndOfStream0).j2l = function (_this__u8e3s4) {
+    return this.l3v(_this__u8e3s4);
+  };
+  var AtEndOfStream0_instance;
+  function AtEndOfStream0_getInstance() {
+    if (AtEndOfStream0_instance == null)
+      new AtEndOfStream0();
+    return AtEndOfStream0_instance;
+  }
+  function AtEndOfStream1() {
+    AtEndOfStream1_instance = this;
+    Predicative_0.call(this, 'at_end_of_stream');
+    this.f3w_1 = '`at_end_of_stream(+Stream)`\n\nSucceeds iff the input stream `Stream` is closed or has no more characters to read, and fails otherwise. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error.\n\n**Examples**\n\n```prolog\n?- at_end_of_stream(user_output).\nthrows error(domain_error(stream_type, user_output), _).\n\n?- at_end_of_stream(S).\nthrows error(instantiation_error, _).\n\n?- at_end_of_stream(no_such_stream).\nthrows error(existence_error(source_sink, no_such_stream), _).\n```';
+  }
+  protoOf(AtEndOfStream1).w1x = function () {
+    return this.f3w_1;
+  };
+  protoOf(AtEndOfStream1).g3w = function (_this__u8e3s4, first) {
+    // Inline function 'kotlin.let' call
+    var it = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    return it.l22() || it.yr();
+  };
+  protoOf(AtEndOfStream1).x2n = function (_this__u8e3s4, first) {
+    return this.g3w(_this__u8e3s4, first);
+  };
+  var AtEndOfStream1_instance;
+  function AtEndOfStream1_getInstance() {
+    if (AtEndOfStream1_instance == null)
+      new AtEndOfStream1();
+    return AtEndOfStream1_instance;
+  }
+  function CharConversion() {
+    CharConversion_instance = this;
+    NonBacktrackable.call(this, 'char_conversion');
+    this.j3w_1 = '`char_conversion(+InChar, +OutChar)`\n\nRegistered for ISO conformance only: the current implementation does not support a character conversion table, so every call raises a system error regardless of its arguments.\n\n**Examples**\n\n```prolog\n?- char_conversion(a, b).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(CharConversion).w1x = function () {
+    return this.j3w_1;
+  };
+  protoOf(CharConversion).z2u = function (_this__u8e3s4, first, second) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(CharConversion).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var CharConversion_instance;
+  function CharConversion_getInstance() {
+    if (CharConversion_instance == null)
+      new CharConversion();
+    return CharConversion_instance;
+  }
+  function Close1$computeOne$lambda($this_computeOne, $channel) {
+    return function ($this$replySuccess) {
+      var tmp = $this_computeOne.context.l1y();
+      $this$replySuccess.e2r(tmp.aliasesOf(isInterface($channel, InputChannel) ? $channel : THROW_CCE()));
+      return Unit_instance;
+    };
+  }
+  function Close1$computeOne$lambda_0($this_computeOne, $channel) {
+    return function ($this$replySuccess) {
+      var tmp = $this_computeOne.context.m1y();
+      $this$replySuccess.h2r(tmp.aliasesOf(isInterface($channel, OutputChannel) ? $channel : THROW_CCE()));
+      return Unit_instance;
+    };
+  }
+  function Close1() {
+    Close1_instance = this;
+    NonBacktrackable_0.call(this, 'close');
+    this.l3w_1 = '`close(+Stream)`\n\nCloses the stream `Stream`, given as an alias or a `$stream(Direction, Id)` term, and unregisters every alias it was reachable through, succeeding deterministically. It raises an instantiation error if `Stream` is unbound, an existence error if it does not denote an open stream, and a domain error (`stream_or_alias`) if it is a compound term other than a stream term. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- close(S).\nthrows error(instantiation_error, _).\n\n?- close(no_such_stream).\nthrows error(existence_error(source_sink, no_such_stream), _).\n\n?- close(foo(bar)).\nthrows error(domain_error(stream_or_alias, foo(bar)), _).\n```';
+  }
+  protoOf(Close1).w1x = function () {
+    return this.l3w_1;
+  };
+  protoOf(Close1).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().m3w(_this__u8e3s4, 0);
+    try {
+      channel.close();
+      var tmp;
+      if (isInterface(channel, InputChannel)) {
+        tmp = _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, Close1$computeOne$lambda(_this__u8e3s4, channel));
+      } else {
+        if (isInterface(channel, OutputChannel)) {
+          tmp = _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, Close1$computeOne$lambda_0(_this__u8e3s4, channel));
+        } else {
+          throw IllegalStateException_init_$Create$('This should never happen');
+        }
+      }
+      return tmp;
+    } catch ($p) {
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        return _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+    }
+  };
+  protoOf(Close1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var Close1_instance;
+  function Close1_getInstance() {
+    if (Close1_instance == null)
+      new Close1();
+    return Close1_instance;
+  }
+  function Close2() {
+    Close2_instance = this;
+    NonBacktrackable.call(this, 'close');
+    this.o3w_1 = '`close(+Stream, +Options)`\n\nRegistered for ISO conformance only: the current implementation does not support close options such as `force(true)`, so every call raises a system error regardless of its arguments; use `close/1` instead.\n\n**Examples**\n\n```prolog\n?- close(user_output, [force(true)]).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(Close2).w1x = function () {
+    return this.o3w_1;
+  };
+  protoOf(Close2).z2u = function (_this__u8e3s4, first, second) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(Close2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var Close2_instance;
+  function Close2_getInstance() {
+    if (Close2_instance == null)
+      new Close2();
+    return Close2_instance;
+  }
+  function Consult() {
+    Consult_instance = this;
+    NonBacktrackable_0.call(this, 'consult');
+    this.q3w_1 = "`consult(+Source)`\n\nLoads the Prolog theory found at `Source`, an atom holding either a URL (e.g. `'https://example.com/theory.pl'`) or a plain absolute or relative file path, parsing it with the current operators. This tuProlog-specific predicate adds the loaded clauses to the knowledge base without removing any existing clause (so consulting the same source twice duplicates its clauses), with clauses of predicates declared dynamic going to the dynamic knowledge base and all others to the static one; operators and flags set by the theory's directives take effect as well. It raises an instantiation error if `Source` is unbound, a type error (`atom`) if it is not an atom, a type error (`url`) if it is not a valid URL or path, a system error if the resource cannot be read, and a syntax error if its content is not a well-formed theory.\n\n**Examples**\n\n```prolog\n% with /path/to/family.pl containing `parent(tom, bob).`\n?- consult('/path/to/family.pl'), parent(tom, X).\nX = bob.\n\n?- consult(F).\nthrows error(instantiation_error, _).\n\n?- consult(42).\nthrows error(type_error(atom, 42), _).\n\n?- consult('/no/such/theory.pl').\nthrows error(system_error, _).\n```";
+  }
+  protoOf(Consult).w1x = function () {
+    return this.q3w_1;
+  };
+  protoOf(Consult).i2u = function (_this__u8e3s4, first) {
+    Companion_getInstance_1().s2l(_this__u8e3s4, 0);
+    Companion_getInstance_1().b2m(_this__u8e3s4, 0);
+    var urlString = (isInterface(first, Atom) ? first : THROW_CCE()).h2();
+    try {
+      var url = Companion_instance_15.of(urlString);
+      var text = url.readAsText();
+      return SetTheory_getInstance().t3w(_this__u8e3s4, text);
+    } catch ($p) {
+      if ($p instanceof InvalidUrlException) {
+        var e = $p;
+        throw e.i3v(_this__u8e3s4.context, _this__u8e3s4.signature, first, 0);
+      } else {
+        if ($p instanceof IOException_0) {
+          var e_0 = $p;
+          throw e_0.h3v(_this__u8e3s4.context);
+        } else {
+          throw $p;
+        }
+      }
+    }
+  };
+  protoOf(Consult).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var Consult_instance;
+  function Consult_getInstance() {
+    if (Consult_instance == null)
+      new Consult();
+    return Consult_instance;
+  }
+  function CurrentCharConversion() {
+    CurrentCharConversion_instance = this;
+    NonBacktrackable.call(this, 'current_char_conversion');
+    this.v3w_1 = '`current_char_conversion(?InChar, ?OutChar)`\n\nRegistered for ISO conformance only: since character conversion is not supported (see `char_conversion/2`), the current implementation raises a system error on every call regardless of its arguments.\n\n**Examples**\n\n```prolog\n?- current_char_conversion(X, Y).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(CurrentCharConversion).w1x = function () {
+    return this.v3w_1;
+  };
+  protoOf(CurrentCharConversion).z2u = function (_this__u8e3s4, first, second) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(CurrentCharConversion).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var CurrentCharConversion_instance;
+  function CurrentCharConversion_getInstance() {
+    if (CurrentCharConversion_instance == null)
+      new CurrentCharConversion();
+    return CurrentCharConversion_instance;
+  }
+  function CurrentInput() {
+    CurrentInput_instance = this;
+    NonBacktrackable_0.call(this, 'current_input');
+    this.x3w_1 = '`current_input(?Stream)`\n\nUnifies `Stream` with the `$stream(in, Id)` term of the current input stream (standard input, unless changed via `set_input/1`); if `Stream` is already a stream term, it succeeds iff that term denotes the current input stream. It is deterministic. It raises an existence error if `Stream` is a stream term denoting no open stream, and a domain error (`stream_or_alias`) if it is bound to anything else, aliases included.\n\n**Examples**\n\n```prolog\n?- current_input(S), stream_property(S, alias(user_input)).\nyes.\n\n?- current_input(user_input).\nthrows error(domain_error(stream_or_alias, user_input), _).\n```';
+  }
+  protoOf(CurrentInput).w1x = function () {
+    return this.x3w_1;
+  };
+  protoOf(CurrentInput).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().y3w(_this__u8e3s4, 0);
+    // Inline function 'kotlin.let' call
+    var it = _this__u8e3s4.context.l1y();
+    var tmp0_elvis_lhs = it.wr();
+    var currentChannel = tmp0_elvis_lhs == null ? it.v1y() : tmp0_elvis_lhs;
+    return channel == null ? _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, first, currentChannel.m22()), VOID, []) : equals(channel, currentChannel) ? _this__u8e3s4.replySuccess(VOID, VOID, []) : _this__u8e3s4.replyFail(VOID, []);
+  };
+  protoOf(CurrentInput).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var CurrentInput_instance;
+  function CurrentInput_getInstance() {
+    if (CurrentInput_instance == null)
+      new CurrentInput();
+    return CurrentInput_instance;
+  }
+  function CurrentOutput() {
+    CurrentOutput_instance = this;
+    NonBacktrackable_0.call(this, 'current_output');
+    this.a3x_1 = '`current_output(?Stream)`\n\nUnifies `Stream` with the `$stream(out, Id)` term of the current output stream (standard output, unless changed via `set_output/1`); if `Stream` is already a stream term, it succeeds iff that term denotes the current output stream. It is deterministic. It raises an existence error if `Stream` is a stream term denoting no open stream, and a domain error (`stream_or_alias`) if it is bound to anything else, aliases included.\n\n**Examples**\n\n```prolog\n?- current_output(S), stream_property(S, alias(user_output)).\nyes.\n\n?- current_output(S), write(S, hello).\n% prints: hello\nyes.\n\n?- current_output(user_output).\nthrows error(domain_error(stream_or_alias, user_output), _).\n```';
+  }
+  protoOf(CurrentOutput).w1x = function () {
+    return this.a3x_1;
+  };
+  protoOf(CurrentOutput).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().y3w(_this__u8e3s4, 0);
+    // Inline function 'kotlin.let' call
+    var it = _this__u8e3s4.context.m1y();
+    var tmp0_elvis_lhs = it.wr();
+    var currentChannel = tmp0_elvis_lhs == null ? it.w1y() : tmp0_elvis_lhs;
+    return channel == null ? _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, first, currentChannel.m22()), VOID, []) : equals(channel, currentChannel) ? _this__u8e3s4.replySuccess(VOID, VOID, []) : _this__u8e3s4.replyFail(VOID, []);
+  };
+  protoOf(CurrentOutput).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var CurrentOutput_instance;
+  function CurrentOutput_getInstance() {
+    if (CurrentOutput_instance == null)
+      new CurrentOutput();
+    return CurrentOutput_instance;
+  }
+  function FlushOutput() {
+    FlushOutput_instance = this;
+    NonBacktrackable_0.call(this, 'flush_output');
+    this.c3x_1 = '`flush_output(+Stream)`\n\nForces any buffered output of the output stream `Stream` to be written to its destination, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write(user_output, hello), flush_output(user_output).\n% prints: hello\nyes.\n\n?- flush_output(user_input).\nthrows error(domain_error(stream_type, user_input), _).\n```';
+  }
+  protoOf(FlushOutput).w1x = function () {
+    return this.c3x_1;
+  };
+  protoOf(FlushOutput).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    var tmp;
+    try {
+      channel.flush();
+      tmp = _this__u8e3s4.replySuccess(VOID, VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(FlushOutput).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var FlushOutput_instance;
+  function FlushOutput_getInstance() {
+    if (FlushOutput_instance == null)
+      new FlushOutput();
+    return FlushOutput_instance;
+  }
+  function GetByte1() {
+    GetByte1_instance = this;
+    NonBacktrackable_0.call(this, 'get_byte');
+    this.f3x_1 = '`get_byte(?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `get_code/1` instead.\n\n**Examples**\n\n```prolog\n?- get_byte(B).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(GetByte1).w1x = function () {
+    return this.f3x_1;
+  };
+  protoOf(GetByte1).i2u = function (_this__u8e3s4, first) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(GetByte1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var GetByte1_instance;
+  function GetByte1_getInstance() {
+    if (GetByte1_instance == null)
+      new GetByte1();
+    return GetByte1_instance;
+  }
+  function GetByte2() {
+    GetByte2_instance = this;
+    NonBacktrackable.call(this, 'get_byte');
+    this.h3x_1 = '`get_byte(+Stream, ?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `get_code/2` instead.\n\n**Examples**\n\n```prolog\n?- get_byte(user_input, B).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(GetByte2).w1x = function () {
+    return this.h3x_1;
+  };
+  protoOf(GetByte2).z2u = function (_this__u8e3s4, first, second) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(GetByte2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var GetByte2_instance;
+  function GetByte2_getInstance() {
+    if (GetByte2_instance == null)
+      new GetByte2();
+    return GetByte2_instance;
+  }
+  function GetChar1() {
+    GetChar1_instance = this;
+    NonBacktrackable_0.call(this, 'get_char');
+    this.j3x_1 = '`get_char(?Char)`\n\nReads and consumes the next character from the current input stream (standard input, unless changed via `set_input/1`) and unifies it with `Char`, which becomes `end_of_file` at the end of the stream. It is deterministic. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_char(ab).\nthrows error(type_error(in_character, ab), _).\n\n?- get_char(1).\nthrows error(type_error(in_character, 1), _).\n```';
+  }
+  protoOf(GetChar1).w1x = function () {
+    return this.j3x_1;
+  };
+  protoOf(GetChar1).i2u = function (_this__u8e3s4, first) {
+    IOPrimitiveUtils_getInstance().k3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().l3x(_this__u8e3s4, IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4), first);
+  };
+  protoOf(GetChar1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var GetChar1_instance;
+  function GetChar1_getInstance() {
+    if (GetChar1_instance == null)
+      new GetChar1();
+    return GetChar1_instance;
+  }
+  function GetChar2() {
+    GetChar2_instance = this;
+    NonBacktrackable.call(this, 'get_char');
+    this.n3x_1 = '`get_char(+Stream, ?Char)`\n\nReads and consumes the next character from the input stream `Stream` and unifies it with `Char`, which becomes `end_of_file` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_char(user_input, ab).\nthrows error(type_error(in_character, ab), _).\n\n?- get_char(S, C).\nthrows error(instantiation_error, _).\n\n?- get_char(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
+  }
+  protoOf(GetChar2).w1x = function () {
+    return this.n3x_1;
+  };
+  protoOf(GetChar2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    IOPrimitiveUtils_getInstance().k3x(_this__u8e3s4, 1);
+    return IOPrimitiveUtils_getInstance().l3x(_this__u8e3s4, channel, second);
+  };
+  protoOf(GetChar2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var GetChar2_instance;
+  function GetChar2_getInstance() {
+    if (GetChar2_instance == null)
+      new GetChar2();
+    return GetChar2_instance;
+  }
+  function GetCode1() {
+    GetCode1_instance = this;
+    NonBacktrackable_0.call(this, 'get_code');
+    this.p3x_1 = '`get_code(?Code)`\n\nReads and consumes the next character from the current input stream (standard input, unless changed via `set_input/1`) and unifies its code with `Code`, which becomes `-1` at the end of the stream. It is deterministic. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_code(a).\nthrows error(type_error(integer, a), _).\n\n?- get_code(-2).\nthrows error(representation_error(character_code), _).\n```';
+  }
+  protoOf(GetCode1).w1x = function () {
+    return this.p3x_1;
+  };
+  protoOf(GetCode1).i2u = function (_this__u8e3s4, first) {
+    IOPrimitiveUtils_getInstance().q3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().r3x(_this__u8e3s4, IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4), first);
+  };
+  protoOf(GetCode1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var GetCode1_instance;
+  function GetCode1_getInstance() {
+    if (GetCode1_instance == null)
+      new GetCode1();
+    return GetCode1_instance;
+  }
+  function GetCode2() {
+    GetCode2_instance = this;
+    NonBacktrackable.call(this, 'get_code');
+    this.t3x_1 = '`get_code(+Stream, ?Code)`\n\nReads and consumes the next character from the input stream `Stream` and unifies its code with `Code`, which becomes `-1` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_code(user_input, a).\nthrows error(type_error(integer, a), _).\n\n?- get_code(S, C).\nthrows error(instantiation_error, _).\n\n?- get_code(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
+  }
+  protoOf(GetCode2).w1x = function () {
+    return this.t3x_1;
+  };
+  protoOf(GetCode2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    IOPrimitiveUtils_getInstance().q3x(_this__u8e3s4, 1);
+    return IOPrimitiveUtils_getInstance().r3x(_this__u8e3s4, channel, second);
+  };
+  protoOf(GetCode2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var GetCode2_instance;
+  function GetCode2_getInstance() {
+    if (GetCode2_instance == null)
+      new GetCode2();
+    return GetCode2_instance;
+  }
+  function IOPrimitiveUtils$propertiesOf$slambda$lambda(it) {
+    return it === '$current';
+  }
+  function IOPrimitiveUtils$alias$ref(p0) {
+    return constructCallableReference(function (p0_0) {
+      var tmp0 = p0;
+      return alias(tmp0, p0_0);
+    }, 1, 0, 86, 'alias', [p0]);
+  }
+  function IOPrimitiveUtils$propertiesOf$slambda$lambda_0(it) {
+    return it === '$current';
+  }
+  function _get_INPUT_STREAM_TERM_PATTERN__5fd8p6($this) {
+    var tmp0 = $this.m3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_OUTPUT_STREAM_TERM_PATTERN__4vocxf($this) {
+    var tmp0 = $this.n3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_TYPE_PATTERN__5nq864($this) {
+    var tmp0 = $this.o3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_REPOSITION_PATTERN__lznuii($this) {
+    var tmp0 = $this.p3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_EOF_ACTION_PATTERN__8k2shv($this) {
+    var tmp0 = $this.q3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_ALIAS_PATTERN__wipd2s($this) {
+    var tmp0 = $this.r3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_INPUT__z2zr91($this) {
+    var tmp0 = $this.s3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_OUTPUT__1pem9m($this) {
+    var tmp0 = $this.t3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_TYPE_TEXT__9rpcwt($this) {
+    var tmp0 = $this.u3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_REPOSITION_FALSE__i73t3b($this) {
+    var tmp0 = $this.v3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_PROPERTY_EOF_ACTION_EOF_CODE__he3pvl($this) {
+    var tmp0 = $this.w3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_OPTION_QUOTED_PATTERN__n2ri42($this) {
+    var tmp0 = $this.x3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_OPTION_NUMBER_VARS_PATTERN__p98ste($this) {
+    var tmp0 = $this.y3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_OPTION_IGNORE_OPS_PATTERN__cpse4v($this) {
+    var tmp0 = $this.z3v_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_INFO_VARIABLES_PATTERN__bhp1h0($this) {
+    var tmp0 = $this.a3w_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_INFO_VARIABLE_NAMES_PATTERN__j3oaom($this) {
+    var tmp0 = $this.b3w_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_INFO_SINGLETONS_PATTERN__y21s87($this) {
+    var tmp0 = $this.c3w_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  function _get_validPropertiesPattern__7s1t06($this) {
+    return sequenceOf([_get_PROPERTY_INPUT__z2zr91($this), _get_PROPERTY_OUTPUT__1pem9m($this), _get_PROPERTY_ALIAS_PATTERN__wipd2s($this), _get_PROPERTY_TYPE_PATTERN__5nq864($this), _get_PROPERTY_EOF_ACTION_PATTERN__8k2shv($this), _get_PROPERTY_REPOSITION_PATTERN__lznuii($this)]);
+  }
+  function _get_validOptionsPattern__akhsd9($this) {
+    var tmp = IOPrimitiveUtils$quoted$ref($this);
+    var tmp_0 = IOPrimitiveUtils$ignoreOps$ref($this);
+    var tmp_1 = sequenceOf([tmp, tmp_0, IOPrimitiveUtils$numberVars$ref($this)]);
+    return flatMap(tmp_1, IOPrimitiveUtils$_get_validOptionsPattern_$lambda_r088xw);
+  }
+  function _get_validInfoPattern__dtwgth($this) {
+    return sequenceOf([_get_INFO_VARIABLES_PATTERN__bhp1h0($this), _get_INFO_VARIABLE_NAMES_PATTERN__j3oaom($this), _get_INFO_SINGLETONS_PATTERN__y21s87($this)]);
+  }
+  function _get_supportedPropertiesPattern__x8u7bw($this) {
+    return sequenceOf([_get_PROPERTY_INPUT__z2zr91($this), _get_PROPERTY_OUTPUT__1pem9m($this), _get_PROPERTY_ALIAS_PATTERN__wipd2s($this), _get_PROPERTY_TYPE_TEXT__9rpcwt($this), _get_PROPERTY_EOF_ACTION_EOF_CODE__he3pvl($this), _get_PROPERTY_REPOSITION_FALSE__i73t3b($this)]);
+  }
+  function alias($this, alias) {
+    alias = alias === VOID ? null : alias;
+    var tmp = Companion_getInstance_2();
+    var tmp_0;
+    if (alias == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = Companion_getInstance_0().of(alias);
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp.of('alias', [tmp1_elvis_lhs == null ? Companion_getInstance_3().anonymous() : tmp1_elvis_lhs]);
+  }
+  function quoted($this, value) {
+    value = value === VOID ? null : value;
+    var tmp = Companion_getInstance_2();
+    var tmp_0;
+    if (value == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = Companion_getInstance_4().of(value);
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp.of('quoted', [tmp1_elvis_lhs == null ? Companion_getInstance_3().anonymous() : tmp1_elvis_lhs]);
+  }
+  function ignoreOps($this, value) {
+    value = value === VOID ? null : value;
+    var tmp = Companion_getInstance_2();
+    var tmp_0;
+    if (value == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = Companion_getInstance_4().of(value);
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp.of('ignore_ops', [tmp1_elvis_lhs == null ? Companion_getInstance_3().anonymous() : tmp1_elvis_lhs]);
+  }
+  function numberVars($this, value) {
+    value = value === VOID ? null : value;
+    var tmp = Companion_getInstance_2();
+    var tmp_0;
+    if (value == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = Companion_getInstance_4().of(value);
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp.of('numbervars', [tmp1_elvis_lhs == null ? Companion_getInstance_3().anonymous() : tmp1_elvis_lhs]);
+  }
+  function variables($this, variables) {
+    variables = variables === VOID ? null : variables;
+    var tmp = Companion_getInstance_2();
+    var tmp_0;
+    if (variables == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = Companion_instance_4.ofList(variables);
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp.of('variables', [tmp1_elvis_lhs == null ? Companion_getInstance_3().anonymous() : tmp1_elvis_lhs]);
+  }
+  function vn($this, functor, vNames) {
+    vNames = vNames === VOID ? null : vNames;
+    var tmp = Companion_getInstance_2();
+    var tmp_0;
+    if (vNames == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.collections.map' call
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(vNames, 10));
+      var _iterator__ex2g4s = vNames.n();
+      while (_iterator__ex2g4s.q()) {
+        var item = _iterator__ex2g4s.r();
+        var a = item.he();
+        var v = item.ie();
+        var tmp$ret$2 = Companion_getInstance_2().of('=', [a, v]);
+        destination.l(tmp$ret$2);
+      }
+      tmp_0 = destination;
+    }
+    var tmp1_safe_receiver = tmp_0;
+    var tmp_1;
+    if (tmp1_safe_receiver == null) {
+      tmp_1 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_1 = Companion_instance_4.ofList(tmp1_safe_receiver);
+    }
+    var tmp2_elvis_lhs = tmp_1;
+    return tmp.of(functor, [tmp2_elvis_lhs == null ? Companion_getInstance_3().anonymous() : tmp2_elvis_lhs]);
+  }
+  function variableNames($this, vNames) {
+    vNames = vNames === VOID ? null : vNames;
+    return vn($this, 'variable_names', vNames);
+  }
+  function singletons($this, vNames) {
+    vNames = vNames === VOID ? null : vNames;
+    return vn($this, 'singletons', vNames);
+  }
+  function getOption($this, $receiver, unificator, pattern) {
+    // Inline function 'kotlin.sequences.filterIsInstance' call
+    var this_0 = asSequence($receiver);
+    var tmp = filter(this_0, IOPrimitiveUtils$getOption$lambda);
+    var tmp_0 = isInterface(tmp, Sequence) ? tmp : THROW_CCE();
+    var tmp_1 = filter(tmp_0, IOPrimitiveUtils$getOption$lambda_0(unificator, pattern));
+    // Inline function 'kotlin.sequences.filterIsInstance' call
+    var this_1 = map(tmp_1, IOPrimitiveUtils$getOption$lambda_1);
+    var tmp_2 = filter(this_1, IOPrimitiveUtils$getOption$lambda_2);
+    var tmp_3 = isInterface(tmp_2, Sequence) ? tmp_2 : THROW_CCE();
+    var tmp0_elvis_lhs = firstOrNull(map(tmp_3, IOPrimitiveUtils$getOption$lambda_3));
+    return tmp0_elvis_lhs == null ? false : tmp0_elvis_lhs;
+  }
+  function getInfo($this, $receiver, unificator, pattern, value) {
+    // Inline function 'kotlin.sequences.filterIsInstance' call
+    var this_0 = asSequence($receiver);
+    var tmp = filter(this_0, IOPrimitiveUtils$getInfo$lambda);
+    var tmp0 = isInterface(tmp, Sequence) ? tmp : THROW_CCE();
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.sequences.firstOrNull' call
+      var _iterator__ex2g4s = tmp0.n();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        if (unificator.match(pattern, element)) {
+          tmp$ret$1 = element;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = null;
+    }
+    var tmp0_safe_receiver = tmp$ret$1;
+    var tmp_0;
+    if (tmp0_safe_receiver == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = unificator.mgu(tmp0_safe_receiver, value);
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp1_elvis_lhs == null ? Companion_getInstance_5().empty() : tmp1_elvis_lhs;
+  }
+  function _get_singletons__bihqrn($this, $receiver) {
+    // Inline function 'kotlin.sequences.groupBy' call
+    var tmp0 = $receiver.gx();
+    // Inline function 'kotlin.sequences.groupByTo' call
+    var destination = LinkedHashMap_init_$Create$();
+    var _iterator__ex2g4s = tmp0.n();
+    while (_iterator__ex2g4s.q()) {
+      var element = _iterator__ex2g4s.r();
+      var key = element;
+      // Inline function 'kotlin.collections.getOrPut' call
+      var value = destination.k2(key);
+      var tmp;
+      if (value == null) {
+        var answer = ArrayList_init_$Create$_0();
+        destination.t4(key, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      var list = tmp;
+      list.l(element);
+    }
+    var tmp_0 = asSequence_0(destination);
+    var tmp_1 = filter(tmp_0, IOPrimitiveUtils$_get_singletons_$lambda_kke618);
+    return toSet(map(tmp_1, IOPrimitiveUtils$_get_singletons_$lambda_kke618_0));
+  }
+  function toAssignments($this, $receiver) {
+    return toAssignments_0($this, asSequence($receiver));
+  }
+  function toAssignments_0($this, $receiver) {
+    // Inline function 'kotlin.sequences.groupBy' call
+    // Inline function 'kotlin.sequences.groupByTo' call
+    var destination = LinkedHashMap_init_$Create$();
+    var _iterator__ex2g4s = $receiver.n();
+    while (_iterator__ex2g4s.q()) {
+      var element = _iterator__ex2g4s.r();
+      var key = Companion_getInstance_0().of(element.p2());
+      // Inline function 'kotlin.collections.getOrPut' call
+      var value = destination.k2(key);
+      var tmp;
+      if (value == null) {
+        var answer = ArrayList_init_$Create$_0();
+        destination.t4(key, answer);
+        tmp = answer;
+      } else {
+        tmp = value;
+      }
+      var list = tmp;
+      list.l(element);
+    }
+    // Inline function 'kotlin.collections.flatMap' call
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var destination_0 = ArrayList_init_$Create$_0();
+    // Inline function 'kotlin.collections.iterator' call
+    var _iterator__ex2g4s_0 = destination.d1().n();
+    while (_iterator__ex2g4s_0.q()) {
+      var element_0 = _iterator__ex2g4s_0.r();
+      // Inline function 'kotlin.collections.component1' call
+      var n = element_0.g2();
+      // Inline function 'kotlin.collections.component2' call
+      var vs = element_0.h2();
+      var tmp_0 = asSequence(vs);
+      var list_0 = map(tmp_0, IOPrimitiveUtils$toAssignments$lambda(n));
+      addAll(destination_0, list_0);
+    }
+    return toList(destination_0);
+  }
+  function _get_alias__jw26bj($this, $receiver) {
+    var tmp0_safe_receiver = (!($receiver == null) ? isInterface($receiver, Struct) : false) ? $receiver : null;
+    var tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.getArgAt(0);
+    var tmp1_safe_receiver = (!(tmp == null) ? isInterface(tmp, Atom) : false) ? tmp : null;
+    return tmp1_safe_receiver == null ? null : tmp1_safe_receiver.h2();
+  }
+  function replyOpeningStream($this, $receiver, channel, third, alias) {
+    alias = alias === VOID ? null : alias;
+    var streamTerm = channel.m22();
+    var tmp = Companion_getInstance_1().m2l($receiver, third, streamTerm);
+    return $receiver.replyWithBuildingSideEffects(tmp, VOID, IOPrimitiveUtils$replyOpeningStream$lambda(alias, channel));
+  }
+  function replyOpeningStream_0($this, $receiver, channel, third, alias) {
+    alias = alias === VOID ? null : alias;
+    var streamTerm = channel.m22();
+    var tmp = Companion_getInstance_1().m2l($receiver, third, streamTerm);
+    return $receiver.replyWithBuildingSideEffects(tmp, VOID, IOPrimitiveUtils$replyOpeningStream$lambda_0(alias, channel));
+  }
+  function IOPrimitiveUtils$INPUT_STREAM_TERM_PATTERN$delegate$lambda() {
+    return Companion_instance.streamTerm();
+  }
+  function IOPrimitiveUtils$_get_INPUT_STREAM_TERM_PATTERN_$ref_59oxnp() {
+    return constructCallableReference(function (p0) {
+      return _get_INPUT_STREAM_TERM_PATTERN__5fd8p6(p0);
+    }, 1, 0, 87);
+  }
+  function IOPrimitiveUtils$OUTPUT_STREAM_TERM_PATTERN$delegate$lambda() {
+    return Companion_instance_5.streamTerm();
+  }
+  function IOPrimitiveUtils$_get_OUTPUT_STREAM_TERM_PATTERN_$ref_kcdkmo() {
+    return constructCallableReference(function (p0) {
+      return _get_OUTPUT_STREAM_TERM_PATTERN__4vocxf(p0);
+    }, 1, 0, 88);
+  }
+  function IOPrimitiveUtils$PROPERTY_TYPE_PATTERN$delegate$lambda() {
+    return Companion_getInstance_2().of('type', [Companion_getInstance_3().anonymous()]);
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_TYPE_PATTERN_$ref_qcyh3d() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_TYPE_PATTERN__5nq864(p0);
+    }, 1, 0, 89);
+  }
+  function IOPrimitiveUtils$PROPERTY_REPOSITION_PATTERN$delegate$lambda() {
+    return Companion_getInstance_2().of('reposition', [Companion_getInstance_3().anonymous()]);
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_REPOSITION_PATTERN_$ref_uil93p() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_REPOSITION_PATTERN__lznuii(p0);
+    }, 1, 0, 90);
+  }
+  function IOPrimitiveUtils$PROPERTY_EOF_ACTION_PATTERN$delegate$lambda() {
+    return Companion_getInstance_2().of('eof_action', [Companion_getInstance_3().anonymous()]);
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_EOF_ACTION_PATTERN_$ref_bt8ai0() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_EOF_ACTION_PATTERN__8k2shv(p0);
+    }, 1, 0, 91);
+  }
+  function IOPrimitiveUtils$PROPERTY_ALIAS_PATTERN$delegate$lambda() {
+    return alias(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_ALIAS_PATTERN_$ref_qs5lfb() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_ALIAS_PATTERN__wipd2s(p0);
+    }, 1, 0, 92);
+  }
+  function IOPrimitiveUtils$PROPERTY_INPUT$delegate$lambda() {
+    return Companion_getInstance_0().of('input');
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_INPUT_$ref_hltzoy() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_INPUT__z2zr91(p0);
+    }, 1, 0, 93);
+  }
+  function IOPrimitiveUtils$PROPERTY_OUTPUT$delegate$lambda() {
+    return Companion_getInstance_0().of('output');
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_OUTPUT_$ref_9ccgyp() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_OUTPUT__1pem9m(p0);
+    }, 1, 0, 94);
+  }
+  function IOPrimitiveUtils$PROPERTY_TYPE_TEXT$delegate$lambda() {
+    return Companion_getInstance_2().of('type', [Companion_getInstance_0().of('text')]);
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_TYPE_TEXT_$ref_47hbty() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_TYPE_TEXT__9rpcwt(p0);
+    }, 1, 0, 95);
+  }
+  function IOPrimitiveUtils$PROPERTY_REPOSITION_FALSE$delegate$lambda() {
+    return Companion_getInstance_2().of('reposition', [Companion_getInstance_4().xw_1]);
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_REPOSITION_FALSE_$ref_jx0m6() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_REPOSITION_FALSE__i73t3b(p0);
+    }, 1, 0, 96);
+  }
+  function IOPrimitiveUtils$PROPERTY_EOF_ACTION_EOF_CODE$delegate$lambda() {
+    return Companion_getInstance_2().of('eof_action', [Companion_getInstance_0().of('eof_code')]);
+  }
+  function IOPrimitiveUtils$_get_PROPERTY_EOF_ACTION_EOF_CODE_$ref_1cwy66() {
+    return constructCallableReference(function (p0) {
+      return _get_PROPERTY_EOF_ACTION_EOF_CODE__he3pvl(p0);
+    }, 1, 0, 97);
+  }
+  function IOPrimitiveUtils$OPTION_QUOTED_PATTERN$delegate$lambda() {
+    return quoted(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_OPTION_QUOTED_PATTERN_$ref_nxjfbr() {
+    return constructCallableReference(function (p0) {
+      return _get_OPTION_QUOTED_PATTERN__n2ri42(p0);
+    }, 1, 0, 98);
+  }
+  function IOPrimitiveUtils$OPTION_NUMBER_VARS_PATTERN$delegate$lambda() {
+    return numberVars(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_OPTION_NUMBER_VARS_PATTERN_$ref_pdk9ph() {
+    return constructCallableReference(function (p0) {
+      return _get_OPTION_NUMBER_VARS_PATTERN__p98ste(p0);
+    }, 1, 0, 99);
+  }
+  function IOPrimitiveUtils$OPTION_IGNORE_OPS_PATTERN$delegate$lambda() {
+    return ignoreOps(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_OPTION_IGNORE_OPS_PATTERN_$ref_vvsa9g() {
+    return constructCallableReference(function (p0) {
+      return _get_OPTION_IGNORE_OPS_PATTERN__cpse4v(p0);
+    }, 1, 0, 100);
+  }
+  function IOPrimitiveUtils$INFO_VARIABLES_PATTERN$delegate$lambda() {
+    return variables(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_INFO_VARIABLES_PATTERN_$ref_ih2rd5() {
+    return constructCallableReference(function (p0) {
+      return _get_INFO_VARIABLES_PATTERN__bhp1h0(p0);
+    }, 1, 0, 101);
+  }
+  function IOPrimitiveUtils$INFO_VARIABLE_NAMES_PATTERN$delegate$lambda() {
+    return variableNames(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_INFO_VARIABLE_NAMES_PATTERN_$ref_lzmk91() {
+    return constructCallableReference(function (p0) {
+      return _get_INFO_VARIABLE_NAMES_PATTERN__j3oaom(p0);
+    }, 1, 0, 102);
+  }
+  function IOPrimitiveUtils$INFO_SINGLETONS_PATTERN$delegate$lambda() {
+    return singletons(IOPrimitiveUtils_getInstance());
+  }
+  function IOPrimitiveUtils$_get_INFO_SINGLETONS_PATTERN_$ref_8msi4i() {
+    return constructCallableReference(function (p0) {
+      return _get_INFO_SINGLETONS_PATTERN__y21s87(p0);
+    }, 1, 0, 103);
+  }
+  function IOPrimitiveUtils$quoted$ref(p0) {
+    return constructCallableReference(function (p0_0) {
+      var tmp0 = p0;
+      return quoted(tmp0, p0_0);
+    }, 1, 0, 104, 'quoted', [p0]);
+  }
+  function IOPrimitiveUtils$ignoreOps$ref(p0) {
+    return constructCallableReference(function (p0_0) {
+      var tmp0 = p0;
+      return ignoreOps(tmp0, p0_0);
+    }, 1, 0, 105, 'ignoreOps', [p0]);
+  }
+  function IOPrimitiveUtils$numberVars$ref(p0) {
+    return constructCallableReference(function (p0_0) {
+      var tmp0 = p0;
+      return numberVars(tmp0, p0_0);
+    }, 1, 0, 106, 'numberVars', [p0]);
+  }
+  function IOPrimitiveUtils$_get_validOptionsPattern_$lambda_r088xw(it) {
+    return map(sequenceOf([true, false]), it);
+  }
+  function IOPrimitiveUtils$propertiesOf$slambda($channel, $this_propertiesOf, resultContinuation) {
+    this.c3y_1 = $channel;
+    this.d3y_1 = $this_propertiesOf;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(IOPrimitiveUtils$propertiesOf$slambda).f3y = function ($this$sequence, $completion) {
+    var tmp = this.g3y($this$sequence, $completion);
+    tmp.t8_1 = Unit_instance;
+    tmp.u8_1 = null;
+    return tmp.z8();
+  };
+  protoOf(IOPrimitiveUtils$propertiesOf$slambda).q9 = function (p1, $completion) {
+    return this.f3y(p1 instanceof SequenceScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(IOPrimitiveUtils$propertiesOf$slambda).z8 = function () {
+    var suspendResult = this.t8_1;
+    $sm: do
+      try {
+        var tmp = this.r8_1;
+        switch (tmp) {
+          case 0:
+            this.s8_1 = 7;
+            var tmp0_subject = this.c3y_1;
+            if (isInterface(tmp0_subject, InputChannel)) {
+              this.r8_1 = 3;
+              suspendResult = this.e3y_1.bf(_get_PROPERTY_INPUT__z2zr91(IOPrimitiveUtils_getInstance()), this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              if (isInterface(tmp0_subject, OutputChannel)) {
+                this.r8_1 = 1;
+                suspendResult = this.e3y_1.bf(_get_PROPERTY_OUTPUT__1pem9m(IOPrimitiveUtils_getInstance()), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+                continue $sm;
+              } else {
+                this.r8_1 = 5;
+                continue $sm;
+              }
+            }
+          case 1:
+            this.r8_1 = 2;
+            var tmp_0 = this.d3y_1.context.m1y();
+            var tmp_1 = this.c3y_1;
+            var tmp_2 = tmp_0.aliasesOf(isInterface(tmp_1, OutputChannel) ? tmp_1 : THROW_CCE());
+            var tmp_3 = filterNot(tmp_2, IOPrimitiveUtils$propertiesOf$slambda$lambda_0);
+            suspendResult = this.e3y_1.ef(map(tmp_3, IOPrimitiveUtils$alias$ref(IOPrimitiveUtils_getInstance())), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          case 2:
+            this.r8_1 = 5;
+            continue $sm;
+          case 3:
+            this.r8_1 = 4;
+            var tmp_4 = this.d3y_1.context.l1y();
+            var tmp_5 = this.c3y_1;
+            var tmp_6 = tmp_4.aliasesOf(isInterface(tmp_5, InputChannel) ? tmp_5 : THROW_CCE());
+            var tmp_7 = filterNot(tmp_6, IOPrimitiveUtils$propertiesOf$slambda$lambda);
+            suspendResult = this.e3y_1.ef(map(tmp_7, IOPrimitiveUtils$alias$ref(IOPrimitiveUtils_getInstance())), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          case 4:
+            this.r8_1 = 5;
+            continue $sm;
+          case 5:
+            this.r8_1 = 6;
+            suspendResult = this.e3y_1.bf(_get_PROPERTY_TYPE_TEXT__9rpcwt(IOPrimitiveUtils_getInstance()), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          case 6:
+            return Unit_instance;
+          case 7:
+            throw this.u8_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.s8_1 === 7) {
+          throw e;
+        } else {
+          this.r8_1 = this.s8_1;
+          this.u8_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(IOPrimitiveUtils$propertiesOf$slambda).g3y = function ($this$sequence, completion) {
+    var i = new IOPrimitiveUtils$propertiesOf$slambda(this.c3y_1, this.d3y_1, completion);
+    i.e3y_1 = $this$sequence;
+    return i;
+  };
+  function IOPrimitiveUtils$propertiesOf$slambda_0($channel, $this_propertiesOf, resultContinuation) {
+    var i = new IOPrimitiveUtils$propertiesOf$slambda($channel, $this_propertiesOf, resultContinuation);
+    return constructCallableReference(function ($this$sequence, $completion) {
+      return i.f3y($this$sequence, $completion);
+    }, 1);
+  }
+  function IOPrimitiveUtils$getOption$lambda(it) {
+    return !(it == null) ? isInterface(it, Struct) : false;
+  }
+  function IOPrimitiveUtils$getOption$lambda_0($unificator, $pattern) {
+    return function (it) {
+      return $unificator.match($pattern, it);
+    };
+  }
+  function IOPrimitiveUtils$getOption$lambda_1(it) {
+    return it.get(0);
+  }
+  function IOPrimitiveUtils$getOption$lambda_2(it) {
+    return !(it == null) ? isInterface(it, Truth) : false;
+  }
+  function IOPrimitiveUtils$getOption$lambda_3(it) {
+    return it.cx();
+  }
+  function IOPrimitiveUtils$getInfo$lambda(it) {
+    return !(it == null) ? isInterface(it, Struct) : false;
+  }
+  function IOPrimitiveUtils$_get_singletons_$lambda_kke618(it) {
+    return it.h2().t() === 1;
+  }
+  function IOPrimitiveUtils$_get_singletons_$lambda_kke618_0(it) {
+    return it.g2();
+  }
+  function IOPrimitiveUtils$toAssignments$lambda($n) {
+    return function (it) {
+      return to($n, it);
+    };
+  }
+  function IOPrimitiveUtils$open$lambda($this_open) {
+    return function (it) {
+      return IOPrimitiveUtils_getInstance().h3y($this_open, it);
+    };
+  }
+  function IOPrimitiveUtils$open$lambda_0($this_open) {
+    return function (it) {
+      return IOPrimitiveUtils_getInstance().i3y($this_open, it);
+    };
+  }
+  function IOPrimitiveUtils$replyOpeningStream$lambda($alias, $channel) {
+    return function ($this$replyWith) {
+      var tmp0_elvis_lhs = $alias;
+      $this$replyWith.f2r(tmp0_elvis_lhs == null ? 'output_channel' + $channel.m22().get(1).toString() : tmp0_elvis_lhs, $channel);
+      return Unit_instance;
+    };
+  }
+  function IOPrimitiveUtils$replyOpeningStream$lambda_0($alias, $channel) {
+    return function ($this$replyWith) {
+      var tmp0_elvis_lhs = $alias;
+      $this$replyWith.c2r(tmp0_elvis_lhs == null ? 'input_channel' + $channel.m22().get(1).toString() : tmp0_elvis_lhs, $channel);
+      return Unit_instance;
+    };
+  }
+  function IOPrimitiveUtils() {
+    IOPrimitiveUtils_instance = this;
+    var tmp = this;
+    tmp.m3v_1 = lazy(IOPrimitiveUtils$INPUT_STREAM_TERM_PATTERN$delegate$lambda);
+    var tmp_0 = this;
+    tmp_0.n3v_1 = lazy(IOPrimitiveUtils$OUTPUT_STREAM_TERM_PATTERN$delegate$lambda);
+    var tmp_1 = this;
+    tmp_1.o3v_1 = lazy(IOPrimitiveUtils$PROPERTY_TYPE_PATTERN$delegate$lambda);
+    var tmp_2 = this;
+    tmp_2.p3v_1 = lazy(IOPrimitiveUtils$PROPERTY_REPOSITION_PATTERN$delegate$lambda);
+    var tmp_3 = this;
+    tmp_3.q3v_1 = lazy(IOPrimitiveUtils$PROPERTY_EOF_ACTION_PATTERN$delegate$lambda);
+    var tmp_4 = this;
+    tmp_4.r3v_1 = lazy(IOPrimitiveUtils$PROPERTY_ALIAS_PATTERN$delegate$lambda);
+    var tmp_5 = this;
+    tmp_5.s3v_1 = lazy(IOPrimitiveUtils$PROPERTY_INPUT$delegate$lambda);
+    var tmp_6 = this;
+    tmp_6.t3v_1 = lazy(IOPrimitiveUtils$PROPERTY_OUTPUT$delegate$lambda);
+    var tmp_7 = this;
+    tmp_7.u3v_1 = lazy(IOPrimitiveUtils$PROPERTY_TYPE_TEXT$delegate$lambda);
+    var tmp_8 = this;
+    tmp_8.v3v_1 = lazy(IOPrimitiveUtils$PROPERTY_REPOSITION_FALSE$delegate$lambda);
+    var tmp_9 = this;
+    tmp_9.w3v_1 = lazy(IOPrimitiveUtils$PROPERTY_EOF_ACTION_EOF_CODE$delegate$lambda);
+    var tmp_10 = this;
+    tmp_10.x3v_1 = lazy(IOPrimitiveUtils$OPTION_QUOTED_PATTERN$delegate$lambda);
+    var tmp_11 = this;
+    tmp_11.y3v_1 = lazy(IOPrimitiveUtils$OPTION_NUMBER_VARS_PATTERN$delegate$lambda);
+    var tmp_12 = this;
+    tmp_12.z3v_1 = lazy(IOPrimitiveUtils$OPTION_IGNORE_OPS_PATTERN$delegate$lambda);
+    var tmp_13 = this;
+    tmp_13.a3w_1 = lazy(IOPrimitiveUtils$INFO_VARIABLES_PATTERN$delegate$lambda);
+    var tmp_14 = this;
+    tmp_14.b3w_1 = lazy(IOPrimitiveUtils$INFO_VARIABLE_NAMES_PATTERN$delegate$lambda);
+    var tmp_15 = this;
+    tmp_15.c3w_1 = lazy(IOPrimitiveUtils$INFO_SINGLETONS_PATTERN$delegate$lambda);
+  }
+  protoOf(IOPrimitiveUtils).j3y = function (_this__u8e3s4, channel) {
+    return sequence(IOPrimitiveUtils$propertiesOf$slambda_0(channel, _this__u8e3s4, null));
+  };
+  protoOf(IOPrimitiveUtils).d3w = function (_this__u8e3s4) {
+    // Inline function 'kotlin.let' call
+    var it = _this__u8e3s4.context.l1y();
+    var tmp0_elvis_lhs = it.wr();
+    return tmp0_elvis_lhs == null ? it.v1y() : tmp0_elvis_lhs;
+  };
+  protoOf(IOPrimitiveUtils).k3y = function (_this__u8e3s4) {
+    // Inline function 'kotlin.let' call
+    var it = _this__u8e3s4.context.m1y();
+    var tmp0_elvis_lhs = it.wr();
+    return tmp0_elvis_lhs == null ? it.w1y() : tmp0_elvis_lhs;
+  };
+  protoOf(IOPrimitiveUtils).h3y = function (_this__u8e3s4, term) {
+    var tmp;
+    var tmp0 = _get_validPropertiesPattern__7s1t06(this);
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.any' call
+      var _iterator__ex2g4s = tmp0.n();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, term, element)) {
+          tmp$ret$0 = true;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = false;
+    }
+    if (tmp$ret$0) {
+      tmp = term;
+    } else {
+      throw Companion_instance_6.forTerm(_this__u8e3s4.context, Expected_STREAM_PROPERTY_getInstance(), term);
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).i3y = function (_this__u8e3s4, term) {
+    var tmp;
+    var tmp0 = _get_supportedPropertiesPattern__x8u7bw(this);
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.any' call
+      var _iterator__ex2g4s = tmp0.n();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, term, element)) {
+          tmp$ret$0 = true;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = false;
+    }
+    if (tmp$ret$0) {
+      tmp = term;
+    } else {
+      throw Companion_instance_2.forUncaughtKtException(_this__u8e3s4.context, IllegalStateException_init_$Create$('unsupported option ' + term.toString()));
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).l3y = function (_this__u8e3s4, term) {
+    var tmp;
+    var tmp0 = _get_validOptionsPattern__akhsd9(this);
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.any' call
+      var _iterator__ex2g4s = tmp0.n();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, term, element)) {
+          tmp$ret$0 = true;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = false;
+    }
+    if (tmp$ret$0) {
+      tmp = term;
+    } else {
+      throw Companion_instance_6.forTerm(_this__u8e3s4.context, Expected_WRITE_OPTION_getInstance(), term);
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).m3y = function (_this__u8e3s4, term) {
+    var tmp;
+    var tmp0 = _get_validInfoPattern__dtwgth(this);
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.sequences.any' call
+      var _iterator__ex2g4s = tmp0.n();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, term, element)) {
+          tmp$ret$0 = true;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = false;
+    }
+    if (tmp$ret$0) {
+      tmp = term;
+    } else {
+      throw Companion_instance_6.forTerm(_this__u8e3s4.context, Expected_READ_OPTION_getInstance(), term);
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).n3y = function (_this__u8e3s4, index) {
+    Companion_getInstance_1().g2m(_this__u8e3s4, index);
+    var tmp = _this__u8e3s4.arguments.s(index);
+    var list = isInterface(tmp, List) ? tmp : THROW_CCE();
+    var _iterator__ex2g4s = list.iv().n();
+    while (_iterator__ex2g4s.q()) {
+      var term = _iterator__ex2g4s.r();
+      this.l3y(_this__u8e3s4, term);
+    }
+    return _this__u8e3s4;
+  };
+  protoOf(IOPrimitiveUtils).o3y = function (_this__u8e3s4, index) {
+    var list = _this__u8e3s4.arguments.s(index);
+    var tmp;
+    if (isInterface(list, Var)) {
+      tmp = null;
+    } else {
+      Companion_getInstance_1().g2m(_this__u8e3s4, index);
+      var listOfInfo = (isInterface(list, List) ? list : THROW_CCE()).toList();
+      var _iterator__ex2g4s = listOfInfo.n();
+      while (_iterator__ex2g4s.q()) {
+        var term = _iterator__ex2g4s.r();
+        this.m3y(_this__u8e3s4, term);
+      }
+      tmp = listOfInfo;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).p3y = function (_this__u8e3s4, index) {
+    this.n3y(_this__u8e3s4, index);
+    var tmp = _this__u8e3s4.arguments.s(index);
+    var optionList = (isInterface(tmp, List) ? tmp : THROW_CCE()).toList();
+    var tmp_0;
+    if (getOption(this, optionList, _this__u8e3s4.context.i1o(), _get_OPTION_QUOTED_PATTERN__n2ri42(this))) {
+      tmp_0 = FuncFormat_QUOTED_IF_NECESSARY_getInstance();
+    } else {
+      tmp_0 = FuncFormat_LITERAL_getInstance();
+    }
+    var funcFormat = tmp_0;
+    var tmp_1;
+    if (getOption(this, optionList, _this__u8e3s4.context.i1o(), _get_OPTION_IGNORE_OPS_PATTERN__cpse4v(this))) {
+      tmp_1 = OpFormat_IGNORE_OPERATORS_getInstance();
+    } else {
+      tmp_1 = OpFormat_EXPRESSIONS_getInstance();
+    }
+    var opFormat = tmp_1;
+    var numberVars = getOption(this, optionList, _this__u8e3s4.context.i1o(), _get_OPTION_NUMBER_VARS_PATTERN__p98ste(this));
+    return Companion_instance_7.of(VarFormat_UNDERSCORE_getInstance(), opFormat, funcFormat, numberVars, _this__u8e3s4.context.q1y());
+  };
+  protoOf(IOPrimitiveUtils).q3y = function (_this__u8e3s4, index) {
+    var term = _this__u8e3s4.arguments.s(index);
+    if (isInterface(term, Var))
+      return _this__u8e3s4;
+    else {
+      if (isInterface(term, Struct)) {
+        var tmp0 = sequenceOf([_get_PROPERTY_INPUT__z2zr91(this), _get_PROPERTY_OUTPUT__1pem9m(this), _get_PROPERTY_ALIAS_PATTERN__wipd2s(this)]);
+        var tmp$ret$0;
+        $l$block: {
+          // Inline function 'kotlin.sequences.any' call
+          var _iterator__ex2g4s = tmp0.n();
+          while (_iterator__ex2g4s.q()) {
+            var element = _iterator__ex2g4s.r();
+            if (Companion_getInstance_1().n2l(_this__u8e3s4, term, element)) {
+              tmp$ret$0 = true;
+              break $l$block;
+            }
+          }
+          tmp$ret$0 = false;
+        }
+        if (tmp$ret$0) {
+          return _this__u8e3s4;
+        }
+      }
+    }
+    throw Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_STREAM_PROPERTY_getInstance(), term, index);
+  };
+  protoOf(IOPrimitiveUtils).r3y = function (_this__u8e3s4, index) {
+    Companion_getInstance_1().s2l(_this__u8e3s4, index);
+    var term = _this__u8e3s4.arguments.s(index);
+    var error = Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_SOURCE_SINK_getInstance(), term, index);
+    if (!isInterface(term, Atom)) {
+      throw error;
+    }
+    try {
+      return Companion_instance_15.of(term.h2());
+    } catch ($p) {
+      if ($p instanceof InvalidUrlException) {
+        var _unused_var__etf5q3 = $p;
+        throw error;
+      } else {
+        throw $p;
+      }
+    }
+  };
+  protoOf(IOPrimitiveUtils).s3y = function (_this__u8e3s4, index) {
+    Companion_getInstance_1().s2l(_this__u8e3s4, index);
+    Companion_getInstance_1().b2m(_this__u8e3s4, index);
+    var tmp = _this__u8e3s4.arguments.s(index);
+    var term = isInterface(tmp, Atom) ? tmp : THROW_CCE();
+    if (!Companion_getInstance_8().f3u_1.z(term)) {
+      throw Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_IO_MODE_getInstance(), term, index);
+    }
+    // Inline function 'kotlin.text.uppercase' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp$ret$0 = term.h2().toUpperCase();
+    return valueOf(tmp$ret$0);
+  };
+  protoOf(IOPrimitiveUtils).y3w = function (_this__u8e3s4, index) {
+    var term = _this__u8e3s4.arguments.s(index);
+    if (isInterface(term, Var))
+      return null;
+    else {
+      if (isInterface(term, Struct))
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, term, _get_OUTPUT_STREAM_TERM_PATTERN__4vocxf(this))) {
+          var tmp1_elvis_lhs = firstOrNull(_this__u8e3s4.context.m1y().findByTerm(term));
+          var tmp;
+          if (tmp1_elvis_lhs == null) {
+            throw Companion_instance_8.forStream(_this__u8e3s4.context, term);
+          } else {
+            tmp = tmp1_elvis_lhs;
+          }
+          return tmp;
+        } else if (Companion_getInstance_1().n2l(_this__u8e3s4, term, _get_INPUT_STREAM_TERM_PATTERN__5fd8p6(this))) {
+          var tmp2_elvis_lhs = firstOrNull(_this__u8e3s4.context.l1y().findByTerm(term));
+          var tmp_0;
+          if (tmp2_elvis_lhs == null) {
+            throw Companion_instance_8.forStream(_this__u8e3s4.context, term);
+          } else {
+            tmp_0 = tmp2_elvis_lhs;
+          }
+          return tmp_0;
+        }
+    }
+    throw Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_STREAM_OR_ALIAS_getInstance(), term, index);
+  };
+  protoOf(IOPrimitiveUtils).k3x = function (_this__u8e3s4, index) {
+    var arg = _this__u8e3s4.arguments.s(index);
+    var tmp;
+    if (isInterface(arg, Var)) {
+      tmp = _this__u8e3s4;
+    } else {
+      if (isInterface(arg, Atom)) {
+        var tmp_0;
+        if (arg.h2() === 'end_of_file') {
+          tmp_0 = _this__u8e3s4;
+        } else if (arg.h2().length === 1) {
+          tmp_0 = _this__u8e3s4;
+        } else {
+          throw Companion_instance_3.o2b(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_IN_CHARACTER_getInstance(), arg, index);
+        }
+        tmp = tmp_0;
+      } else {
+        throw Companion_instance_3.o2b(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_IN_CHARACTER_getInstance(), arg, index);
+      }
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).q3x = function (_this__u8e3s4, index) {
+    var term = _this__u8e3s4.arguments.s(index);
+    var tmp;
+    if (isInterface(term, Var)) {
+      tmp = _this__u8e3s4;
+    } else {
+      if (!isInterface(term, Integer)) {
+        tmp = Companion_getInstance_1().f2m(_this__u8e3s4, index);
+      } else {
+        if (term.equals(Companion_getInstance_6().t11_1)) {
+          tmp = _this__u8e3s4;
+        } else {
+          if (Companion_getInstance_1().j2m(term)) {
+            throw Companion_instance_9.of(_this__u8e3s4.context, _this__u8e3s4.signature, Limit_CHARACTER_CODE_getInstance());
+          } else {
+            tmp = _this__u8e3s4;
+          }
+        }
+      }
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).m3w = function (_this__u8e3s4, index) {
+    Companion_getInstance_1().s2l(_this__u8e3s4, index);
+    Companion_getInstance_1().w2l(_this__u8e3s4, index);
+    var tmp = _this__u8e3s4.arguments.s(index);
+    var term = isInterface(tmp, Struct) ? tmp : THROW_CCE();
+    var tmp_0;
+    if (isInterface(term, Atom)) {
+      var tmp0 = sequenceOf([_this__u8e3s4.context.l1y(), _this__u8e3s4.context.m1y()]);
+      var tmp$ret$0;
+      $l$block: {
+        // Inline function 'kotlin.sequences.firstOrNull' call
+        var _iterator__ex2g4s = tmp0.n();
+        while (_iterator__ex2g4s.q()) {
+          var element = _iterator__ex2g4s.r();
+          // Inline function 'kotlin.collections.contains' call
+          // Inline function 'kotlin.collections.containsKey' call
+          var key = term.h2();
+          if ((isInterface(element, KtMap) ? element : THROW_CCE()).i2(key)) {
+            tmp$ret$0 = element;
+            break $l$block;
+          }
+        }
+        tmp$ret$0 = null;
+      }
+      var tmp0_safe_receiver = tmp$ret$0;
+      var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.k2(term.h2());
+      var tmp_1;
+      if (tmp1_elvis_lhs == null) {
+        throw Companion_instance_8.forSourceSink(_this__u8e3s4.context, term);
+      } else {
+        tmp_1 = tmp1_elvis_lhs;
+      }
+      tmp_0 = tmp_1;
+    } else {
+      if (Companion_getInstance_1().n2l(_this__u8e3s4, term, _get_OUTPUT_STREAM_TERM_PATTERN__4vocxf(this))) {
+        var tmp2_elvis_lhs = firstOrNull(_this__u8e3s4.context.m1y().findByTerm(term));
+        var tmp_2;
+        if (tmp2_elvis_lhs == null) {
+          throw Companion_instance_8.forStream(_this__u8e3s4.context, term);
+        } else {
+          tmp_2 = tmp2_elvis_lhs;
+        }
+        tmp_0 = tmp_2;
+      } else {
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, term, _get_INPUT_STREAM_TERM_PATTERN__5fd8p6(this))) {
+          var tmp3_elvis_lhs = firstOrNull(_this__u8e3s4.context.l1y().findByTerm(term));
+          var tmp_3;
+          if (tmp3_elvis_lhs == null) {
+            throw Companion_instance_8.forStream(_this__u8e3s4.context, term);
+          } else {
+            tmp_3 = tmp3_elvis_lhs;
+          }
+          tmp_0 = tmp_3;
+        } else {
+          throw Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_STREAM_OR_ALIAS_getInstance(), term, index);
+        }
+      }
+    }
+    return tmp_0;
+  };
+  protoOf(IOPrimitiveUtils).h3w = function (_this__u8e3s4, index) {
+    var channel = this.m3w(_this__u8e3s4, index);
+    var tmp;
+    if (isInterface(channel, InputChannel)) {
+      tmp = channel;
+    } else {
+      throw Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_STREAM_TYPE_getInstance(), _this__u8e3s4.arguments.s(index), index);
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).d3x = function (_this__u8e3s4, index) {
+    var channel = this.m3w(_this__u8e3s4, index);
+    var tmp;
+    if (isInterface(channel, OutputChannel)) {
+      tmp = channel;
+    } else {
+      throw Companion_instance_6.t28(_this__u8e3s4.context, _this__u8e3s4.signature, Expected_STREAM_TYPE_getInstance(), _this__u8e3s4.arguments.s(index), index);
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).t3y = function (_this__u8e3s4, channel, term, formatter) {
+    var tmp;
+    try {
+      channel.write(format(term, formatter));
+      tmp = _this__u8e3s4.replySuccess(VOID, VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).u3y = function (_this__u8e3s4, channel, arg) {
+    var tmp;
+    try {
+      channel.write(toString_0(arg.m11().toChar()));
+      tmp = _this__u8e3s4.replySuccess(VOID, VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).v3y = function (_this__u8e3s4, channel, arg) {
+    var tmp;
+    try {
+      channel.write(arg.h2());
+      tmp = _this__u8e3s4.replySuccess(VOID, VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).w3y = function (_this__u8e3s4, channel, arg) {
+    var tmp;
+    try {
+      var tmp0_safe_receiver = channel.peek();
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : charCodeAt(tmp0_safe_receiver, 0);
+      var tmp_0;
+      var tmp_1 = tmp1_safe_receiver;
+      if ((tmp_1 == null ? null : new Char(tmp_1)) == null) {
+        tmp_0 = null;
+      } else {
+        // Inline function 'kotlin.code' call
+        tmp_0 = Char__toInt_impl_vasixd(tmp1_safe_receiver);
+      }
+      var tmp2_elvis_lhs = tmp_0;
+      var code = tmp2_elvis_lhs == null ? -1 : tmp2_elvis_lhs;
+      tmp = _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, arg, Companion_getInstance_6().ofInt(code)), VOID, []);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_2 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_2;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).x3y = function (_this__u8e3s4, channel, arg) {
+    var tmp;
+    try {
+      var tmp0_elvis_lhs = channel.peek();
+      var char = tmp0_elvis_lhs == null ? 'end_of_file' : tmp0_elvis_lhs;
+      tmp = _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, arg, Companion_getInstance_0().of(char)), VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).r3x = function (_this__u8e3s4, channel, arg) {
+    var tmp;
+    try {
+      var tmp0_safe_receiver = channel.read();
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : charCodeAt(tmp0_safe_receiver, 0);
+      var tmp_0;
+      var tmp_1 = tmp1_safe_receiver;
+      if ((tmp_1 == null ? null : new Char(tmp_1)) == null) {
+        tmp_0 = null;
+      } else {
+        // Inline function 'kotlin.code' call
+        tmp_0 = Char__toInt_impl_vasixd(tmp1_safe_receiver);
+      }
+      var tmp2_elvis_lhs = tmp_0;
+      var code = tmp2_elvis_lhs == null ? -1 : tmp2_elvis_lhs;
+      tmp = _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, arg, Companion_getInstance_6().ofInt(code)), VOID, []);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_2 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_2;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).l3x = function (_this__u8e3s4, channel, arg) {
+    var tmp;
+    try {
+      var tmp0_elvis_lhs = channel.read();
+      var char = tmp0_elvis_lhs == null ? 'end_of_file' : tmp0_elvis_lhs;
+      tmp = _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, arg, Companion_getInstance_0().of(char)), VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(IOPrimitiveUtils).y3y = function (_this__u8e3s4, channel, arg, lastIsInfoList) {
+    try {
+      var termsChannel = asTermChannel(channel, _this__u8e3s4.context.q1y());
+      var tmp;
+      if (lastIsInfoList) {
+        tmp = this.o3y(_this__u8e3s4, get_lastIndex(_this__u8e3s4.arguments));
+      } else {
+        tmp = emptyList();
+      }
+      var infoList = tmp;
+      if (!termsChannel.p22())
+        return _this__u8e3s4.replyFail(VOID, []);
+      var read = termsChannel.read();
+      var tmp_0;
+      if (read == null) {
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        var variables_0 = variables(this, toList_0(read.gx()));
+        var variableNames_0 = variableNames(this, toAssignments_0(this, read.gx()));
+        var singletons_0 = singletons(this, toAssignments(this, _get_singletons__bihqrn(this, read)));
+        var tmp_1;
+        if (infoList == null) {
+          tmp_1 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          var u = _this__u8e3s4.context.i1o();
+          tmp_1 = getInfo(IOPrimitiveUtils_getInstance(), infoList, u, _get_INFO_SINGLETONS_PATTERN__y21s87(IOPrimitiveUtils_getInstance()), singletons_0).plus(getInfo(IOPrimitiveUtils_getInstance(), infoList, u, _get_INFO_VARIABLES_PATTERN__bhp1h0(IOPrimitiveUtils_getInstance()), variables_0)).plus(getInfo(IOPrimitiveUtils_getInstance(), infoList, u, _get_INFO_VARIABLE_NAMES_PATTERN__j3oaom(IOPrimitiveUtils_getInstance()), variableNames_0));
+        }
+        var tmp1_elvis_lhs = tmp_1;
+        var info = tmp1_elvis_lhs == null ? Companion_getInstance_1().m2l(_this__u8e3s4, last(_this__u8e3s4.arguments), Companion_instance_4.of([variables_0, variableNames_0, singletons_0])) : tmp1_elvis_lhs;
+        tmp_0 = _this__u8e3s4.replyWith(Companion_getInstance_1().m2l(_this__u8e3s4, arg, read).plus(info), VOID, []);
+      }
+      return tmp_0;
+    } catch ($p) {
+      if ($p instanceof IllegalStateException) {
+        var e = $p;
+        throw Companion_instance_2.forUncaughtKtException(_this__u8e3s4.context, e);
+      } else {
+        if ($p instanceof ParseException) {
+          var e_0 = $p;
+          var tmp_2 = Companion_instance_10;
+          var tmp_3 = channel.m22().toString();
+          var tmp_4 = e_0.line;
+          var tmp_5 = e_0.column;
+          var tmp2_elvis_lhs = e_0.message;
+          throw tmp_2.whileParsingTerm(_this__u8e3s4.context, tmp_3, tmp_4, tmp_5, tmp2_elvis_lhs == null ? '<no details provided>' : tmp2_elvis_lhs);
+        } else {
+          throw $p;
+        }
+      }
+    }
+  };
+  protoOf(IOPrimitiveUtils).z3y = function (_this__u8e3s4, channel, arg, lastIsInfoList, $super) {
+    lastIsInfoList = lastIsInfoList === VOID ? false : lastIsInfoList;
+    return $super === VOID ? this.y3y(_this__u8e3s4, channel, arg, lastIsInfoList) : $super.y3y.call(this, _this__u8e3s4, channel, arg, lastIsInfoList);
+  };
+  protoOf(IOPrimitiveUtils).a3z = function (_this__u8e3s4, third) {
+    var url = this.r3y(_this__u8e3s4, 0);
+    var mode = this.s3y(_this__u8e3s4, 1);
+    Companion_getInstance_1().z2l(_this__u8e3s4, 2);
+    var tmp;
+    if (_this__u8e3s4.arguments.t() >= 4) {
+      Companion_getInstance_1().g2m(_this__u8e3s4, 3);
+      var tmp_0 = _this__u8e3s4.arguments.s(3);
+      var tmp_1 = (isInterface(tmp_0, List) ? tmp_0 : THROW_CCE()).iv();
+      var tmp_2 = map(tmp_1, IOPrimitiveUtils$open$lambda(_this__u8e3s4));
+      tmp = toSet(map(tmp_2, IOPrimitiveUtils$open$lambda_0(_this__u8e3s4)));
+    } else {
+      tmp = emptySet();
+    }
+    var options = tmp;
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s = options.n();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        if (Companion_getInstance_1().n2l(_this__u8e3s4, _get_PROPERTY_ALIAS_PATTERN__wipd2s(IOPrimitiveUtils_getInstance()), element)) {
+          tmp$ret$0 = element;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = null;
+    }
+    var tmp0_safe_receiver = tmp$ret$0;
+    var alias = tmp0_safe_receiver == null ? null : _get_alias__jw26bj(this, tmp0_safe_receiver);
+    var tmp_3;
+    try {
+      var tmp_4;
+      switch (mode.o2_1) {
+        case 0:
+          tmp_4 = replyOpeningStream_0(this, _this__u8e3s4, openInputChannel(url), third, alias);
+          break;
+        case 1:
+          tmp_4 = replyOpeningStream(this, _this__u8e3s4, openOutputChannel(url, false), third, alias);
+          break;
+        case 2:
+          tmp_4 = replyOpeningStream(this, _this__u8e3s4, openOutputChannel(url, true), third, alias);
+          break;
+        default:
+          noWhenBranchMatchedException();
+          break;
+      }
+      tmp_3 = tmp_4;
+    } catch ($p) {
+      var tmp_5;
+      if ($p instanceof IOException_0) {
+        var e = $p;
+        var tmp_6;
+        var tmp_7 = e.cause;
+        if (tmp_7 instanceof FileNotFoundException) {
+          tmp_6 = ExistenceError_init_$Create$(e.message, e, _this__u8e3s4.context, ObjectType_SOURCE_SINK_getInstance(), _this__u8e3s4.arguments.s(0));
+        } else {
+          tmp_6 = e.h3v(_this__u8e3s4.context);
+        }
+        throw tmp_6;
+      } else {
+        throw $p;
+      }
+    }
+    return tmp_3;
+  };
+  var IOPrimitiveUtils_instance;
+  function IOPrimitiveUtils_getInstance() {
+    if (IOPrimitiveUtils_instance == null)
+      new IOPrimitiveUtils();
+    return IOPrimitiveUtils_instance;
+  }
+  function Nl1() {
+    Nl1_instance = this;
+    NonBacktrackable_0.call(this, 'nl');
+    this.c3z_1 = '`nl(+Stream)`\n\nWrites a newline character to the output stream `Stream`, succeeding deterministically (`nl/0`, writing to the current output, is provided by `prolog.lang`). `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write(user_output, hello), nl(user_output).\n% prints: hello, then a newline\nyes.\n\n?- nl(user_input).\nthrows error(domain_error(stream_type, user_input), _).\n\n?- nl(S).\nthrows error(instantiation_error, _).\n```';
+  }
+  protoOf(Nl1).w1x = function () {
+    return this.c3z_1;
+  };
+  protoOf(Nl1).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    var tmp;
+    try {
+      channel.write('\n');
+      tmp = _this__u8e3s4.replySuccess(VOID, VOID, []);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalStateException) {
+        var _unused_var__etf5q3 = $p;
+        tmp_0 = _this__u8e3s4.replyFail(VOID, []);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(Nl1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var Nl1_instance;
+  function Nl1_getInstance() {
+    if (Nl1_instance == null)
+      new Nl1();
+    return Nl1_instance;
+  }
+  function Open3() {
+    Open3_instance = this;
+    NonBacktrackable_1.call(this, 'open');
+    this.e3z_1 = "`open(+SourceSink, +Mode, -Stream)`\n\nOpens `SourceSink`, an atom holding a URL or a plain file path, in `Mode` (`read`, `write` or `append`), registers the new stream under an auto-generated alias, and unifies `Stream` with its `$stream(Direction, Id)` term; it behaves as `open/4` with an empty options list. Any URL readable by the platform (e.g. files or `http(s)`) can be opened for reading, but the current implementation can only write or append to local files on the JVM, and never on JS. It raises an instantiation error if `SourceSink` or `Mode` is unbound, a domain error (`source_sink`) if `SourceSink` is not a valid URL or path, a type or domain error (`io_mode`) if `Mode` is not one of the allowed atoms, a type error (`variable`) if `Stream` is bound (ISO prescribes an uninstantiation error), an existence error (`source_sink`) if the resource does not exist, and a system error if it cannot be opened for any other reason.\n\n**Examples**\n\n```prolog\n% with /path/to/data.pl containing `hello(world).`\n?- open('/path/to/data.pl', read, S), read(S, T), close(S).\nT = hello(world).\n\n?- open(F, read, S).\nthrows error(instantiation_error, _).\n\n?- open('/path/to/data.pl', update, S).\nthrows error(domain_error(io_mode, update), _).\n\n?- open('/path/to/data.pl', read, foo).\nthrows error(type_error(variable, foo), _).\n```";
+  }
+  protoOf(Open3).w1x = function () {
+    return this.e3z_1;
+  };
+  protoOf(Open3).t2z = function (_this__u8e3s4, first, second, third) {
+    return IOPrimitiveUtils_getInstance().a3z(_this__u8e3s4, third);
+  };
+  protoOf(Open3).t2n = function (_this__u8e3s4, first, second, third) {
+    return this.t2z(_this__u8e3s4, first, second, third);
+  };
+  var Open3_instance;
+  function Open3_getInstance() {
+    if (Open3_instance == null)
+      new Open3();
+    return Open3_instance;
+  }
+  function Open4() {
+    Open4_instance = this;
+    NonBacktrackable_2.call(this, 'open');
+    this.g3z_1 = "`open(+SourceSink, +Mode, -Stream, +Options)`\n\nLike `open/3`, opens `SourceSink` (a URL or file path atom) in `Mode` (`read`, `write` or `append`) and unifies `Stream` with the new `$stream(Direction, Id)` term, but also takes a list of `Options`. In the current implementation only `alias(Name)` has an effect, registering the stream under `Name` instead of an auto-generated alias; `input`, `output`, `type(text)`, `eof_action(eof_code)` and `reposition(false)` are accepted and ignored, other values of `type/1`, `eof_action/1` and `reposition/1` (e.g. `type(binary)`) raise a system error, and any other element raises a domain error (`stream_property`). `Options` must be a list (type error otherwise, even when unbound), and all other arguments are checked and raise errors exactly as for `open/3`.\n\n**Examples**\n\n```prolog\n?- open('/path/to/out.txt', write, _, [alias(out)]), write(out, hello), close(out).\nyes.\n\n?- open('/path/to/out.txt', write, S, [type(binary)]).\nthrows error(system_error, _).\n\n?- open('/path/to/out.txt', write, S, [foo]).\nthrows error(domain_error(stream_property, foo), _).\n```";
+  }
+  protoOf(Open4).w1x = function () {
+    return this.g3z_1;
+  };
+  protoOf(Open4).h3z = function (_this__u8e3s4, first, second, third, fourth) {
+    return IOPrimitiveUtils_getInstance().a3z(_this__u8e3s4, third);
+  };
+  protoOf(Open4).q2m = function (_this__u8e3s4, first, second, third, fourth) {
+    return this.h3z(_this__u8e3s4, first, second, third, fourth);
+  };
+  var Open4_instance;
+  function Open4_getInstance() {
+    if (Open4_instance == null)
+      new Open4();
+    return Open4_instance;
+  }
+  function PeekByte1() {
+    PeekByte1_instance = this;
+    NonBacktrackable_0.call(this, 'peek_byte');
+    this.j3z_1 = '`peek_byte(?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `peek_code/1` instead.\n\n**Examples**\n\n```prolog\n?- peek_byte(B).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(PeekByte1).w1x = function () {
+    return this.j3z_1;
+  };
+  protoOf(PeekByte1).i2u = function (_this__u8e3s4, first) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(PeekByte1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var PeekByte1_instance;
+  function PeekByte1_getInstance() {
+    if (PeekByte1_instance == null)
+      new PeekByte1();
+    return PeekByte1_instance;
+  }
+  function PeekByte2() {
+    PeekByte2_instance = this;
+    NonBacktrackable.call(this, 'peek_byte');
+    this.l3z_1 = '`peek_byte(+Stream, ?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `peek_code/2` instead.\n\n**Examples**\n\n```prolog\n?- peek_byte(user_input, B).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(PeekByte2).w1x = function () {
+    return this.l3z_1;
+  };
+  protoOf(PeekByte2).z2u = function (_this__u8e3s4, first, second) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(PeekByte2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var PeekByte2_instance;
+  function PeekByte2_getInstance() {
+    if (PeekByte2_instance == null)
+      new PeekByte2();
+    return PeekByte2_instance;
+  }
+  function PeekChar1() {
+    PeekChar1_instance = this;
+    NonBacktrackable_0.call(this, 'peek_char');
+    this.n3z_1 = '`peek_char(?Char)`\n\nUnifies `Char` with the next character of the current input stream (standard input, unless changed via `set_input/1`) without consuming it, or with `end_of_file` at the end of the stream. It is deterministic. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_char(ab).\nthrows error(type_error(in_character, ab), _).\n```';
+  }
+  protoOf(PeekChar1).w1x = function () {
+    return this.n3z_1;
+  };
+  protoOf(PeekChar1).i2u = function (_this__u8e3s4, first) {
+    IOPrimitiveUtils_getInstance().k3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().x3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4), first);
+  };
+  protoOf(PeekChar1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var PeekChar1_instance;
+  function PeekChar1_getInstance() {
+    if (PeekChar1_instance == null)
+      new PeekChar1();
+    return PeekChar1_instance;
+  }
+  function PeekChar2() {
+    PeekChar2_instance = this;
+    NonBacktrackable.call(this, 'peek_char');
+    this.p3z_1 = '`peek_char(+Stream, ?Char)`\n\nUnifies `Char` with the next character of the input stream `Stream` without consuming it, or with `end_of_file` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_char(user_input, ab).\nthrows error(type_error(in_character, ab), _).\n\n?- peek_char(S, C).\nthrows error(instantiation_error, _).\n\n?- peek_char(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
+  }
+  protoOf(PeekChar2).w1x = function () {
+    return this.p3z_1;
+  };
+  protoOf(PeekChar2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    IOPrimitiveUtils_getInstance().k3x(_this__u8e3s4, 1);
+    return IOPrimitiveUtils_getInstance().x3y(_this__u8e3s4, channel, second);
+  };
+  protoOf(PeekChar2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var PeekChar2_instance;
+  function PeekChar2_getInstance() {
+    if (PeekChar2_instance == null)
+      new PeekChar2();
+    return PeekChar2_instance;
+  }
+  function PeekCode1() {
+    PeekCode1_instance = this;
+    NonBacktrackable_0.call(this, 'peek_code');
+    this.r3z_1 = '`peek_code(?Code)`\n\nUnifies `Code` with the code of the next character of the current input stream (standard input, unless changed via `set_input/1`) without consuming it, or with `-1` at the end of the stream. It is deterministic. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_code(a).\nthrows error(type_error(integer, a), _).\n\n?- peek_code(-2).\nthrows error(representation_error(character_code), _).\n```';
+  }
+  protoOf(PeekCode1).w1x = function () {
+    return this.r3z_1;
+  };
+  protoOf(PeekCode1).i2u = function (_this__u8e3s4, first) {
+    IOPrimitiveUtils_getInstance().q3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().w3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4), first);
+  };
+  protoOf(PeekCode1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var PeekCode1_instance;
+  function PeekCode1_getInstance() {
+    if (PeekCode1_instance == null)
+      new PeekCode1();
+    return PeekCode1_instance;
+  }
+  function PeekCode2() {
+    PeekCode2_instance = this;
+    NonBacktrackable.call(this, 'peek_code');
+    this.t3z_1 = '`peek_code(+Stream, ?Code)`\n\nUnifies `Code` with the code of the next character of the input stream `Stream` without consuming it, or with `-1` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_code(user_input, a).\nthrows error(type_error(integer, a), _).\n\n?- peek_code(S, C).\nthrows error(instantiation_error, _).\n\n?- peek_code(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
+  }
+  protoOf(PeekCode2).w1x = function () {
+    return this.t3z_1;
+  };
+  protoOf(PeekCode2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    IOPrimitiveUtils_getInstance().q3x(_this__u8e3s4, 1);
+    return IOPrimitiveUtils_getInstance().w3y(_this__u8e3s4, channel, second);
+  };
+  protoOf(PeekCode2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var PeekCode2_instance;
+  function PeekCode2_getInstance() {
+    if (PeekCode2_instance == null)
+      new PeekCode2();
+    return PeekCode2_instance;
+  }
+  function PutByte1() {
+    PutByte1_instance = this;
+    NonBacktrackable_0.call(this, 'put_byte');
+    this.v3z_1 = '`put_byte(+Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `put_code/1` instead.\n\n**Examples**\n\n```prolog\n?- put_byte(65).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(PutByte1).w1x = function () {
+    return this.v3z_1;
+  };
+  protoOf(PutByte1).i2u = function (_this__u8e3s4, first) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(PutByte1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var PutByte1_instance;
+  function PutByte1_getInstance() {
+    if (PutByte1_instance == null)
+      new PutByte1();
+    return PutByte1_instance;
+  }
+  function PutByte2() {
+    PutByte2_instance = this;
+    NonBacktrackable.call(this, 'put_byte');
+    this.x3z_1 = '`put_byte(+Stream, +Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `put_code/2` instead.\n\n**Examples**\n\n```prolog\n?- put_byte(user_output, 65).\nthrows error(system_error, _).\n```';
+  }
+  protoOf(PutByte2).w1x = function () {
+    return this.x3z_1;
+  };
+  protoOf(PutByte2).z2u = function (_this__u8e3s4, first, second) {
+    return Companion_getInstance_1().u2l(_this__u8e3s4);
+  };
+  protoOf(PutByte2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var PutByte2_instance;
+  function PutByte2_getInstance() {
+    if (PutByte2_instance == null)
+      new PutByte2();
+    return PutByte2_instance;
+  }
+  function PutChar1() {
+    PutChar1_instance = this;
+    NonBacktrackable_0.call(this, 'put_char');
+    this.z3z_1 = '`put_char(+Char)`\n\nWrites the character `Char` to the current output stream (standard output, unless changed via `set_output/1`), succeeding deterministically. `Char` must be a one-character atom, otherwise a type error (`character`) is raised; the current implementation raises that type error even when `Char` is unbound, where ISO prescribes an instantiation error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_char(a).\n% prints: a\nyes.\n\n?- put_char(ab).\nthrows error(type_error(character, ab), _).\n\n?- put_char(C).\nthrows error(type_error(character, _), _).\n```';
+  }
+  protoOf(PutChar1).w1x = function () {
+    return this.z3z_1;
+  };
+  protoOf(PutChar1).i2u = function (_this__u8e3s4, first) {
+    Companion_getInstance_1().d2m(_this__u8e3s4, 0);
+    var tmp = IOPrimitiveUtils_getInstance();
+    var tmp_0 = IOPrimitiveUtils_getInstance().k3y(_this__u8e3s4);
+    return tmp.v3y(_this__u8e3s4, tmp_0, isInterface(first, Atom) ? first : THROW_CCE());
+  };
+  protoOf(PutChar1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var PutChar1_instance;
+  function PutChar1_getInstance() {
+    if (PutChar1_instance == null)
+      new PutChar1();
+    return PutChar1_instance;
+  }
+  function PutChar2() {
+    PutChar2_instance = this;
+    NonBacktrackable.call(this, 'put_char');
+    this.b40_1 = '`put_char(+Stream, +Char)`\n\nWrites the character `Char` to the output stream `Stream`, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. `Char` must be a one-character atom, otherwise (even when unbound) a type error (`character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_char(user_output, a).\n% prints: a\nyes.\n\n?- put_char(user_output, ab).\nthrows error(type_error(character, ab), _).\n\n?- put_char(user_input, a).\nthrows error(domain_error(stream_type, user_input), _).\n```';
+  }
+  protoOf(PutChar2).w1x = function () {
+    return this.b40_1;
+  };
+  protoOf(PutChar2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    Companion_getInstance_1().d2m(_this__u8e3s4, 1);
+    var tmp = IOPrimitiveUtils_getInstance();
+    return tmp.v3y(_this__u8e3s4, channel, isInterface(second, Atom) ? second : THROW_CCE());
+  };
+  protoOf(PutChar2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var PutChar2_instance;
+  function PutChar2_getInstance() {
+    if (PutChar2_instance == null)
+      new PutChar2();
+    return PutChar2_instance;
+  }
+  function PutCode1() {
+    PutCode1_instance = this;
+    NonBacktrackable_0.call(this, 'put_code');
+    this.d40_1 = '`put_code(+Code)`\n\nWrites the character whose code is `Code` to the current output stream (standard output, unless changed via `set_output/1`), succeeding deterministically. `Code` must be an integer, otherwise (even when unbound, where ISO prescribes an instantiation error) a type error (`integer`) is raised, and a valid character code, otherwise a representation error (`character_code`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_code(97).\n% prints: a\nyes.\n\n?- put_code(a).\nthrows error(type_error(integer, a), _).\n\n?- put_code(-1).\nthrows error(representation_error(character_code), _).\n```';
+  }
+  protoOf(PutCode1).w1x = function () {
+    return this.d40_1;
+  };
+  protoOf(PutCode1).i2u = function (_this__u8e3s4, first) {
+    Companion_getInstance_1().m2m(_this__u8e3s4, 0);
+    var tmp = IOPrimitiveUtils_getInstance();
+    var tmp_0 = IOPrimitiveUtils_getInstance().k3y(_this__u8e3s4);
+    return tmp.u3y(_this__u8e3s4, tmp_0, isInterface(first, Integer) ? first : THROW_CCE());
+  };
+  protoOf(PutCode1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var PutCode1_instance;
+  function PutCode1_getInstance() {
+    if (PutCode1_instance == null)
+      new PutCode1();
+    return PutCode1_instance;
+  }
+  function PutCode2() {
+    PutCode2_instance = this;
+    NonBacktrackable.call(this, 'put_code');
+    this.f40_1 = '`put_code(+Stream, +Code)`\n\nWrites the character whose code is `Code` to the output stream `Stream`, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. `Code` must be an integer (type error otherwise, even when unbound) and a valid character code (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_code(user_output, 97).\n% prints: a\nyes.\n\n?- put_code(user_output, C).\nthrows error(type_error(integer, _), _).\n\n?- put_code(user_input, 97).\nthrows error(domain_error(stream_type, user_input), _).\n```';
+  }
+  protoOf(PutCode2).w1x = function () {
+    return this.f40_1;
+  };
+  protoOf(PutCode2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    Companion_getInstance_1().m2m(_this__u8e3s4, 1);
+    var tmp = IOPrimitiveUtils_getInstance();
+    return tmp.u3y(_this__u8e3s4, channel, isInterface(second, Integer) ? second : THROW_CCE());
+  };
+  protoOf(PutCode2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var PutCode2_instance;
+  function PutCode2_getInstance() {
+    if (PutCode2_instance == null)
+      new PutCode2();
+    return PutCode2_instance;
+  }
+  function Read1() {
+    Read1_instance = this;
+    NonBacktrackable_0.call(this, 'read');
+    this.h40_1 = '`read(?Term)`\n\nReads the next term, terminated by a full stop, from the current input stream (standard input, unless changed via `set_input/1`) and unifies it with `Term`, using the current operators. It is deterministic. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n% with `foo(X, bar).` to be read from standard input\n?- read(T).\nT = foo(_, bar).\n\n% once standard input has been exhausted\n?- read(T).\nno.\n```';
+  }
+  protoOf(Read1).w1x = function () {
+    return this.h40_1;
+  };
+  protoOf(Read1).i2u = function (_this__u8e3s4, first) {
+    return IOPrimitiveUtils_getInstance().z3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4), first);
+  };
+  protoOf(Read1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var Read1_instance;
+  function Read1_getInstance() {
+    if (Read1_instance == null)
+      new Read1();
+    return Read1_instance;
+  }
+  function Read2() {
+    Read2_instance = this;
+    NonBacktrackable.call(this, 'read');
+    this.j40_1 = '`read(+Stream, ?Term)`\n\nReads the next term, terminated by a full stop, from the input stream `Stream` and unifies it with `Term`, using the current operators. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n?- read(S, T).\nthrows error(instantiation_error, _).\n\n?- read(user_output, T).\nthrows error(domain_error(stream_type, user_output), _).\n\n?- read(no_such_stream, T).\nthrows error(existence_error(source_sink, no_such_stream), _).\n```';
+  }
+  protoOf(Read2).w1x = function () {
+    return this.j40_1;
+  };
+  protoOf(Read2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().z3y(_this__u8e3s4, channel, second);
+  };
+  protoOf(Read2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var Read2_instance;
+  function Read2_getInstance() {
+    if (Read2_instance == null)
+      new Read2();
+    return Read2_instance;
+  }
+  function ReadTerm2() {
+    ReadTerm2_instance = this;
+    NonBacktrackable.call(this, 'read_term');
+    this.l40_1 = "`read_term(?Term, ?Options)`\n\nReads the next term from the current input stream (standard input, unless changed via `set_input/1`) like `read/1`, and unifies the elements of the `Options` list with information about the term's variables. Each element of `Options` may be `variables(Vars)` (the variables of the term, in order of appearance), `variable_names(Names)` (a list of `'Name' = Var` pairs) or `singletons(Names)` (the same, for variables occurring once); other elements raise a domain error (`read_option`). Deviating from ISO, an unbound `Options` is not an error: it is unified with `[variables(Vars), variable_names(Names), singletons(Singletons)]`. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n?- read_term(T, [foo]).\nthrows error(domain_error(read_option, foo), _).\n\n?- read_term(T, foo).\nthrows error(type_error(list, foo), _).\n```";
+  }
+  protoOf(ReadTerm2).w1x = function () {
+    return this.l40_1;
+  };
+  protoOf(ReadTerm2).z2u = function (_this__u8e3s4, first, second) {
+    return IOPrimitiveUtils_getInstance().y3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().d3w(_this__u8e3s4), first, true);
+  };
+  protoOf(ReadTerm2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var ReadTerm2_instance;
+  function ReadTerm2_getInstance() {
+    if (ReadTerm2_instance == null)
+      new ReadTerm2();
+    return ReadTerm2_instance;
+  }
+  function ReadTerm3() {
+    ReadTerm3_instance = this;
+    NonBacktrackable_1.call(this, 'read_term');
+    this.n40_1 = "`read_term(+Stream, ?Term, ?Options)`\n\nReads the next term from the input stream `Stream` like `read/2`, and unifies the elements of the `Options` list with information about the term's variables. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. Each element of `Options` may be `variables(Vars)` (the variables of the term, in order of appearance), `variable_names(Names)` (a list of `'Name' = Var` pairs) or `singletons(Names)` (the same, for variables occurring once); other elements raise a domain error (`read_option`). Deviating from ISO, an unbound `Options` is not an error: it is unified with `[variables(Vars), variable_names(Names), singletons(Singletons)]`. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n?- read_term(user_input, T, [foo]).\nthrows error(domain_error(read_option, foo), _).\n\n?- read_term(S, T, []).\nthrows error(instantiation_error, _).\n\n?- read_term(user_output, T, []).\nthrows error(domain_error(stream_type, user_output), _).\n```";
+  }
+  protoOf(ReadTerm3).w1x = function () {
+    return this.n40_1;
+  };
+  protoOf(ReadTerm3).t2z = function (_this__u8e3s4, first, second, third) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().y3y(_this__u8e3s4, channel, second, true);
+  };
+  protoOf(ReadTerm3).t2n = function (_this__u8e3s4, first, second, third) {
+    return this.t2z(_this__u8e3s4, first, second, third);
+  };
+  var ReadTerm3_instance;
+  function ReadTerm3_getInstance() {
+    if (ReadTerm3_instance == null)
+      new ReadTerm3();
+    return ReadTerm3_instance;
+  }
+  function SetInput$computeOne$lambda($this_computeOne, $channel) {
+    return function ($this$replySuccess) {
+      $this$replySuccess.d2r($this_computeOne.context.l1y().setCurrentChannel($channel));
+      return Unit_instance;
+    };
+  }
+  function SetInput() {
+    SetInput_instance = this;
+    NonBacktrackable_0.call(this, 'set_input');
+    this.p40_1 = '`set_input(+Stream)`\n\nMakes the input stream `Stream` the current input stream, i.e. the one used by the predicates without an explicit stream argument (e.g. `get_char/1`, `read/1`), succeeding deterministically. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error.\n\n**Examples**\n\n```prolog\n?- set_input(user_input), current_input(S), stream_property(S, alias(user_input)).\nyes.\n\n?- set_input(user_output).\nthrows error(domain_error(stream_type, user_output), _).\n\n?- set_input(S).\nthrows error(instantiation_error, _).\n```';
+  }
+  protoOf(SetInput).w1x = function () {
+    return this.p40_1;
+  };
+  protoOf(SetInput).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().h3w(_this__u8e3s4, 0);
+    return _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, SetInput$computeOne$lambda(_this__u8e3s4, channel));
+  };
+  protoOf(SetInput).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var SetInput_instance;
+  function SetInput_getInstance() {
+    if (SetInput_instance == null)
+      new SetInput();
+    return SetInput_instance;
+  }
+  function SetOutput$computeOne$lambda($this_computeOne, $channel) {
+    return function ($this$replySuccess) {
+      $this$replySuccess.g2r($this_computeOne.context.m1y().setCurrentChannel($channel));
+      return Unit_instance;
+    };
+  }
+  function SetOutput() {
+    SetOutput_instance = this;
+    NonBacktrackable_0.call(this, 'set_output');
+    this.r40_1 = '`set_output(+Stream)`\n\nMakes the output stream `Stream` the current output stream, i.e. the one used by the predicates without an explicit stream argument (e.g. `put_char/1`, `write/1`), succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error.\n\n**Examples**\n\n```prolog\n?- set_output(user_output), put_char(a).\n% prints: a\nyes.\n\n?- set_output(user_input).\nthrows error(domain_error(stream_type, user_input), _).\n\n?- set_output(S).\nthrows error(instantiation_error, _).\n```';
+  }
+  protoOf(SetOutput).w1x = function () {
+    return this.r40_1;
+  };
+  protoOf(SetOutput).i2u = function (_this__u8e3s4, first) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    return _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, SetOutput$computeOne$lambda(_this__u8e3s4, channel));
+  };
+  protoOf(SetOutput).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var SetOutput_instance;
+  function SetOutput_getInstance() {
+    if (SetOutput_instance == null)
+      new SetOutput();
+    return SetOutput_instance;
+  }
+  function SetTheory$setTheory$lambda($append, $solver) {
+    return function ($this$replySuccess) {
+      if ($append) {
+        $this$replySuccess.t2q($solver.j1y());
+        $this$replySuccess.w2q($solver.k1y());
+      } else {
+        $this$replySuccess.r2q($solver.j1y());
+        $this$replySuccess.u2q($solver.k1y());
+      }
+      $this$replySuccess.b2r($solver.q1y());
+      $this$replySuccess.a2r($solver.i1y());
+      return Unit_instance;
+    };
+  }
+  function SetTheory() {
+    SetTheory_instance = this;
+    NonBacktrackable_0.call(this, 'set_theory');
+    this.s3w_1 = "`set_theory(+Text)`\n\nParses the atom `Text` as Prolog source code, using the current operators, and makes the resulting theory the new knowledge base: both the static and the dynamic knowledge bases are replaced (clauses of predicates declared dynamic go to the dynamic one), and operators and flags set by its directives take effect. This predicate is tuProlog-specific; see `consult/1` to add clauses loaded from a file or URL instead. It raises a type error (`atom`) if `Text` is not an atom (including when it is unbound, where an instantiation error would be customary) and a syntax error if `Text` is not a well-formed theory.\n\n**Examples**\n\n```prolog\n?- set_theory('parent(tom, bob). parent(bob, ann).'), parent(bob, X).\nX = ann.\n\n?- set_theory(42).\nthrows error(type_error(atom, 42), _).\n\n?- set_theory('foo(.').\nthrows error(syntax_error, _).\n```";
+  }
+  protoOf(SetTheory).w1x = function () {
+    return this.s3w_1;
+  };
+  protoOf(SetTheory).i2u = function (_this__u8e3s4, first) {
+    Companion_getInstance_1().b2m(_this__u8e3s4, 0);
+    return this.s40(_this__u8e3s4, first.yx().h2(), false);
+  };
+  protoOf(SetTheory).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  protoOf(SetTheory).s40 = function (_this__u8e3s4, text, append) {
+    try {
+      var theory = Companion_instance_11.withOperatorSet(_this__u8e3s4.context.q1y()).parseTheoryWithDefaultUnificator(text);
+      var solver = _this__u8e3s4.context.createMutableSolver(VOID, VOID, VOID, Companion_instance_12.empty(_this__u8e3s4.context.i1o()), Companion_instance_13.empty(_this__u8e3s4.context.i1o()));
+      solver.loadStaticKb(theory);
+      return _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, SetTheory$setTheory$lambda(append, solver));
+    } catch ($p) {
+      if ($p instanceof ParseException) {
+        var e = $p;
+        var tmp = Companion_instance_10;
+        var tmp_0 = e.clauseIndex;
+        var tmp_1 = e.line;
+        var tmp_2 = e.column;
+        var tmp0_safe_receiver = e.message;
+        var tmp_3;
+        if (tmp0_safe_receiver == null) {
+          tmp_3 = null;
+        } else {
+          // Inline function 'kotlin.text.replaceFirstChar' call
+          var tmp_4;
+          // Inline function 'kotlin.text.isNotEmpty' call
+          if (charSequenceLength(tmp0_safe_receiver) > 0) {
+            var it = charCodeAt(tmp0_safe_receiver, 0);
+            var tmp$ret$2 = isLowerCase(it) ? titlecase(it) : toString_0(it);
+            tmp_4 = toString(tmp$ret$2) + substring(tmp0_safe_receiver, 1);
+          } else {
+            tmp_4 = tmp0_safe_receiver;
+          }
+          tmp_3 = tmp_4;
+        }
+        var tmp1_elvis_lhs = tmp_3;
+        throw tmp.whileParsingClauses(_this__u8e3s4.context, text, tmp_0, tmp_1, tmp_2, tmp1_elvis_lhs == null ? '<no detail provided>' : tmp1_elvis_lhs);
+      } else {
+        throw $p;
+      }
+    }
+  };
+  protoOf(SetTheory).t3w = function (_this__u8e3s4, text, append, $super) {
+    append = append === VOID ? true : append;
+    return $super === VOID ? this.s40(_this__u8e3s4, text, append) : $super.s40.call(this, _this__u8e3s4, text, append);
+  };
+  var SetTheory_instance;
+  function SetTheory_getInstance() {
+    if (SetTheory_instance == null)
+      new SetTheory();
+    return SetTheory_instance;
+  }
+  function StreamProperty$computeAll$lambda(it) {
+    return asSequence(it.m2());
+  }
+  function StreamProperty$computeAll$lambda_0($this_computeAll) {
+    return function (it) {
+      return to(it.m22(), IOPrimitiveUtils_getInstance().j3y($this_computeAll, it));
+    };
+  }
+  function StreamProperty$computeAll$lambda_1(_destruct__k2r9zo) {
+    var streamTerm = _destruct__k2r9zo.he();
+    var properties = _destruct__k2r9zo.ie();
+    return map(properties, StreamProperty$computeAll$lambda$lambda(streamTerm));
+  }
+  function StreamProperty$computeAll$lambda$lambda($streamTerm) {
+    return function (it) {
+      return to($streamTerm, it);
+    };
+  }
+  function StreamProperty$computeAll$lambda_2($this_computeAll, $first, $second) {
+    return function (_destruct__k2r9zo) {
+      var streamTerm = _destruct__k2r9zo.he();
+      var property = _destruct__k2r9zo.ie();
+      return Companion_getInstance_1().m2l($this_computeAll, $first, streamTerm).plus(Companion_getInstance_1().m2l($this_computeAll, $second, property));
+    };
+  }
+  function StreamProperty$computeAll$lambda_3(it) {
+    return it.i13();
+  }
+  function StreamProperty$computeAll$lambda_4($this_computeAll) {
+    return function (it) {
+      return $this_computeAll.replyWith(it, VOID, []);
+    };
+  }
+  function StreamProperty() {
+    StreamProperty_instance = this;
+    BinaryRelation.call(this, 'stream_property');
+    this.u40_1 = '`stream_property(?Stream, ?Property)`\n\nEnumerates, on backtracking, every open stream `Stream` (as a `$stream(Direction, Id)` term) together with each `Property` holding for it; the current implementation reports `input` or `output`, one `alias(Name)` per alias of the stream, and `type(text)`. If `Stream` is bound it must be a stream term (aliases are not accepted), otherwise a domain error (`stream_or_alias`) is raised, or an existence error if it denotes no open stream. If `Property` is bound it must be `input`, `output` or `alias(Name)`, otherwise a domain error (`stream_property`) is raised, so the reported `type(text)` property cannot be queried directly.\n\n**Examples**\n\n```prolog\n?- stream_property(S, alias(user_output)), stream_property(S, output).\nyes.\n\n?- stream_property(S, type(text)).\nthrows error(domain_error(stream_property, type(text)), _).\n\n?- stream_property(user_output, P).\nthrows error(domain_error(stream_or_alias, user_output), _).\n```';
+  }
+  protoOf(StreamProperty).w1x = function () {
+    return this.u40_1;
+  };
+  protoOf(StreamProperty).v2u = function (_this__u8e3s4, first, second) {
+    IOPrimitiveUtils_getInstance().y3w(_this__u8e3s4, 0);
+    IOPrimitiveUtils_getInstance().q3y(_this__u8e3s4, 1);
+    var tmp = sequenceOf([_this__u8e3s4.context.l1y(), _this__u8e3s4.context.m1y()]);
+    var tmp_0 = distinct(flatMap(tmp, StreamProperty$computeAll$lambda));
+    var tmp_1 = map(tmp_0, StreamProperty$computeAll$lambda_0(_this__u8e3s4));
+    var tmp_2 = flatMap(tmp_1, StreamProperty$computeAll$lambda_1);
+    var tmp_3 = map(tmp_2, StreamProperty$computeAll$lambda_2(_this__u8e3s4, first, second));
+    var tmp_4 = filter(tmp_3, StreamProperty$computeAll$lambda_3);
+    return map(tmp_4, StreamProperty$computeAll$lambda_4(_this__u8e3s4));
+  };
+  protoOf(StreamProperty).t2k = function (_this__u8e3s4, first, second) {
+    return this.v2u(_this__u8e3s4, first, second);
+  };
+  var StreamProperty_instance;
+  function StreamProperty_getInstance() {
+    if (StreamProperty_instance == null)
+      new StreamProperty();
+    return StreamProperty_instance;
+  }
+  function Write2() {
+    Write2_instance = this;
+    NonBacktrackable.call(this, 'write');
+    this.w40_1 = "`write(+Stream, @Term)`\n\nWrites `Term` to the output stream `Stream` as `write/1` does: unquoted, using the current operators, and writing `'$VAR'(N)` terms as variable letters. It succeeds deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write(user_output, 'hello world').\n% prints: hello world\nyes.\n\n?- write(user_output, f('A', 1 + 2, '$VAR'(27))).\n% prints: f(A, 1 + 2, B1)\nyes.\n\n?- write(user_input, hello).\nthrows error(domain_error(stream_type, user_input), _).\n```";
+  }
+  protoOf(Write2).w1x = function () {
+    return this.w40_1;
+  };
+  protoOf(Write2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, channel, second, Companion_instance_7.default(_this__u8e3s4.context.q1y()));
+  };
+  protoOf(Write2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var Write2_instance;
+  function Write2_getInstance() {
+    if (Write2_instance == null)
+      new Write2();
+    return Write2_instance;
+  }
+  function WriteCanonical1() {
+    WriteCanonical1_instance = this;
+    NonBacktrackable_0.call(this, 'write_canonical');
+    this.y40_1 = "`write_canonical(@Term)`\n\nWrites `Term` to the current output stream (standard output, unless changed via `set_output/1`) in canonical form: atoms and functors are quoted where needed, operators are written in functional notation, and `'$VAR'(N)` terms are written as-is. It succeeds deterministically. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_canonical(f('A', 1 + 2, '$VAR'(27))).\n% prints: f('A', '+'(1, 2), '$VAR'(27))\nyes.\n```";
+  }
+  protoOf(WriteCanonical1).w1x = function () {
+    return this.y40_1;
+  };
+  protoOf(WriteCanonical1).i2u = function (_this__u8e3s4, first) {
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().k3y(_this__u8e3s4), first, Companion_instance_7.canonical());
+  };
+  protoOf(WriteCanonical1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var WriteCanonical1_instance;
+  function WriteCanonical1_getInstance() {
+    if (WriteCanonical1_instance == null)
+      new WriteCanonical1();
+    return WriteCanonical1_instance;
+  }
+  function WriteCanonical2() {
+    WriteCanonical2_instance = this;
+    NonBacktrackable.call(this, 'write_canonical');
+    this.a41_1 = "`write_canonical(+Stream, @Term)`\n\nWrites `Term` to the output stream `Stream` in canonical form: atoms and functors are quoted where needed, operators are written in functional notation, and `'$VAR'(N)` terms are written as-is. It succeeds deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_canonical(user_output, f('A', 1 + 2)).\n% prints: f('A', '+'(1, 2))\nyes.\n\n?- write_canonical(user_input, a).\nthrows error(domain_error(stream_type, user_input), _).\n```";
+  }
+  protoOf(WriteCanonical2).w1x = function () {
+    return this.a41_1;
+  };
+  protoOf(WriteCanonical2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, channel, second, Companion_instance_7.canonical());
+  };
+  protoOf(WriteCanonical2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var WriteCanonical2_instance;
+  function WriteCanonical2_getInstance() {
+    if (WriteCanonical2_instance == null)
+      new WriteCanonical2();
+    return WriteCanonical2_instance;
+  }
+  function WriteEq1() {
+    WriteEq1_instance = this;
+    NonBacktrackable_0.call(this, 'writeq');
+    this.c41_1 = "`writeq(@Term)`\n\nWrites `Term` to the current output stream (standard output, unless changed via `set_output/1`) so that it can be read back: atoms and functors are quoted where needed, operators are written in operator notation, and `'$VAR'(N)` terms are written as variable letters. It succeeds deterministically. The current implementation formats operators according to the default operator table rather than the current one. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- writeq(f('A', 'hello world', 1 + 2, '$VAR'(27))).\n% prints: f('A', 'hello world', 1 + 2, B1)\nyes.\n```";
+  }
+  protoOf(WriteEq1).w1x = function () {
+    return this.c41_1;
+  };
+  protoOf(WriteEq1).i2u = function (_this__u8e3s4, first) {
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().k3y(_this__u8e3s4), first, Companion_instance_7.readable());
+  };
+  protoOf(WriteEq1).a2o = function (_this__u8e3s4, first) {
+    return this.i2u(_this__u8e3s4, first);
+  };
+  var WriteEq1_instance;
+  function WriteEq1_getInstance() {
+    if (WriteEq1_instance == null)
+      new WriteEq1();
+    return WriteEq1_instance;
+  }
+  function WriteEq2() {
+    WriteEq2_instance = this;
+    NonBacktrackable.call(this, 'writeq');
+    this.e41_1 = "`writeq(+Stream, @Term)`\n\nWrites `Term` to the output stream `Stream` so that it can be read back, quoting atoms and functors where needed and writing `'$VAR'(N)` terms as variable letters; the current implementation formats operators according to the default operator table rather than the current one. It succeeds deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- writeq(user_output, f('A', 1 + 2)).\n% prints: f('A', 1 + 2)\nyes.\n\n?- writeq(user_input, a).\nthrows error(domain_error(stream_type, user_input), _).\n```";
+  }
+  protoOf(WriteEq2).w1x = function () {
+    return this.e41_1;
+  };
+  protoOf(WriteEq2).z2u = function (_this__u8e3s4, first, second) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, channel, second, Companion_instance_7.readable());
+  };
+  protoOf(WriteEq2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var WriteEq2_instance;
+  function WriteEq2_getInstance() {
+    if (WriteEq2_instance == null)
+      new WriteEq2();
+    return WriteEq2_instance;
+  }
+  function WriteTerm2() {
+    WriteTerm2_instance = this;
+    NonBacktrackable.call(this, 'write_term');
+    this.g41_1 = "`write_term(@Term, +Options)`\n\nWrites `Term` to the current output stream (standard output, unless changed via `set_output/1`), formatted according to `Options` and the current operators, succeeding deterministically. `Options` must be a list (an unbound `Options` raises a type error (`list`) rather than ISO's instantiation error) whose elements are `quoted(Bool)` (quote atoms and functors where needed), `ignore_ops(Bool)` (write operators in canonical functional notation) and `numbervars(Bool)` (write `'$VAR'(N)` terms as variable letters), with `Bool` being `true` or `false`; missing options default to `false`, and any other element raises a domain error (`write_option`). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_term(f('A', 1 + 2), [quoted(true), ignore_ops(true)]).\n% prints: f('A', '+'(1, 2))\nyes.\n\n?- write_term(f('A', 1 + 2), []).\n% prints: f(A, 1 + 2)\nyes.\n\n?- write_term(a, [foo]).\nthrows error(domain_error(write_option, foo), _).\n\n?- write_term(a, Options).\nthrows error(type_error(list, _), _).\n```";
+  }
+  protoOf(WriteTerm2).w1x = function () {
+    return this.g41_1;
+  };
+  protoOf(WriteTerm2).z2u = function (_this__u8e3s4, first, second) {
+    var formatter = IOPrimitiveUtils_getInstance().p3y(_this__u8e3s4, 1);
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, IOPrimitiveUtils_getInstance().k3y(_this__u8e3s4), first, formatter);
+  };
+  protoOf(WriteTerm2).r2k = function (_this__u8e3s4, first, second) {
+    return this.z2u(_this__u8e3s4, first, second);
+  };
+  var WriteTerm2_instance;
+  function WriteTerm2_getInstance() {
+    if (WriteTerm2_instance == null)
+      new WriteTerm2();
+    return WriteTerm2_instance;
+  }
+  function WriteTerm3() {
+    WriteTerm3_instance = this;
+    NonBacktrackable_1.call(this, 'write_term');
+    this.i41_1 = "`write_term(+Stream, @Term, +Options)`\n\nWrites `Term` to the output stream `Stream`, formatted according to `Options` and the current operators, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. `Options` must be a list (an unbound `Options` raises a type error (`list`) rather than ISO's instantiation error) whose elements are `quoted(Bool)` (quote atoms and functors where needed), `ignore_ops(Bool)` (write operators in canonical functional notation) and `numbervars(Bool)` (write `'$VAR'(N)` terms as variable letters), with `Bool` being `true` or `false`; missing options default to `false`, and any other element raises a domain error (`write_option`). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_term(user_output, '$VAR'(27), [numbervars(true)]).\n% prints: B1\nyes.\n\n?- write_term(user_output, a, [quoted(maybe)]).\nthrows error(domain_error(write_option, quoted(maybe)), _).\n\n?- write_term(user_input, a, []).\nthrows error(domain_error(stream_type, user_input), _).\n```";
+  }
+  protoOf(WriteTerm3).w1x = function () {
+    return this.i41_1;
+  };
+  protoOf(WriteTerm3).t2z = function (_this__u8e3s4, first, second, third) {
+    var channel = IOPrimitiveUtils_getInstance().d3x(_this__u8e3s4, 0);
+    var formatter = IOPrimitiveUtils_getInstance().p3y(_this__u8e3s4, 2);
+    return IOPrimitiveUtils_getInstance().t3y(_this__u8e3s4, channel, second, formatter);
+  };
+  protoOf(WriteTerm3).t2n = function (_this__u8e3s4, first, second, third) {
+    return this.t2z(_this__u8e3s4, first, second, third);
+  };
+  var WriteTerm3_instance;
+  function WriteTerm3_getInstance() {
+    if (WriteTerm3_instance == null)
+      new WriteTerm3();
+    return WriteTerm3_instance;
+  }
+  function JsUrl_init_$Init$(url, $this) {
+    JsUrl.call($this);
+    var tmp;
+    try {
+      tmp = new URL(url);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        var e = $p;
+        throw InvalidUrlException_init_$Create$_0('Invalid URL: ' + url, e);
+      } else {
+        throw $p;
+      }
+    }
+    var parsed = tmp;
+    if (removeSuffix(parsed.protocol, ':').length === 1) {
+      throw InvalidUrlException_init_$Create$('Invalid URL: ' + url);
+    }
+    $this.k41_1 = removeSuffix(parsed.protocol, ':');
+    $this.l41_1 = parsed.hostname;
+    $this.m41_1 = parsed.pathname;
+    $this.n41_1 = toIntOrNull(parsed.port);
+    var tmp_1 = $this;
+    // Inline function 'kotlin.text.ifEmpty' call
+    var this_0 = removePrefix(parsed.search, '?');
+    var tmp_2;
+    // Inline function 'kotlin.text.isEmpty' call
+    if (charSequenceLength(this_0) === 0) {
+      tmp_2 = null;
+    } else {
+      tmp_2 = this_0;
+    }
+    tmp_1.o41_1 = tmp_2;
+    $this.j41_1 = url;
+    return $this;
+  }
+  function JsUrl_init_$Create$(url) {
+    return JsUrl_init_$Init$(url, objectCreate(protoOf(JsUrl)));
+  }
+  function JsUrl_init_$Init$_0(protocol, host, port, path, query, $this) {
+    host = host === VOID ? '' : host;
+    port = port === VOID ? null : port;
+    path = path === VOID ? '' : path;
+    query = query === VOID ? null : query;
+    JsUrl.call($this);
+    $this.k41_1 = protocol;
+    $this.l41_1 = host;
+    $this.n41_1 = port;
+    $this.m41_1 = path;
+    $this.o41_1 = query;
+    $this.j41_1 = Companion_instance_15.n3u(protocol, host, port, path, query);
+    return $this;
+  }
+  function JsUrl_init_$Create$_0(protocol, host, port, path, query) {
+    return JsUrl_init_$Init$_0(protocol, host, port, path, query, objectCreate(protoOf(JsUrl)));
+  }
+  function readLocalFile($this, action) {
+    var tmp;
+    try {
+      // Inline function 'okio.use' call
+      var this_0 = buffer(LocalFileSystem_getInstance().k3c(toLocalPath($this)));
+      var thrown = null;
+      var tmp_0;
+      try {
+        tmp_0 = action(this_0);
+      } catch ($p) {
+        var tmp_1;
+        if ($p instanceof Error) {
+          var t = $p;
+          thrown = t;
+          tmp_1 = null;
+        } else {
+          throw $p;
+        }
+        tmp_0 = tmp_1;
+      }
+      finally {
+        try {
+          if (this_0 == null)
+            null;
+          else {
+            this_0.z22();
+          }
+        } catch ($p_0) {
+          if ($p_0 instanceof Error) {
+            var t_0 = $p_0;
+            if (thrown == null) {
+              thrown = t_0;
+            } else {
+              addSuppressed(thrown, t_0);
+            }
+          } else {
+            throw $p_0;
+          }
+        }
+      }
+      var result = tmp_0;
+      if (!(thrown == null))
+        throw thrown;
+      tmp = result;
+    } catch ($p_1) {
+      var tmp_2;
+      if ($p_1 instanceof IOException) {
+        var e = $p_1;
+        throw IOException_init_$Create$_0(e.message, e);
+      } else {
+        throw $p_1;
+      }
+    }
+    return tmp;
+  }
+  function JsUrl$readAsText$lambda(it) {
+    return it.c3d();
+  }
+  function JsUrl$readAsByteArray$lambda(it) {
+    return it.f3d();
+  }
+  protoOf(JsUrl).o3u = function () {
+    return this.k41_1;
+  };
+  protoOf(JsUrl).p3u = function () {
+    return this.l41_1;
+  };
+  protoOf(JsUrl).q3u = function () {
+    return this.m41_1;
+  };
+  protoOf(JsUrl).r3u = function () {
+    return this.n41_1;
+  };
+  protoOf(JsUrl).w1z = function () {
+    return this.o41_1;
+  };
+  protoOf(JsUrl).p41 = function () {
+    var tmp;
+    if (this.s3u() && get_isNode()) {
+      tmp = readLocalFile(this, JsUrl$readAsText$lambda);
+    } else if (this.s3u()) {
+      tmp = readText(this.m41_1);
+    } else {
+      tmp = fetch(this.j41_1, 'UTF-8');
+    }
+    return tmp;
+  };
+  protoOf(JsUrl).readAsText = function () {
+    return this.p41();
+  };
+  protoOf(JsUrl).q41 = function () {
+    var tmp;
+    if (this.s3u() && get_isNode()) {
+      tmp = readLocalFile(this, JsUrl$readAsByteArray$lambda);
+    } else if (this.s3u()) {
+      tmp = readBin(this.m41_1);
+    } else {
+      tmp = toByteArray(fetch(this.j41_1));
+    }
+    return tmp;
+  };
+  protoOf(JsUrl).readAsByteArray = function () {
+    return this.q41();
+  };
+  protoOf(JsUrl).equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null || !(this.constructor == other.constructor))
+      return false;
+    if (!(other instanceof JsUrl))
+      THROW_CCE();
+    if (!(this.j41_1 === other.j41_1))
+      return false;
+    return true;
+  };
+  protoOf(JsUrl).hashCode = function () {
+    return getStringHashCode(this.j41_1);
+  };
+  protoOf(JsUrl).toString = function () {
+    return this.j41_1;
+  };
+  function JsUrl() {
+  }
+  function get_REQUEST() {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    var tmp0 = REQUEST$delegate;
+    var tmp = KProperty0;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  var REQUEST$delegate;
+  function get_isNode() {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    return !Info_getInstance().ov().equals(Platform_BROWSER_getInstance());
+  }
+  function readText(path) {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    // Inline function 'kotlin.js.unsafeCast' call
+    var tmp0_elvis_lhs = window.localStorage.getItem(path);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw IOException_init_$Create$('No such entry in window.localStorage: ' + path);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  }
+  function fetch(url, encoding) {
+    encoding = encoding === VOID ? null : encoding;
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    try {
+      var response = get_REQUEST()('GET', url, {});
+      // Inline function 'kotlin.js.unsafeCast' call
+      return response.getBody(encoding);
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var e = $p;
+        throw IOException_init_$Create$_0(e.message, e);
+      } else {
+        throw $p;
+      }
+    }
+  }
+  function readBin(path) {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    // Inline function 'kotlin.js.unsafeCast' call
+    var tmp0_safe_receiver = window.localStorage.getItem(path);
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : toByteArray(tmp0_safe_receiver);
+    var tmp;
+    if (tmp1_elvis_lhs == null) {
+      throw IOException_init_$Create$('No such entry in window.localStorage: ' + path);
+    } else {
+      tmp = tmp1_elvis_lhs;
+    }
+    return tmp;
+  }
+  function toByteArray(_this__u8e3s4) {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    return toByteArray_0(toUInt8Array(_this__u8e3s4));
+  }
+  function toByteArray_0(_this__u8e3s4) {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    var tmp = 0;
+    var tmp_0 = _this__u8e3s4.length;
+    var tmp_1 = new Int8Array(tmp_0);
+    while (tmp < tmp_0) {
+      var tmp_2 = tmp;
+      // Inline function 'org.khronos.webgl.get' call
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp_1[tmp_2] = _this__u8e3s4[tmp_2];
+      tmp = tmp + 1 | 0;
+    }
+    return tmp_1;
+  }
+  function toUInt8Array(_this__u8e3s4) {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    return new Uint8Array(_this__u8e3s4);
+  }
+  function REQUEST$delegate$lambda() {
+    _init_properties_RemoteAndBrowserIO_kt__6j78jn();
+    return require('sync-request');
+  }
+  function _get_REQUEST_$ref_g5y4c1() {
+    return constructCallableReference(function () {
+      return get_REQUEST();
+    }, 0, 0, 107);
+  }
+  var properties_initialized_RemoteAndBrowserIO_kt_w2uybl;
+  function _init_properties_RemoteAndBrowserIO_kt__6j78jn() {
+    if (!properties_initialized_RemoteAndBrowserIO_kt_w2uybl) {
+      properties_initialized_RemoteAndBrowserIO_kt_w2uybl = true;
+      REQUEST$delegate = lazy(REQUEST$delegate$lambda);
+    }
+  }
+  function get_platformFileSystem() {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    return platformFileSystem;
+  }
+  var platformFileSystem;
+  function get_FILE_URL_TO_PATH() {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    var tmp0 = FILE_URL_TO_PATH$delegate;
+    var tmp = KProperty0;
+    // Inline function 'kotlin.getValue' call
+    /* dead property reference removed */
+    return tmp0.h2();
+  }
+  var FILE_URL_TO_PATH$delegate;
+  function fileUrl(path) {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    return JsUrl_init_$Create$_0('file', VOID, VOID, path);
+  }
+  function remoteUrl(protocol, host, port, path, query) {
+    host = host === VOID ? '' : host;
+    port = port === VOID ? null : port;
+    path = path === VOID ? '' : path;
+    query = query === VOID ? null : query;
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    return JsUrl_init_$Create$_0(protocol, host, port, path, query);
+  }
+  function parseUrl(string) {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    return JsUrl_init_$Create$(string);
+  }
+  function openInputChannel(_this__u8e3s4) {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    var tmp;
+    if (_this__u8e3s4.s3u() && get_isNode()) {
+      tmp = wrappingIOException(openInputChannel$lambda(_this__u8e3s4));
+    } else {
+      tmp = Companion_instance.ofString(_this__u8e3s4.readAsText());
+    }
+    return tmp;
+  }
+  function openOutputChannel(_this__u8e3s4, append) {
+    append = append === VOID ? false : append;
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    if (!_this__u8e3s4.s3u() || !get_isNode()) {
+      throw IOException_init_$Create$('Writing not supported for ' + toString(_this__u8e3s4));
+    }
+    var path = toLocalPath(_this__u8e3s4);
+    return wrappingIOException(openOutputChannel$lambda(append, path));
+  }
+  function toLocalPath(_this__u8e3s4) {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    var tmp;
+    try {
+      var tmp_0 = Companion_getInstance_7();
+      var tmp_1 = get_FILE_URL_TO_PATH()(toString(_this__u8e3s4));
+      tmp = tmp_0.i3c((!(tmp_1 == null) ? typeof tmp_1 === 'string' : false) ? tmp_1 : THROW_CCE());
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3 = $p;
+        tmp_2 = Companion_getInstance_7().i3c(_this__u8e3s4.q3u());
+      } else {
+        throw $p;
+      }
+      tmp = tmp_2;
+    }
+    return tmp;
+  }
+  function wrappingIOException(action) {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    var tmp;
+    try {
+      tmp = action();
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IOException) {
+        var e = $p;
+        throw IOException_init_$Create$_0(e.message, e);
+      } else {
+        throw $p;
+      }
+    }
+    return tmp;
+  }
+  function FILE_URL_TO_PATH$delegate$lambda() {
+    _init_properties_UrlUtilsJs_kt__dw3tit();
+    return eval('require')('url').fileURLToPath;
+  }
+  function _get_FILE_URL_TO_PATH_$ref_kwvzgc() {
+    return constructCallableReference(function () {
+      return get_FILE_URL_TO_PATH();
+    }, 0, 0, 108);
+  }
+  function openInputChannel$lambda($this_openInputChannel) {
+    return function () {
+      return new SourceInputChannel(buffer(LocalFileSystem_getInstance().k3c(toLocalPath($this_openInputChannel))));
+    };
+  }
+  function openOutputChannel$lambda($append, $path) {
+    return function () {
+      var sink = $append ? LocalFileSystem_getInstance().i3u($path) : LocalFileSystem_getInstance().h3u($path);
+      return new SinkOutputChannel(buffer_0(sink));
+    };
+  }
+  var properties_initialized_UrlUtilsJs_kt_66lob1;
+  function _init_properties_UrlUtilsJs_kt__dw3tit() {
+    if (!properties_initialized_UrlUtilsJs_kt_66lob1) {
+      properties_initialized_UrlUtilsJs_kt_66lob1 = true;
+      platformFileSystem = NodeJsFileSystem_getInstance();
+      FILE_URL_TO_PATH$delegate = lazy(FILE_URL_TO_PATH$delegate$lambda);
+    }
+  }
+  //region block: post-declaration
+  protoOf(JsUrl).resolve = resolve;
+  protoOf(JsUrl).div = div;
+  protoOf(JsUrl).s3u = get_isFile;
+  protoOf(JsUrl).t3u = get_isHttp;
+  //endregion
+  //region block: init
+  Companion_instance_15 = new Companion_0();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = IOLib_getInstance;
+  _.$_$.b = Companion_instance_15;
   //endregion
   return _;
 }));