@solibo/solibo-sdk 1.0.23-SNAPSHOT

package/kotlin-kotlin-stdlib.js

@@ -0,0 +1,3118 @@
+//region block: polyfills
+(function () {
+  if (typeof globalThis === 'object')
+    return;
+  Object.defineProperty(Object.prototype, '__magic__', {get: function () {
+    return this;
+  }, configurable: true});
+  __magic__.globalThis = __magic__;
+  delete Object.prototype.__magic__;
+}());
+if (typeof Math.imul === 'undefined') {
+  Math.imul = function imul(a, b) {
+    return (a & 4.29490176E9) * (b & 65535) + (a & 65535) * (b | 0) | 0;
+  };
+}
+if (typeof ArrayBuffer.isView === 'undefined') {
+  ArrayBuffer.isView = function (a) {
+    return a != null && a.__proto__ != null && a.__proto__.__proto__ === Int8Array.prototype.__proto__;
+  };
+}
+if (typeof Array.prototype.fill === 'undefined') {
+  // Polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill#Polyfill
+  Object.defineProperty(Array.prototype, 'fill', {value: function (value) {
+    // Steps 1-2.
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+    var O = Object(this); // Steps 3-5.
+    var len = O.length >>> 0; // Steps 6-7.
+    var start = arguments[1];
+    var relativeStart = start >> 0; // Step 8.
+    var k = relativeStart < 0 ? Math.max(len + relativeStart, 0) : Math.min(relativeStart, len); // Steps 9-10.
+    var end = arguments[2];
+    var relativeEnd = end === undefined ? len : end >> 0; // Step 11.
+    var finalValue = relativeEnd < 0 ? Math.max(len + relativeEnd, 0) : Math.min(relativeEnd, len); // Step 12.
+    while (k < finalValue) {
+      O[k] = value;
+      k++;
+    }
+    ; // Step 13.
+    return O;
+  }});
+}
+[Int8Array, Int16Array, Uint16Array, Int32Array, Float32Array, Float64Array].forEach(function (TypedArray) {
+  if (typeof TypedArray.prototype.fill === 'undefined') {
+    Object.defineProperty(TypedArray.prototype, 'fill', {value: Array.prototype.fill});
+  }
+});
+if (typeof Math.clz32 === 'undefined') {
+  Math.clz32 = function (log, LN2) {
+    return function (x) {
+      var asUint = x >>> 0;
+      if (asUint === 0) {
+        return 32;
+      }
+      return 31 - (log(asUint) / LN2 | 0) | 0; // the "| 0" acts like math.floor
+    };
+  }(Math.log, Math.LN2);
+}
+//endregion
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['kotlin-kotlin-stdlib'] = factory(typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined' ? {} : globalThis['kotlin-kotlin-stdlib']);
+}(function (_) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var isView = ArrayBuffer.isView;
+  var clz32 = Math.clz32;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForInterface(CharSequence, 'CharSequence');
+  initMetadataForInterface(Comparable, 'Comparable');
+  initMetadataForClass(Number_0, 'Number');
+  initMetadataForClass(Char, 'Char', VOID, VOID, [Comparable]);
+  initMetadataForInterface(Collection, 'Collection');
+  initMetadataForInterface(KtList, 'List', VOID, VOID, [Collection]);
+  initMetadataForInterface(KtSet, 'Set', VOID, VOID, [Collection]);
+  initMetadataForInterface(Entry, 'Entry');
+  initMetadataForInterface(KtMap, 'Map');
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(Long, 'Long', VOID, Number_0, [Number_0, Comparable]);
+  initMetadataForInterface(FunctionAdapter, 'FunctionAdapter');
+  initMetadataForInterface(Comparator, 'Comparator');
+  initMetadataForObject(Unit, 'Unit');
+  initMetadataForClass(AbstractCollection, 'AbstractCollection', VOID, VOID, [Collection]);
+  initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [AbstractCollection, Collection]);
+  initMetadataForClass(IteratorImpl, 'IteratorImpl');
+  initMetadataForClass(AbstractMutableList, 'AbstractMutableList', VOID, AbstractMutableCollection, [AbstractMutableCollection, KtList, Collection]);
+  initMetadataForClass(AbstractMap, 'AbstractMap', VOID, VOID, [KtMap]);
+  initMetadataForClass(AbstractMutableMap, 'AbstractMutableMap', VOID, AbstractMap, [AbstractMap, KtMap]);
+  initMetadataForClass(AbstractMutableSet, 'AbstractMutableSet', VOID, AbstractMutableCollection, [AbstractMutableCollection, KtSet, Collection]);
+  initMetadataForCompanion(Companion_0);
+  initMetadataForClass(ArrayList, 'ArrayList', ArrayList_init_$Create$, AbstractMutableList, [AbstractMutableList, KtList, Collection]);
+  initMetadataForClass(HashMap, 'HashMap', HashMap_init_$Create$, AbstractMutableMap, [AbstractMutableMap, KtMap]);
+  initMetadataForClass(HashMapEntrySetBase, 'HashMapEntrySetBase', VOID, AbstractMutableSet, [KtSet, Collection, AbstractMutableSet]);
+  initMetadataForClass(HashMapEntrySet, 'HashMapEntrySet', VOID, HashMapEntrySetBase);
+  initMetadataForCompanion(Companion_1);
+  initMetadataForClass(Itr, 'Itr');
+  initMetadataForClass(EntriesItr, 'EntriesItr', VOID, Itr);
+  initMetadataForClass(EntryRef, 'EntryRef', VOID, VOID, [Entry]);
+  function containsAllEntries(m) {
+    var tmp$ret$0;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.all' call
+      var tmp;
+      if (isInterface(m, Collection)) {
+        tmp = m.h();
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        tmp$ret$0 = true;
+        break $l$block_0;
+      }
+      var _iterator__ex2g4s = m.c();
+      while (_iterator__ex2g4s.d()) {
+        var element = _iterator__ex2g4s.e();
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var entry = element;
+        var tmp_0;
+        if (!(entry == null) ? isInterface(entry, Entry) : false) {
+          tmp_0 = this.x3(entry);
+        } else {
+          tmp_0 = false;
+        }
+        if (!tmp_0) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  }
+  initMetadataForInterface(InternalMap, 'InternalMap');
+  initMetadataForClass(InternalHashMap, 'InternalHashMap', InternalHashMap_init_$Create$, VOID, [InternalMap]);
+  initMetadataForClass(LinkedHashMap, 'LinkedHashMap', LinkedHashMap_init_$Create$, HashMap, [HashMap, KtMap]);
+  initMetadataForClass(Exception, 'Exception', Exception_init_$Create$, Error);
+  initMetadataForClass(RuntimeException, 'RuntimeException', RuntimeException_init_$Create$, Exception);
+  initMetadataForClass(UnsupportedOperationException, 'UnsupportedOperationException', UnsupportedOperationException_init_$Create$, RuntimeException);
+  initMetadataForClass(IllegalStateException, 'IllegalStateException', IllegalStateException_init_$Create$, RuntimeException);
+  initMetadataForClass(IllegalArgumentException, 'IllegalArgumentException', IllegalArgumentException_init_$Create$, RuntimeException);
+  initMetadataForClass(NoSuchElementException, 'NoSuchElementException', NoSuchElementException_init_$Create$, RuntimeException);
+  initMetadataForClass(IndexOutOfBoundsException, 'IndexOutOfBoundsException', IndexOutOfBoundsException_init_$Create$, RuntimeException);
+  initMetadataForClass(ConcurrentModificationException, 'ConcurrentModificationException', ConcurrentModificationException_init_$Create$, RuntimeException);
+  initMetadataForClass(NullPointerException, 'NullPointerException', NullPointerException_init_$Create$, RuntimeException);
+  initMetadataForClass(ClassCastException, 'ClassCastException', ClassCastException_init_$Create$, RuntimeException);
+  initMetadataForClass(KClassImpl, 'KClassImpl');
+  initMetadataForClass(PrimitiveKClassImpl, 'PrimitiveKClassImpl', VOID, KClassImpl);
+  initMetadataForObject(NothingKClassImpl, 'NothingKClassImpl', VOID, KClassImpl);
+  initMetadataForClass(StringBuilder, 'StringBuilder', StringBuilder_init_$Create$_0, VOID, [CharSequence]);
+  initMetadataForCompanion(Companion_2);
+  initMetadataForCompanion(Companion_3);
+  initMetadataForCompanion(Companion_4);
+  initMetadataForObject(EmptyList, 'EmptyList', VOID, VOID, [KtList]);
+  initMetadataForObject(EmptyIterator, 'EmptyIterator');
+  initMetadataForClass(Random, 'Random');
+  initMetadataForObject(Default, 'Default', VOID, Random);
+  initMetadataForCompanion(Companion_5);
+  initMetadataForClass(XorWowRandom, 'XorWowRandom', VOID, Random);
+  initMetadataForClass(UnsafeLazyImpl, 'UnsafeLazyImpl');
+  initMetadataForObject(UNINITIALIZED_VALUE, 'UNINITIALIZED_VALUE');
+  //endregion
+  function CharSequence() {
+  }
+  function Comparable() {
+  }
+  function Number_0() {
+  }
+  function indexOf(_this__u8e3s4, element) {
+    if (element == null) {
+      var inductionVariable = 0;
+      var last = _this__u8e3s4.length - 1 | 0;
+      if (inductionVariable <= last)
+        do {
+          var index = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          if (_this__u8e3s4[index] == null) {
+            return index;
+          }
+        }
+         while (inductionVariable <= last);
+    } else {
+      var inductionVariable_0 = 0;
+      var last_0 = _this__u8e3s4.length - 1 | 0;
+      if (inductionVariable_0 <= last_0)
+        do {
+          var index_0 = inductionVariable_0;
+          inductionVariable_0 = inductionVariable_0 + 1 | 0;
+          if (equals(element, _this__u8e3s4[index_0])) {
+            return index_0;
+          }
+        }
+         while (inductionVariable_0 <= last_0);
+    }
+    return -1;
+  }
+  function joinToString(_this__u8e3s4, separator, prefix, postfix, limit, truncated, transform) {
+    separator = separator === VOID ? ', ' : separator;
+    prefix = prefix === VOID ? '' : prefix;
+    postfix = postfix === VOID ? '' : postfix;
+    limit = limit === VOID ? -1 : limit;
+    truncated = truncated === VOID ? '...' : truncated;
+    transform = transform === VOID ? null : transform;
+    return joinTo(_this__u8e3s4, StringBuilder_init_$Create$_0(), separator, prefix, postfix, limit, truncated, transform).toString();
+  }
+  function get_lastIndex(_this__u8e3s4) {
+    return _this__u8e3s4.length - 1 | 0;
+  }
+  function joinTo(_this__u8e3s4, buffer, separator, prefix, postfix, limit, truncated, transform) {
+    separator = separator === VOID ? ', ' : separator;
+    prefix = prefix === VOID ? '' : prefix;
+    postfix = postfix === VOID ? '' : postfix;
+    limit = limit === VOID ? -1 : limit;
+    truncated = truncated === VOID ? '...' : truncated;
+    transform = transform === VOID ? null : transform;
+    buffer.b(prefix);
+    var count = 0;
+    var inductionVariable = 0;
+    var last = _this__u8e3s4.length;
+    $l$loop: while (inductionVariable < last) {
+      var element = _this__u8e3s4[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      count = count + 1 | 0;
+      if (count > 1) {
+        buffer.b(separator);
+      }
+      if (limit < 0 || count <= limit) {
+        appendElement(buffer, element, transform);
+      } else
+        break $l$loop;
+    }
+    if (limit >= 0 && count > limit) {
+      buffer.b(truncated);
+    }
+    buffer.b(postfix);
+    return buffer;
+  }
+  function joinToString_0(_this__u8e3s4, separator, prefix, postfix, limit, truncated, transform) {
+    separator = separator === VOID ? ', ' : separator;
+    prefix = prefix === VOID ? '' : prefix;
+    postfix = postfix === VOID ? '' : postfix;
+    limit = limit === VOID ? -1 : limit;
+    truncated = truncated === VOID ? '...' : truncated;
+    transform = transform === VOID ? null : transform;
+    return joinTo_0(_this__u8e3s4, StringBuilder_init_$Create$_0(), separator, prefix, postfix, limit, truncated, transform).toString();
+  }
+  function joinTo_0(_this__u8e3s4, buffer, separator, prefix, postfix, limit, truncated, transform) {
+    separator = separator === VOID ? ', ' : separator;
+    prefix = prefix === VOID ? '' : prefix;
+    postfix = postfix === VOID ? '' : postfix;
+    limit = limit === VOID ? -1 : limit;
+    truncated = truncated === VOID ? '...' : truncated;
+    transform = transform === VOID ? null : transform;
+    buffer.b(prefix);
+    var count = 0;
+    var _iterator__ex2g4s = _this__u8e3s4.c();
+    $l$loop: while (_iterator__ex2g4s.d()) {
+      var element = _iterator__ex2g4s.e();
+      count = count + 1 | 0;
+      if (count > 1) {
+        buffer.b(separator);
+      }
+      if (limit < 0 || count <= limit) {
+        appendElement(buffer, element, transform);
+      } else
+        break $l$loop;
+    }
+    if (limit >= 0 && count > limit) {
+      buffer.b(truncated);
+    }
+    buffer.b(postfix);
+    return buffer;
+  }
+  function toList(_this__u8e3s4) {
+    if (isInterface(_this__u8e3s4, Collection)) {
+      var tmp;
+      switch (_this__u8e3s4.f()) {
+        case 0:
+          tmp = emptyList();
+          break;
+        case 1:
+          var tmp_0;
+          if (isInterface(_this__u8e3s4, KtList)) {
+            tmp_0 = _this__u8e3s4.g(0);
+          } else {
+            tmp_0 = _this__u8e3s4.c().e();
+          }
+
+          tmp = listOf(tmp_0);
+          break;
+        default:
+          tmp = toMutableList(_this__u8e3s4);
+          break;
+      }
+      return tmp;
+    }
+    return optimizeReadOnlyList(toMutableList_0(_this__u8e3s4));
+  }
+  function first(_this__u8e3s4) {
+    if (_this__u8e3s4.h())
+      throw NoSuchElementException_init_$Create$_0('List is empty.');
+    return _this__u8e3s4.g(0);
+  }
+  function toMutableList(_this__u8e3s4) {
+    return ArrayList_init_$Create$_1(_this__u8e3s4);
+  }
+  function toMutableList_0(_this__u8e3s4) {
+    if (isInterface(_this__u8e3s4, Collection))
+      return toMutableList(_this__u8e3s4);
+    return toCollection(_this__u8e3s4, ArrayList_init_$Create$());
+  }
+  function sortedWith(_this__u8e3s4, comparator) {
+    if (isInterface(_this__u8e3s4, Collection)) {
+      if (_this__u8e3s4.f() <= 1)
+        return toList(_this__u8e3s4);
+      // Inline function 'kotlin.collections.toTypedArray' call
+      var tmp = copyToArray(_this__u8e3s4);
+      // Inline function 'kotlin.apply' call
+      var this_0 = isArray(tmp) ? tmp : THROW_CCE();
+      sortWith(this_0, comparator);
+      return asList(this_0);
+    }
+    // Inline function 'kotlin.apply' call
+    var this_1 = toMutableList_0(_this__u8e3s4);
+    sortWith_0(this_1, comparator);
+    return this_1;
+  }
+  function toCollection(_this__u8e3s4, destination) {
+    var _iterator__ex2g4s = _this__u8e3s4.c();
+    while (_iterator__ex2g4s.d()) {
+      var item = _iterator__ex2g4s.e();
+      destination.i(item);
+    }
+    return destination;
+  }
+  function coerceAtLeast(_this__u8e3s4, minimumValue) {
+    return _this__u8e3s4 < minimumValue ? minimumValue : _this__u8e3s4;
+  }
+  function coerceAtMost(_this__u8e3s4, maximumValue) {
+    return _this__u8e3s4 > maximumValue ? maximumValue : _this__u8e3s4;
+  }
+  function _Char___init__impl__6a9atx(value) {
+    return value;
+  }
+  function _get_value__a43j40($this) {
+    return $this;
+  }
+  function toString($this) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    return String.fromCharCode(_get_value__a43j40($this));
+  }
+  function Char() {
+  }
+  function KtList() {
+  }
+  function Collection() {
+  }
+  function KtSet() {
+  }
+  function Entry() {
+  }
+  function KtMap() {
+  }
+  function toString_0(_this__u8e3s4) {
+    var tmp1_elvis_lhs = _this__u8e3s4 == null ? null : toString_1(_this__u8e3s4);
+    return tmp1_elvis_lhs == null ? 'null' : tmp1_elvis_lhs;
+  }
+  function Companion() {
+    Companion_instance = this;
+    this.q_1 = new Long(0, -2147483648);
+    this.r_1 = new Long(-1, 2147483647);
+    this.s_1 = 8;
+    this.t_1 = 64;
+  }
+  var Companion_instance;
+  function Companion_getInstance() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Long(low, high) {
+    Companion_getInstance();
+    Number_0.call(this);
+    this.u_1 = low;
+    this.v_1 = high;
+  }
+  protoOf(Long).w = function (other) {
+    return compare(this, other);
+  };
+  protoOf(Long).a = function (other) {
+    return this.w(other instanceof Long ? other : THROW_CCE());
+  };
+  protoOf(Long).toString = function () {
+    return toStringImpl(this, 10);
+  };
+  protoOf(Long).equals = function (other) {
+    var tmp;
+    if (other instanceof Long) {
+      tmp = equalsLong(this, other);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(Long).hashCode = function () {
+    return hashCode(this);
+  };
+  protoOf(Long).valueOf = function () {
+    return toNumber(this);
+  };
+  function abs(_this__u8e3s4) {
+    var tmp;
+    // Inline function 'kotlin.js.internal.isNegative' call
+    if (_this__u8e3s4 < 0) {
+      // Inline function 'kotlin.js.internal.unaryMinus' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp = -_this__u8e3s4;
+    } else {
+      tmp = _this__u8e3s4;
+    }
+    return tmp;
+  }
+  function implement(interfaces) {
+    var maxSize = 1;
+    var masks = [];
+    var inductionVariable = 0;
+    var last = interfaces.length;
+    while (inductionVariable < last) {
+      var i = interfaces[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var currentSize = maxSize;
+      var tmp0_elvis_lhs = i.prototype.$imask$;
+      var imask = tmp0_elvis_lhs == null ? i.$imask$ : tmp0_elvis_lhs;
+      if (!(imask == null)) {
+        masks.push(imask);
+        currentSize = imask.length;
+      }
+      var iid = i.$metadata$.iid;
+      var tmp;
+      if (iid == null) {
+        tmp = null;
+      } else {
+        // Inline function 'kotlin.let' call
+        tmp = bitMaskWith(iid);
+      }
+      var iidImask = tmp;
+      if (!(iidImask == null)) {
+        masks.push(iidImask);
+        currentSize = Math.max(currentSize, iidImask.length);
+      }
+      if (currentSize > maxSize) {
+        maxSize = currentSize;
+      }
+    }
+    return compositeBitMask(maxSize, masks);
+  }
+  function bitMaskWith(activeBit) {
+    var numberIndex = activeBit >> 5;
+    var intArray = new Int32Array(numberIndex + 1 | 0);
+    var positionInNumber = activeBit & 31;
+    var numberWithSettledBit = 1 << positionInNumber;
+    intArray[numberIndex] = intArray[numberIndex] | numberWithSettledBit;
+    return intArray;
+  }
+  function compositeBitMask(capacity, masks) {
+    var tmp = 0;
+    var tmp_0 = new Int32Array(capacity);
+    while (tmp < capacity) {
+      var tmp_1 = tmp;
+      var result = 0;
+      var inductionVariable = 0;
+      var last = masks.length;
+      while (inductionVariable < last) {
+        var mask = masks[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        if (tmp_1 < mask.length) {
+          result = result | mask[tmp_1];
+        }
+      }
+      tmp_0[tmp_1] = result;
+      tmp = tmp + 1 | 0;
+    }
+    return tmp_0;
+  }
+  function isBitSet(_this__u8e3s4, possibleActiveBit) {
+    var numberIndex = possibleActiveBit >> 5;
+    if (numberIndex > _this__u8e3s4.length)
+      return false;
+    var positionInNumber = possibleActiveBit & 31;
+    var numberWithSettledBit = 1 << positionInNumber;
+    return !((_this__u8e3s4[numberIndex] & numberWithSettledBit) === 0);
+  }
+  function FunctionAdapter() {
+  }
+  function get_buf() {
+    _init_properties_bitUtils_kt__nfcg4k();
+    return buf;
+  }
+  var buf;
+  function get_bufFloat64() {
+    _init_properties_bitUtils_kt__nfcg4k();
+    return bufFloat64;
+  }
+  var bufFloat64;
+  var bufFloat32;
+  function get_bufInt32() {
+    _init_properties_bitUtils_kt__nfcg4k();
+    return bufInt32;
+  }
+  var bufInt32;
+  function get_lowIndex() {
+    _init_properties_bitUtils_kt__nfcg4k();
+    return lowIndex;
+  }
+  var lowIndex;
+  function get_highIndex() {
+    _init_properties_bitUtils_kt__nfcg4k();
+    return highIndex;
+  }
+  var highIndex;
+  function getNumberHashCode(obj) {
+    _init_properties_bitUtils_kt__nfcg4k();
+    // Inline function 'kotlin.js.jsBitwiseOr' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    if ((obj | 0) === obj) {
+      return numberToInt(obj);
+    }
+    get_bufFloat64()[0] = obj;
+    return imul(get_bufInt32()[get_highIndex()], 31) + get_bufInt32()[get_lowIndex()] | 0;
+  }
+  var properties_initialized_bitUtils_kt_i2bo3e;
+  function _init_properties_bitUtils_kt__nfcg4k() {
+    if (!properties_initialized_bitUtils_kt_i2bo3e) {
+      properties_initialized_bitUtils_kt_i2bo3e = true;
+      buf = new ArrayBuffer(8);
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      bufFloat64 = new Float64Array(get_buf());
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      bufFloat32 = new Float32Array(get_buf());
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      bufInt32 = new Int32Array(get_buf());
+      // Inline function 'kotlin.run' call
+      get_bufFloat64()[0] = -1.0;
+      lowIndex = !(get_bufInt32()[0] === 0) ? 1 : 0;
+      highIndex = 1 - get_lowIndex() | 0;
+    }
+  }
+  function get_ZERO() {
+    _init_properties_boxedLong_kt__v24qrw();
+    return ZERO;
+  }
+  var ZERO;
+  function get_ONE() {
+    _init_properties_boxedLong_kt__v24qrw();
+    return ONE;
+  }
+  var ONE;
+  function get_NEG_ONE() {
+    _init_properties_boxedLong_kt__v24qrw();
+    return NEG_ONE;
+  }
+  var NEG_ONE;
+  function get_MAX_VALUE() {
+    _init_properties_boxedLong_kt__v24qrw();
+    return MAX_VALUE;
+  }
+  var MAX_VALUE;
+  function get_MIN_VALUE() {
+    _init_properties_boxedLong_kt__v24qrw();
+    return MIN_VALUE;
+  }
+  var MIN_VALUE;
+  function get_TWO_PWR_24_() {
+    _init_properties_boxedLong_kt__v24qrw();
+    return TWO_PWR_24_;
+  }
+  var TWO_PWR_24_;
+  var longArrayClass;
+  function compare(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    if (equalsLong(_this__u8e3s4, other)) {
+      return 0;
+    }
+    var thisNeg = isNegative(_this__u8e3s4);
+    var otherNeg = isNegative(other);
+    return thisNeg && !otherNeg ? -1 : !thisNeg && otherNeg ? 1 : isNegative(subtract(_this__u8e3s4, other)) ? -1 : 1;
+  }
+  function convertToInt(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return _this__u8e3s4.u_1;
+  }
+  function toNumber(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return _this__u8e3s4.v_1 * 4.294967296E9 + getLowBitsUnsigned(_this__u8e3s4);
+  }
+  function toStringImpl(_this__u8e3s4, radix) {
+    _init_properties_boxedLong_kt__v24qrw();
+    if (isZero(_this__u8e3s4)) {
+      return '0';
+    }
+    if (isNegative(_this__u8e3s4)) {
+      if (equalsLong(_this__u8e3s4, get_MIN_VALUE())) {
+        var radixLong = fromInt(radix);
+        var div = divide(_this__u8e3s4, radixLong);
+        var rem = convertToInt(subtract(multiply(div, radixLong), _this__u8e3s4));
+        var tmp = toStringImpl(div, radix);
+        // Inline function 'kotlin.js.asDynamic' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        return tmp + rem.toString(radix);
+      } else {
+        return '-' + toStringImpl(negate(_this__u8e3s4), radix);
+      }
+    }
+    var digitsPerTime = radix === 2 ? 31 : radix <= 10 ? 9 : radix <= 21 ? 7 : radix <= 35 ? 6 : 5;
+    var radixToPower = fromNumber(Math.pow(radix, digitsPerTime));
+    var rem_0 = _this__u8e3s4;
+    var result = '';
+    while (true) {
+      var remDiv = divide(rem_0, radixToPower);
+      var intval = convertToInt(subtract(rem_0, multiply(remDiv, radixToPower)));
+      // Inline function 'kotlin.js.asDynamic' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      var digits = intval.toString(radix);
+      rem_0 = remDiv;
+      if (isZero(rem_0)) {
+        return digits + result;
+      } else {
+        while (digits.length < digitsPerTime) {
+          digits = '0' + digits;
+        }
+        result = digits + result;
+      }
+    }
+  }
+  function equalsLong(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return _this__u8e3s4.v_1 === other.v_1 && _this__u8e3s4.u_1 === other.u_1;
+  }
+  function hashCode(l) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return l.u_1 ^ l.v_1;
+  }
+  function fromInt(value) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return new Long(value, value < 0 ? -1 : 0);
+  }
+  function isNegative(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return _this__u8e3s4.v_1 < 0;
+  }
+  function subtract(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return add(_this__u8e3s4, negate(other));
+  }
+  function getLowBitsUnsigned(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return _this__u8e3s4.u_1 >= 0 ? _this__u8e3s4.u_1 : 4.294967296E9 + _this__u8e3s4.u_1;
+  }
+  function isZero(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return _this__u8e3s4.v_1 === 0 && _this__u8e3s4.u_1 === 0;
+  }
+  function multiply(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    if (isZero(_this__u8e3s4)) {
+      return get_ZERO();
+    } else if (isZero(other)) {
+      return get_ZERO();
+    }
+    if (equalsLong(_this__u8e3s4, get_MIN_VALUE())) {
+      return isOdd(other) ? get_MIN_VALUE() : get_ZERO();
+    } else if (equalsLong(other, get_MIN_VALUE())) {
+      return isOdd(_this__u8e3s4) ? get_MIN_VALUE() : get_ZERO();
+    }
+    if (isNegative(_this__u8e3s4)) {
+      var tmp;
+      if (isNegative(other)) {
+        tmp = multiply(negate(_this__u8e3s4), negate(other));
+      } else {
+        tmp = negate(multiply(negate(_this__u8e3s4), other));
+      }
+      return tmp;
+    } else if (isNegative(other)) {
+      return negate(multiply(_this__u8e3s4, negate(other)));
+    }
+    if (lessThan(_this__u8e3s4, get_TWO_PWR_24_()) && lessThan(other, get_TWO_PWR_24_())) {
+      return fromNumber(toNumber(_this__u8e3s4) * toNumber(other));
+    }
+    var a48 = _this__u8e3s4.v_1 >>> 16 | 0;
+    var a32 = _this__u8e3s4.v_1 & 65535;
+    var a16 = _this__u8e3s4.u_1 >>> 16 | 0;
+    var a00 = _this__u8e3s4.u_1 & 65535;
+    var b48 = other.v_1 >>> 16 | 0;
+    var b32 = other.v_1 & 65535;
+    var b16 = other.u_1 >>> 16 | 0;
+    var b00 = other.u_1 & 65535;
+    var c48 = 0;
+    var c32 = 0;
+    var c16 = 0;
+    var c00 = 0;
+    c00 = c00 + imul(a00, b00) | 0;
+    c16 = c16 + (c00 >>> 16 | 0) | 0;
+    c00 = c00 & 65535;
+    c16 = c16 + imul(a16, b00) | 0;
+    c32 = c32 + (c16 >>> 16 | 0) | 0;
+    c16 = c16 & 65535;
+    c16 = c16 + imul(a00, b16) | 0;
+    c32 = c32 + (c16 >>> 16 | 0) | 0;
+    c16 = c16 & 65535;
+    c32 = c32 + imul(a32, b00) | 0;
+    c48 = c48 + (c32 >>> 16 | 0) | 0;
+    c32 = c32 & 65535;
+    c32 = c32 + imul(a16, b16) | 0;
+    c48 = c48 + (c32 >>> 16 | 0) | 0;
+    c32 = c32 & 65535;
+    c32 = c32 + imul(a00, b32) | 0;
+    c48 = c48 + (c32 >>> 16 | 0) | 0;
+    c32 = c32 & 65535;
+    c48 = c48 + (((imul(a48, b00) + imul(a32, b16) | 0) + imul(a16, b32) | 0) + imul(a00, b48) | 0) | 0;
+    c48 = c48 & 65535;
+    return new Long(c16 << 16 | c00, c48 << 16 | c32);
+  }
+  function negate(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return add(invert(_this__u8e3s4), new Long(1, 0));
+  }
+  function fromNumber(value) {
+    _init_properties_boxedLong_kt__v24qrw();
+    if (isNaN_0(value)) {
+      return get_ZERO();
+    } else if (value <= -9.223372036854776E18) {
+      return get_MIN_VALUE();
+    } else if (value + 1 >= 9.223372036854776E18) {
+      return get_MAX_VALUE();
+    } else if (value < 0) {
+      return negate(fromNumber(-value));
+    } else {
+      var twoPwr32 = 4.294967296E9;
+      // Inline function 'kotlin.js.jsBitwiseOr' call
+      var tmp = value % twoPwr32 | 0;
+      // Inline function 'kotlin.js.jsBitwiseOr' call
+      var tmp$ret$1 = value / twoPwr32 | 0;
+      return new Long(tmp, tmp$ret$1);
+    }
+  }
+  function add(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    var a48 = _this__u8e3s4.v_1 >>> 16 | 0;
+    var a32 = _this__u8e3s4.v_1 & 65535;
+    var a16 = _this__u8e3s4.u_1 >>> 16 | 0;
+    var a00 = _this__u8e3s4.u_1 & 65535;
+    var b48 = other.v_1 >>> 16 | 0;
+    var b32 = other.v_1 & 65535;
+    var b16 = other.u_1 >>> 16 | 0;
+    var b00 = other.u_1 & 65535;
+    var c48 = 0;
+    var c32 = 0;
+    var c16 = 0;
+    var c00 = 0;
+    c00 = c00 + (a00 + b00 | 0) | 0;
+    c16 = c16 + (c00 >>> 16 | 0) | 0;
+    c00 = c00 & 65535;
+    c16 = c16 + (a16 + b16 | 0) | 0;
+    c32 = c32 + (c16 >>> 16 | 0) | 0;
+    c16 = c16 & 65535;
+    c32 = c32 + (a32 + b32 | 0) | 0;
+    c48 = c48 + (c32 >>> 16 | 0) | 0;
+    c32 = c32 & 65535;
+    c48 = c48 + (a48 + b48 | 0) | 0;
+    c48 = c48 & 65535;
+    return new Long(c16 << 16 | c00, c48 << 16 | c32);
+  }
+  function isOdd(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return (_this__u8e3s4.u_1 & 1) === 1;
+  }
+  function lessThan(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return compare(_this__u8e3s4, other) < 0;
+  }
+  function invert(_this__u8e3s4) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return new Long(~_this__u8e3s4.u_1, ~_this__u8e3s4.v_1);
+  }
+  function divide(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    if (isZero(other)) {
+      throw Exception_init_$Create$_0('division by zero');
+    } else if (isZero(_this__u8e3s4)) {
+      return get_ZERO();
+    }
+    if (equalsLong(_this__u8e3s4, get_MIN_VALUE())) {
+      if (equalsLong(other, get_ONE()) || equalsLong(other, get_NEG_ONE())) {
+        return get_MIN_VALUE();
+      } else if (equalsLong(other, get_MIN_VALUE())) {
+        return get_ONE();
+      } else {
+        var halfThis = shiftRight(_this__u8e3s4, 1);
+        var approx = shiftLeft(divide(halfThis, other), 1);
+        if (equalsLong(approx, get_ZERO())) {
+          return isNegative(other) ? get_ONE() : get_NEG_ONE();
+        } else {
+          var rem = subtract(_this__u8e3s4, multiply(other, approx));
+          return add(approx, divide(rem, other));
+        }
+      }
+    } else if (equalsLong(other, get_MIN_VALUE())) {
+      return get_ZERO();
+    }
+    if (isNegative(_this__u8e3s4)) {
+      var tmp;
+      if (isNegative(other)) {
+        tmp = divide(negate(_this__u8e3s4), negate(other));
+      } else {
+        tmp = negate(divide(negate(_this__u8e3s4), other));
+      }
+      return tmp;
+    } else if (isNegative(other)) {
+      return negate(divide(_this__u8e3s4, negate(other)));
+    }
+    var res = get_ZERO();
+    var rem_0 = _this__u8e3s4;
+    while (greaterThanOrEqual(rem_0, other)) {
+      var approxDouble = toNumber(rem_0) / toNumber(other);
+      var approx2 = Math.max(1.0, Math.floor(approxDouble));
+      var log2 = Math.ceil(Math.log(approx2) / Math.LN2);
+      var delta = log2 <= 48 ? 1.0 : Math.pow(2.0, log2 - 48);
+      var approxRes = fromNumber(approx2);
+      var approxRem = multiply(approxRes, other);
+      while (isNegative(approxRem) || greaterThan(approxRem, rem_0)) {
+        approx2 = approx2 - delta;
+        approxRes = fromNumber(approx2);
+        approxRem = multiply(approxRes, other);
+      }
+      if (isZero(approxRes)) {
+        approxRes = get_ONE();
+      }
+      res = add(res, approxRes);
+      rem_0 = subtract(rem_0, approxRem);
+    }
+    return res;
+  }
+  function shiftRight(_this__u8e3s4, numBits) {
+    _init_properties_boxedLong_kt__v24qrw();
+    var numBits_0 = numBits & 63;
+    if (numBits_0 === 0) {
+      return _this__u8e3s4;
+    } else {
+      if (numBits_0 < 32) {
+        return new Long(_this__u8e3s4.u_1 >>> numBits_0 | 0 | _this__u8e3s4.v_1 << (32 - numBits_0 | 0), _this__u8e3s4.v_1 >> numBits_0);
+      } else {
+        return new Long(_this__u8e3s4.v_1 >> (numBits_0 - 32 | 0), _this__u8e3s4.v_1 >= 0 ? 0 : -1);
+      }
+    }
+  }
+  function shiftLeft(_this__u8e3s4, numBits) {
+    _init_properties_boxedLong_kt__v24qrw();
+    var numBits_0 = numBits & 63;
+    if (numBits_0 === 0) {
+      return _this__u8e3s4;
+    } else {
+      if (numBits_0 < 32) {
+        return new Long(_this__u8e3s4.u_1 << numBits_0, _this__u8e3s4.v_1 << numBits_0 | (_this__u8e3s4.u_1 >>> (32 - numBits_0 | 0) | 0));
+      } else {
+        return new Long(0, _this__u8e3s4.u_1 << (numBits_0 - 32 | 0));
+      }
+    }
+  }
+  function greaterThan(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return compare(_this__u8e3s4, other) > 0;
+  }
+  function greaterThanOrEqual(_this__u8e3s4, other) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return compare(_this__u8e3s4, other) >= 0;
+  }
+  function isLongArray(a) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return isJsArray(a) && a.$type$ === 'LongArray';
+  }
+  function longArrayClass$lambda(it) {
+    _init_properties_boxedLong_kt__v24qrw();
+    return !(it == null) ? isLongArray(it) : false;
+  }
+  var properties_initialized_boxedLong_kt_lfwt2;
+  function _init_properties_boxedLong_kt__v24qrw() {
+    if (!properties_initialized_boxedLong_kt_lfwt2) {
+      properties_initialized_boxedLong_kt_lfwt2 = true;
+      ZERO = fromInt(0);
+      ONE = fromInt(1);
+      NEG_ONE = fromInt(-1);
+      MAX_VALUE = new Long(-1, 2147483647);
+      MIN_VALUE = new Long(0, -2147483648);
+      TWO_PWR_24_ = fromInt(16777216);
+      // Inline function 'kotlin.js.unsafeCast' call
+      var tmp = Array;
+      longArrayClass = new PrimitiveKClassImpl(tmp, 'LongArray', longArrayClass$lambda);
+    }
+  }
+  function arrayToString(array) {
+    return joinToString(array, ', ', '[', ']', VOID, VOID, arrayToString$lambda);
+  }
+  function arrayToString$lambda(it) {
+    return toString_1(it);
+  }
+  function compareTo(a, b) {
+    var tmp;
+    switch (typeof a) {
+      case 'number':
+        var tmp_0;
+        if (typeof b === 'number') {
+          tmp_0 = doubleCompareTo(a, b);
+        } else {
+          if (b instanceof Long) {
+            tmp_0 = doubleCompareTo(a, toNumber(b));
+          } else {
+            tmp_0 = primitiveCompareTo(a, b);
+          }
+        }
+
+        tmp = tmp_0;
+        break;
+      case 'string':
+      case 'boolean':
+      case 'bigint':
+        tmp = primitiveCompareTo(a, b);
+        break;
+      default:
+        tmp = compareToDoNotIntrinsicify(a, b);
+        break;
+    }
+    return tmp;
+  }
+  function doubleCompareTo(a, b) {
+    var tmp;
+    if (a < b) {
+      tmp = -1;
+    } else if (a > b) {
+      tmp = 1;
+    } else if (a === b) {
+      var tmp_0;
+      if (a !== 0) {
+        tmp_0 = 0;
+      } else {
+        // Inline function 'kotlin.js.asDynamic' call
+        var ia = 1 / a;
+        var tmp_1;
+        // Inline function 'kotlin.js.asDynamic' call
+        if (ia === 1 / b) {
+          tmp_1 = 0;
+        } else {
+          if (ia < 0) {
+            tmp_1 = -1;
+          } else {
+            tmp_1 = 1;
+          }
+        }
+        tmp_0 = tmp_1;
+      }
+      tmp = tmp_0;
+    } else if (a !== a) {
+      tmp = b !== b ? 0 : 1;
+    } else {
+      tmp = -1;
+    }
+    return tmp;
+  }
+  function primitiveCompareTo(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  function compareToDoNotIntrinsicify(a, b) {
+    return a.a(b);
+  }
+  function getObjectHashCode(obj) {
+    // Inline function 'kotlin.js.jsIn' call
+    if (!('kotlinHashCodeValue$' in obj)) {
+      var hash = calculateRandomHash();
+      var descriptor = new Object();
+      descriptor.value = hash;
+      descriptor.enumerable = false;
+      Object.defineProperty(obj, 'kotlinHashCodeValue$', descriptor);
+    }
+    // Inline function 'kotlin.js.unsafeCast' call
+    return obj['kotlinHashCodeValue$'];
+  }
+  function calculateRandomHash() {
+    // Inline function 'kotlin.js.jsBitwiseOr' call
+    return Math.random() * 4.294967296E9 | 0;
+  }
+  function objectCreate(proto) {
+    proto = proto === VOID ? null : proto;
+    return Object.create(proto);
+  }
+  function defineProp(obj, name, getter, setter, enumerable) {
+    return Object.defineProperty(obj, name, {configurable: true, get: getter, set: setter, enumerable: enumerable});
+  }
+  function toString_1(o) {
+    var tmp;
+    if (o == null) {
+      tmp = 'null';
+    } else if (isArrayish(o)) {
+      tmp = '[...]';
+    } else if (!(typeof o.toString === 'function')) {
+      tmp = anyToString(o);
+    } else {
+      // Inline function 'kotlin.js.unsafeCast' call
+      tmp = o.toString();
+    }
+    return tmp;
+  }
+  function equals(obj1, obj2) {
+    if (obj1 == null) {
+      return obj2 == null;
+    }
+    if (obj2 == null) {
+      return false;
+    }
+    if (typeof obj1 === 'object' && typeof obj1.equals === 'function') {
+      return obj1.equals(obj2);
+    }
+    if (obj1 !== obj1) {
+      return obj2 !== obj2;
+    }
+    if (typeof obj1 === 'number' && typeof obj2 === 'number') {
+      var tmp;
+      if (obj1 === obj2) {
+        var tmp_0;
+        if (obj1 !== 0) {
+          tmp_0 = true;
+        } else {
+          // Inline function 'kotlin.js.asDynamic' call
+          var tmp_1 = 1 / obj1;
+          // Inline function 'kotlin.js.asDynamic' call
+          tmp_0 = tmp_1 === 1 / obj2;
+        }
+        tmp = tmp_0;
+      } else {
+        tmp = false;
+      }
+      return tmp;
+    }
+    return obj1 === obj2;
+  }
+  function hashCode_0(obj) {
+    if (obj == null)
+      return 0;
+    var typeOf = typeof obj;
+    var tmp;
+    switch (typeOf) {
+      case 'object':
+        tmp = 'function' === typeof obj.hashCode ? obj.hashCode() : getObjectHashCode(obj);
+        break;
+      case 'function':
+        tmp = getObjectHashCode(obj);
+        break;
+      case 'number':
+        tmp = getNumberHashCode(obj);
+        break;
+      case 'boolean':
+        // Inline function 'kotlin.js.unsafeCast' call
+
+        tmp = getBooleanHashCode(obj);
+        break;
+      case 'string':
+        tmp = getStringHashCode(String(obj));
+        break;
+      case 'bigint':
+        // Inline function 'kotlin.js.unsafeCast' call
+
+        tmp = getBigIntHashCode(obj);
+        break;
+      case 'symbol':
+        tmp = getSymbolHashCode(obj);
+        break;
+      default:
+        tmp = function () {
+          throw new Error('Unexpected typeof `' + typeOf + '`');
+        }();
+        break;
+    }
+    return tmp;
+  }
+  function anyToString(o) {
+    return Object.prototype.toString.call(o);
+  }
+  function getBooleanHashCode(value) {
+    return value ? 1231 : 1237;
+  }
+  function getStringHashCode(str) {
+    var hash = 0;
+    var length = str.length;
+    var inductionVariable = 0;
+    var last = length - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.js.asDynamic' call
+        var code = str.charCodeAt(i);
+        hash = imul(hash, 31) + code | 0;
+      }
+       while (!(i === last));
+    return hash;
+  }
+  function getBigIntHashCode(value) {
+    var shiftNumber = BigInt(32);
+    var mask = BigInt(4.294967295E9);
+    var bigNumber = abs(value);
+    var hashCode = 0;
+    var tmp;
+    // Inline function 'kotlin.js.internal.isNegative' call
+    if (value < 0) {
+      tmp = -1;
+    } else {
+      tmp = 1;
+    }
+    var signum = tmp;
+    $l$loop: while (true) {
+      // Inline function 'kotlin.js.internal.isZero' call
+      if (!!(bigNumber == 0)) {
+        break $l$loop;
+      }
+      // Inline function 'kotlin.js.internal.and' call
+      // Inline function 'kotlin.js.jsBitwiseAnd' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      // Inline function 'kotlin.js.internal.toNumber' call
+      var self_0 = bigNumber & mask;
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var chunk = Number(self_0);
+      hashCode = imul(31, hashCode) + chunk | 0;
+      // Inline function 'kotlin.js.internal.shr' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      bigNumber = bigNumber >> shiftNumber;
+    }
+    return imul(hashCode, signum);
+  }
+  function getSymbolHashCode(value) {
+    var hashCodeMap = symbolIsSharable(value) ? getSymbolMap() : getSymbolWeakMap();
+    var cachedHashCode = hashCodeMap.get(value);
+    if (cachedHashCode !== VOID)
+      return cachedHashCode;
+    var hash = calculateRandomHash();
+    hashCodeMap.set(value, hash);
+    return hash;
+  }
+  function symbolIsSharable(symbol) {
+    return Symbol.keyFor(symbol) != VOID;
+  }
+  function getSymbolMap() {
+    if (symbolMap === VOID) {
+      symbolMap = new Map();
+    }
+    return symbolMap;
+  }
+  function getSymbolWeakMap() {
+    if (symbolWeakMap === VOID) {
+      symbolWeakMap = new WeakMap();
+    }
+    return symbolWeakMap;
+  }
+  var symbolMap;
+  var symbolWeakMap;
+  function unboxIntrinsic(x) {
+    var message = 'Should be lowered';
+    throw IllegalStateException_init_$Create$_0(toString_1(message));
+  }
+  function captureStack(instance, constructorFunction) {
+    if (Error.captureStackTrace != null) {
+      Error.captureStackTrace(instance, constructorFunction);
+    } else {
+      // Inline function 'kotlin.js.asDynamic' call
+      instance.stack = (new Error()).stack;
+    }
+  }
+  function protoOf(constructor) {
+    return constructor.prototype;
+  }
+  function defineMessage(message, cause) {
+    var tmp;
+    if (isUndefined(message)) {
+      var tmp_0;
+      if (isUndefined(cause)) {
+        tmp_0 = message;
+      } else {
+        var tmp1_elvis_lhs = cause == null ? null : cause.toString();
+        tmp_0 = tmp1_elvis_lhs == null ? VOID : tmp1_elvis_lhs;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = message == null ? VOID : message;
+    }
+    return tmp;
+  }
+  function isUndefined(value) {
+    return value === VOID;
+  }
+  function extendThrowable(this_, message, cause) {
+    defineFieldOnInstance(this_, 'message', defineMessage(message, cause));
+    defineFieldOnInstance(this_, 'cause', cause);
+    defineFieldOnInstance(this_, 'name', Object.getPrototypeOf(this_).constructor.name);
+  }
+  function defineFieldOnInstance(this_, name, value) {
+    Object.defineProperty(this_, name, {configurable: true, writable: true, value: value});
+  }
+  function ensureNotNull(v) {
+    var tmp;
+    if (v == null) {
+      THROW_NPE();
+    } else {
+      tmp = v;
+    }
+    return tmp;
+  }
+  function THROW_NPE() {
+    throw NullPointerException_init_$Create$();
+  }
+  function THROW_CCE() {
+    throw ClassCastException_init_$Create$();
+  }
+  function createMetadata(kind, name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity) {
+    var undef = VOID;
+    var iid = kind === 'interface' ? generateInterfaceId() : VOID;
+    return {kind: kind, simpleName: name, associatedObjectKey: associatedObjectKey, associatedObjects: associatedObjects, suspendArity: suspendArity, $kClass$: undef, defaultConstructor: defaultConstructor, iid: iid};
+  }
+  function generateInterfaceId() {
+    if (globalInterfaceId === VOID) {
+      globalInterfaceId = 0;
+    }
+    // Inline function 'kotlin.js.unsafeCast' call
+    globalInterfaceId = globalInterfaceId + 1 | 0;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return globalInterfaceId;
+  }
+  var globalInterfaceId;
+  function initMetadataForClass(ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects) {
+    var kind = 'class';
+    initMetadataFor(kind, ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects);
+  }
+  function initMetadataFor(kind, ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects) {
+    if (!(parent == null)) {
+      ctor.prototype = Object.create(parent.prototype);
+      ctor.prototype.constructor = ctor;
+    }
+    var metadata = createMetadata(kind, name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity);
+    ctor.$metadata$ = metadata;
+    if (!(interfaces == null)) {
+      var receiver = !equals(metadata.iid, VOID) ? ctor : ctor.prototype;
+      receiver.$imask$ = implement(interfaces);
+    }
+  }
+  function initMetadataForObject(ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects) {
+    var kind = 'object';
+    initMetadataFor(kind, ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects);
+  }
+  function initMetadataForInterface(ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects) {
+    var kind = 'interface';
+    initMetadataFor(kind, ctor, name, defaultConstructor, parent, interfaces, suspendArity, associatedObjectKey, associatedObjects);
+  }
+  function initMetadataForLambda(ctor, parent, interfaces, suspendArity) {
+    initMetadataForClass(ctor, 'Lambda', VOID, parent, interfaces, suspendArity, VOID, VOID);
+  }
+  function initMetadataForCoroutine(ctor, parent, interfaces, suspendArity) {
+    initMetadataForClass(ctor, 'Coroutine', VOID, parent, interfaces, suspendArity, VOID, VOID);
+  }
+  function initMetadataForFunctionReference(ctor, parent, interfaces, suspendArity) {
+    initMetadataForClass(ctor, 'FunctionReference', VOID, parent, interfaces, suspendArity, VOID, VOID);
+  }
+  function initMetadataForCompanion(ctor, parent, interfaces, suspendArity) {
+    initMetadataForObject(ctor, 'Companion', VOID, parent, interfaces, suspendArity, VOID, VOID);
+  }
+  function numberToInt(a) {
+    var tmp;
+    if (a instanceof Long) {
+      tmp = convertToInt(a);
+    } else {
+      tmp = doubleToInt(a);
+    }
+    return tmp;
+  }
+  function doubleToInt(a) {
+    var tmp;
+    if (a > 2147483647) {
+      tmp = 2147483647;
+    } else if (a < -2147483648) {
+      tmp = -2147483648;
+    } else {
+      // Inline function 'kotlin.js.jsBitwiseOr' call
+      tmp = a | 0;
+    }
+    return tmp;
+  }
+  function isArrayish(o) {
+    return isJsArray(o) || isView(o);
+  }
+  function isJsArray(obj) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    return Array.isArray(obj);
+  }
+  function isInterface(obj, iface) {
+    return isInterfaceImpl(obj, iface.$metadata$.iid);
+  }
+  function isInterfaceImpl(obj, iface) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    var tmp0_elvis_lhs = obj.$imask$;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var mask = tmp;
+    return isBitSet(mask, iface);
+  }
+  function isArray(obj) {
+    var tmp;
+    if (isJsArray(obj)) {
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp = !obj.$type$;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  function isNumber(a) {
+    var tmp;
+    if (typeof a === 'number') {
+      tmp = true;
+    } else {
+      tmp = a instanceof Long;
+    }
+    return tmp;
+  }
+  function isComparable(value) {
+    var type = typeof value;
+    return type === 'string' || type === 'boolean' || isNumber(value) || isInterface(value, Comparable);
+  }
+  function isCharSequence(value) {
+    return typeof value === 'string' || isInterface(value, CharSequence);
+  }
+  function get_VOID() {
+    _init_properties_void_kt__3zg9as();
+    return VOID;
+  }
+  var VOID;
+  var properties_initialized_void_kt_e4ret2;
+  function _init_properties_void_kt__3zg9as() {
+    if (!properties_initialized_void_kt_e4ret2) {
+      properties_initialized_void_kt_e4ret2 = true;
+      VOID = void 0;
+    }
+  }
+  function asList(_this__u8e3s4) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return new ArrayList(_this__u8e3s4);
+  }
+  function copyOf(_this__u8e3s4, newSize) {
+    // Inline function 'kotlin.require' call
+    if (!(newSize >= 0)) {
+      var message = 'Invalid new array size: ' + newSize + '.';
+      throw IllegalArgumentException_init_$Create$_0(toString_1(message));
+    }
+    return arrayCopyResize(_this__u8e3s4, newSize, null);
+  }
+  function copyOf_0(_this__u8e3s4, newSize) {
+    // Inline function 'kotlin.require' call
+    if (!(newSize >= 0)) {
+      var message = 'Invalid new array size: ' + newSize + '.';
+      throw IllegalArgumentException_init_$Create$_0(toString_1(message));
+    }
+    return fillFrom(_this__u8e3s4, new Int32Array(newSize));
+  }
+  function sortWith(_this__u8e3s4, comparator) {
+    if (_this__u8e3s4.length > 1) {
+      sortArrayWith(_this__u8e3s4, comparator);
+    }
+  }
+  function Comparator() {
+  }
+  function isNaN_0(_this__u8e3s4) {
+    return !(_this__u8e3s4 === _this__u8e3s4);
+  }
+  function takeHighestOneBit(_this__u8e3s4) {
+    var tmp;
+    if (_this__u8e3s4 === 0) {
+      tmp = 0;
+    } else {
+      // Inline function 'kotlin.countLeadingZeroBits' call
+      tmp = 1 << (31 - clz32(_this__u8e3s4) | 0);
+    }
+    return tmp;
+  }
+  function Unit() {
+  }
+  protoOf(Unit).toString = function () {
+    return 'kotlin.Unit';
+  };
+  var Unit_instance;
+  function Unit_getInstance() {
+    return Unit_instance;
+  }
+  function collectionToArray(collection) {
+    return collectionToArrayCommonImpl(collection);
+  }
+  function listOf(element) {
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp$ret$2 = [element];
+    return new ArrayList(tmp$ret$2);
+  }
+  function copyToArray(collection) {
+    var tmp;
+    // Inline function 'kotlin.js.asDynamic' call
+    if (collection.toArray !== undefined) {
+      // Inline function 'kotlin.js.asDynamic' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      tmp = collection.toArray();
+    } else {
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp = collectionToArray(collection);
+    }
+    return tmp;
+  }
+  function sortWith_0(_this__u8e3s4, comparator) {
+    collectionsSort(_this__u8e3s4, comparator);
+  }
+  function collectionsSort(list, comparator) {
+    if (list.f() <= 1)
+      return Unit_instance;
+    var array = copyToArray(list);
+    sortArrayWith(array, comparator);
+    var inductionVariable = 0;
+    var last = array.length;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        list.y(i, array[i]);
+      }
+       while (inductionVariable < last);
+  }
+  function AbstractMutableCollection() {
+    AbstractCollection.call(this);
+  }
+  protoOf(AbstractMutableCollection).toJSON = function () {
+    return this.toArray();
+  };
+  protoOf(AbstractMutableCollection).z = function () {
+  };
+  function IteratorImpl($outer) {
+    this.c1_1 = $outer;
+    this.a1_1 = 0;
+    this.b1_1 = -1;
+  }
+  protoOf(IteratorImpl).d = function () {
+    return this.a1_1 < this.c1_1.f();
+  };
+  protoOf(IteratorImpl).e = function () {
+    if (!this.d())
+      throw NoSuchElementException_init_$Create$();
+    var tmp = this;
+    var _unary__edvuaz = this.a1_1;
+    this.a1_1 = _unary__edvuaz + 1 | 0;
+    tmp.b1_1 = _unary__edvuaz;
+    return this.c1_1.g(this.b1_1);
+  };
+  function AbstractMutableList() {
+    AbstractMutableCollection.call(this);
+    this.d1_1 = 0;
+  }
+  protoOf(AbstractMutableList).i = function (element) {
+    this.z();
+    this.e1(this.f(), element);
+    return true;
+  };
+  protoOf(AbstractMutableList).c = function () {
+    return new IteratorImpl(this);
+  };
+  protoOf(AbstractMutableList).j = function (element) {
+    return this.f1(element) >= 0;
+  };
+  protoOf(AbstractMutableList).f1 = function (element) {
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.collections.indexOfFirst' call
+      var index = 0;
+      var _iterator__ex2g4s = this.c();
+      while (_iterator__ex2g4s.d()) {
+        var item = _iterator__ex2g4s.e();
+        if (equals(item, element)) {
+          tmp$ret$1 = index;
+          break $l$block;
+        }
+        index = index + 1 | 0;
+      }
+      tmp$ret$1 = -1;
+    }
+    return tmp$ret$1;
+  };
+  protoOf(AbstractMutableList).equals = function (other) {
+    if (other === this)
+      return true;
+    if (!(!(other == null) ? isInterface(other, KtList) : false))
+      return false;
+    return Companion_instance_2.h1(this, other);
+  };
+  protoOf(AbstractMutableList).hashCode = function () {
+    return Companion_instance_2.i1(this);
+  };
+  function AbstractMutableMap() {
+    AbstractMap.call(this);
+    this.l1_1 = null;
+    this.m1_1 = null;
+  }
+  function AbstractMutableSet() {
+    AbstractMutableCollection.call(this);
+  }
+  protoOf(AbstractMutableSet).equals = function (other) {
+    if (other === this)
+      return true;
+    if (!(!(other == null) ? isInterface(other, KtSet) : false))
+      return false;
+    return Companion_instance_4.r1(this, other);
+  };
+  protoOf(AbstractMutableSet).hashCode = function () {
+    return Companion_instance_4.s1(this);
+  };
+  function arrayOfUninitializedElements(capacity) {
+    // Inline function 'kotlin.require' call
+    if (!(capacity >= 0)) {
+      var message = 'capacity must be non-negative.';
+      throw IllegalArgumentException_init_$Create$_0(toString_1(message));
+    }
+    // Inline function 'kotlin.arrayOfNulls' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return Array(capacity);
+  }
+  function resetRange(_this__u8e3s4, fromIndex, toIndex) {
+    // Inline function 'kotlin.js.nativeFill' call
+    // Inline function 'kotlin.js.asDynamic' call
+    _this__u8e3s4.fill(null, fromIndex, toIndex);
+  }
+  function copyOfUninitializedElements(_this__u8e3s4, newSize) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return copyOf(_this__u8e3s4, newSize);
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+    var tmp = this;
+    // Inline function 'kotlin.also' call
+    var this_0 = ArrayList_init_$Create$_0(0);
+    this_0.v1_1 = true;
+    tmp.w1_1 = this_0;
+  }
+  var Companion_instance_0;
+  function Companion_getInstance_0() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function ArrayList_init_$Init$($this) {
+    // Inline function 'kotlin.emptyArray' call
+    var tmp$ret$0 = [];
+    ArrayList.call($this, tmp$ret$0);
+    return $this;
+  }
+  function ArrayList_init_$Create$() {
+    return ArrayList_init_$Init$(objectCreate(protoOf(ArrayList)));
+  }
+  function ArrayList_init_$Init$_0(initialCapacity, $this) {
+    // Inline function 'kotlin.emptyArray' call
+    var tmp$ret$0 = [];
+    ArrayList.call($this, tmp$ret$0);
+    // Inline function 'kotlin.require' call
+    if (!(initialCapacity >= 0)) {
+      var message = 'Negative initial capacity: ' + initialCapacity;
+      throw IllegalArgumentException_init_$Create$_0(toString_1(message));
+    }
+    return $this;
+  }
+  function ArrayList_init_$Create$_0(initialCapacity) {
+    return ArrayList_init_$Init$_0(initialCapacity, objectCreate(protoOf(ArrayList)));
+  }
+  function ArrayList_init_$Init$_1(elements, $this) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var tmp$ret$0 = copyToArray(elements);
+    ArrayList.call($this, tmp$ret$0);
+    return $this;
+  }
+  function ArrayList_init_$Create$_1(elements) {
+    return ArrayList_init_$Init$_1(elements, objectCreate(protoOf(ArrayList)));
+  }
+  function rangeCheck($this, index) {
+    // Inline function 'kotlin.apply' call
+    Companion_instance_2.x1(index, $this.f());
+    return index;
+  }
+  function insertionRangeCheck($this, index) {
+    // Inline function 'kotlin.apply' call
+    Companion_instance_2.y1(index, $this.f());
+    return index;
+  }
+  function ArrayList(array) {
+    Companion_getInstance_0();
+    AbstractMutableList.call(this);
+    this.u1_1 = array;
+    this.v1_1 = false;
+  }
+  protoOf(ArrayList).f = function () {
+    return this.u1_1.length;
+  };
+  protoOf(ArrayList).g = function (index) {
+    var tmp = this.u1_1[rangeCheck(this, index)];
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  protoOf(ArrayList).y = function (index, element) {
+    this.z();
+    rangeCheck(this, index);
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.u1_1[index];
+    this.u1_1[index] = element;
+    var tmp = this_0;
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  protoOf(ArrayList).i = function (element) {
+    this.z();
+    // Inline function 'kotlin.js.asDynamic' call
+    this.u1_1.push(element);
+    this.d1_1 = this.d1_1 + 1 | 0;
+    return true;
+  };
+  protoOf(ArrayList).e1 = function (index, element) {
+    this.z();
+    // Inline function 'kotlin.js.asDynamic' call
+    this.u1_1.splice(insertionRangeCheck(this, index), 0, element);
+    this.d1_1 = this.d1_1 + 1 | 0;
+  };
+  protoOf(ArrayList).f1 = function (element) {
+    return indexOf(this.u1_1, element);
+  };
+  protoOf(ArrayList).toString = function () {
+    return arrayToString(this.u1_1);
+  };
+  protoOf(ArrayList).z1 = function () {
+    return [].slice.call(this.u1_1);
+  };
+  protoOf(ArrayList).toArray = function () {
+    return this.z1();
+  };
+  protoOf(ArrayList).z = function () {
+    if (this.v1_1)
+      throw UnsupportedOperationException_init_$Create$();
+  };
+  var _stableSortingIsSupported;
+  function sortArrayWith(array, comparator) {
+    if (getStableSortingIsSupported()) {
+      var comparison = sortArrayWith$lambda(comparator);
+      // Inline function 'kotlin.js.asDynamic' call
+      array.sort(comparison);
+    } else {
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      mergeSort(array, 0, get_lastIndex(array), comparator);
+    }
+  }
+  function getStableSortingIsSupported() {
+    var tmp0_safe_receiver = _stableSortingIsSupported;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      return tmp0_safe_receiver;
+    }
+    _stableSortingIsSupported = false;
+    // Inline function 'kotlin.js.unsafeCast' call
+    var array = [];
+    var inductionVariable = 0;
+    if (inductionVariable < 600)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.js.asDynamic' call
+        array.push(index);
+      }
+       while (inductionVariable < 600);
+    var comparison = getStableSortingIsSupported$lambda;
+    // Inline function 'kotlin.js.asDynamic' call
+    array.sort(comparison);
+    var inductionVariable_0 = 1;
+    var last = array.length;
+    if (inductionVariable_0 < last)
+      do {
+        var index_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        var a = array[index_0 - 1 | 0];
+        var b = array[index_0];
+        if ((a & 3) === (b & 3) && a >= b)
+          return false;
+      }
+       while (inductionVariable_0 < last);
+    _stableSortingIsSupported = true;
+    return true;
+  }
+  function mergeSort(array, start, endInclusive, comparator) {
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = array.length;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var buffer = Array(size);
+    var result = mergeSort_0(array, buffer, start, endInclusive, comparator);
+    if (!(result === array)) {
+      var inductionVariable = start;
+      if (inductionVariable <= endInclusive)
+        do {
+          var i = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          array[i] = result[i];
+        }
+         while (!(i === endInclusive));
+    }
+  }
+  function mergeSort_0(array, buffer, start, end, comparator) {
+    if (start === end) {
+      return array;
+    }
+    var median = (start + end | 0) / 2 | 0;
+    var left = mergeSort_0(array, buffer, start, median, comparator);
+    var right = mergeSort_0(array, buffer, median + 1 | 0, end, comparator);
+    var target = left === buffer ? array : buffer;
+    var leftIndex = start;
+    var rightIndex = median + 1 | 0;
+    var inductionVariable = start;
+    if (inductionVariable <= end)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        if (leftIndex <= median && rightIndex <= end) {
+          var leftValue = left[leftIndex];
+          var rightValue = right[rightIndex];
+          if (comparator.compare(leftValue, rightValue) <= 0) {
+            target[i] = leftValue;
+            leftIndex = leftIndex + 1 | 0;
+          } else {
+            target[i] = rightValue;
+            rightIndex = rightIndex + 1 | 0;
+          }
+        } else if (leftIndex <= median) {
+          target[i] = left[leftIndex];
+          leftIndex = leftIndex + 1 | 0;
+        } else {
+          target[i] = right[rightIndex];
+          rightIndex = rightIndex + 1 | 0;
+        }
+      }
+       while (!(i === end));
+    return target;
+  }
+  function sortArrayWith$lambda($comparator) {
+    return function (a, b) {
+      return $comparator.compare(a, b);
+    };
+  }
+  function getStableSortingIsSupported$lambda(a, b) {
+    return (a & 3) - (b & 3) | 0;
+  }
+  function HashMap_init_$Init$(internalMap, $this) {
+    AbstractMutableMap.call($this);
+    HashMap.call($this);
+    $this.e2_1 = internalMap;
+    return $this;
+  }
+  function HashMap_init_$Init$_0($this) {
+    HashMap_init_$Init$(InternalHashMap_init_$Create$(), $this);
+    return $this;
+  }
+  function HashMap_init_$Create$() {
+    return HashMap_init_$Init$_0(objectCreate(protoOf(HashMap)));
+  }
+  protoOf(HashMap).n = function (key) {
+    return this.e2_1.g2(key);
+  };
+  protoOf(HashMap).p = function () {
+    var tmp0_elvis_lhs = this.f2_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      // Inline function 'kotlin.also' call
+      var this_0 = new HashMapEntrySet(this.e2_1);
+      this.f2_1 = this_0;
+      tmp = this_0;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(HashMap).o = function (key) {
+    return this.e2_1.o(key);
+  };
+  protoOf(HashMap).n1 = function (key, value) {
+    return this.e2_1.n1(key, value);
+  };
+  protoOf(HashMap).f = function () {
+    return this.e2_1.f();
+  };
+  function HashMap() {
+    this.f2_1 = null;
+  }
+  function HashMapEntrySet(backing) {
+    HashMapEntrySetBase.call(this, backing);
+  }
+  protoOf(HashMapEntrySet).c = function () {
+    return this.i2_1.j2();
+  };
+  function HashMapEntrySetBase(backing) {
+    AbstractMutableSet.call(this);
+    this.i2_1 = backing;
+  }
+  protoOf(HashMapEntrySetBase).f = function () {
+    return this.i2_1.f();
+  };
+  protoOf(HashMapEntrySetBase).h = function () {
+    return this.i2_1.f() === 0;
+  };
+  protoOf(HashMapEntrySetBase).k2 = function (element) {
+    return this.i2_1.m2(element);
+  };
+  protoOf(HashMapEntrySetBase).j = function (element) {
+    if (!(!(element == null) ? isInterface(element, Entry) : false))
+      return false;
+    return this.k2((!(element == null) ? isInterface(element, Entry) : false) ? element : THROW_CCE());
+  };
+  protoOf(HashMapEntrySetBase).l2 = function (element) {
+    throw UnsupportedOperationException_init_$Create$();
+  };
+  protoOf(HashMapEntrySetBase).i = function (element) {
+    return this.l2((!(element == null) ? isInterface(element, Entry) : false) ? element : THROW_CCE());
+  };
+  protoOf(HashMapEntrySetBase).k = function (elements) {
+    return this.i2_1.n2(elements);
+  };
+  function computeHashSize($this, capacity) {
+    return takeHighestOneBit(imul(coerceAtLeast(capacity, 1), 3));
+  }
+  function computeShift($this, hashSize) {
+    // Inline function 'kotlin.countLeadingZeroBits' call
+    return clz32(hashSize) + 1 | 0;
+  }
+  function checkForComodification($this) {
+    if (!($this.y2_1.v2_1 === $this.a3_1))
+      throw ConcurrentModificationException_init_$Create$_0('The backing map has been modified after this entry was obtained.');
+  }
+  function InternalHashMap_init_$Init$($this) {
+    InternalHashMap_init_$Init$_0(8, $this);
+    return $this;
+  }
+  function InternalHashMap_init_$Create$() {
+    return InternalHashMap_init_$Init$(objectCreate(protoOf(InternalHashMap)));
+  }
+  function InternalHashMap_init_$Init$_0(initialCapacity, $this) {
+    InternalHashMap.call($this, arrayOfUninitializedElements(initialCapacity), null, new Int32Array(initialCapacity), new Int32Array(computeHashSize(Companion_instance_1, initialCapacity)), 2, 0);
+    return $this;
+  }
+  function _get_capacity__a9k9f3($this) {
+    return $this.o2_1.length;
+  }
+  function _get_hashSize__tftcho($this) {
+    return $this.r2_1.length;
+  }
+  function registerModification($this) {
+    $this.v2_1 = $this.v2_1 + 1 | 0;
+  }
+  function ensureExtraCapacity($this, n) {
+    if (shouldCompact($this, n)) {
+      compact($this, true);
+    } else {
+      ensureCapacity($this, $this.t2_1 + n | 0);
+    }
+  }
+  function shouldCompact($this, extraCapacity) {
+    var spareCapacity = _get_capacity__a9k9f3($this) - $this.t2_1 | 0;
+    var gaps = $this.t2_1 - $this.f() | 0;
+    return spareCapacity < extraCapacity && (gaps + spareCapacity | 0) >= extraCapacity && gaps >= (_get_capacity__a9k9f3($this) / 4 | 0);
+  }
+  function ensureCapacity($this, minCapacity) {
+    if (minCapacity < 0)
+      throw RuntimeException_init_$Create$_0('too many elements');
+    if (minCapacity > _get_capacity__a9k9f3($this)) {
+      var newSize = Companion_instance_2.b3(_get_capacity__a9k9f3($this), minCapacity);
+      $this.o2_1 = copyOfUninitializedElements($this.o2_1, newSize);
+      var tmp = $this;
+      var tmp0_safe_receiver = $this.p2_1;
+      tmp.p2_1 = tmp0_safe_receiver == null ? null : copyOfUninitializedElements(tmp0_safe_receiver, newSize);
+      $this.q2_1 = copyOf_0($this.q2_1, newSize);
+      var newHashSize = computeHashSize(Companion_instance_1, newSize);
+      if (newHashSize > _get_hashSize__tftcho($this)) {
+        rehash($this, newHashSize);
+      }
+    }
+  }
+  function allocateValuesArray($this) {
+    var curValuesArray = $this.p2_1;
+    if (!(curValuesArray == null))
+      return curValuesArray;
+    var newValuesArray = arrayOfUninitializedElements(_get_capacity__a9k9f3($this));
+    $this.p2_1 = newValuesArray;
+    return newValuesArray;
+  }
+  function hash($this, key) {
+    return key == null ? 0 : imul(hashCode_0(key), -1640531527) >>> $this.u2_1 | 0;
+  }
+  function compact($this, updateHashArray) {
+    var i = 0;
+    var j = 0;
+    var valuesArray = $this.p2_1;
+    while (i < $this.t2_1) {
+      var hash = $this.q2_1[i];
+      if (hash >= 0) {
+        $this.o2_1[j] = $this.o2_1[i];
+        if (!(valuesArray == null)) {
+          valuesArray[j] = valuesArray[i];
+        }
+        if (updateHashArray) {
+          $this.q2_1[j] = hash;
+          $this.r2_1[hash] = j + 1 | 0;
+        }
+        j = j + 1 | 0;
+      }
+      i = i + 1 | 0;
+    }
+    resetRange($this.o2_1, j, $this.t2_1);
+    if (valuesArray == null)
+      null;
+    else {
+      resetRange(valuesArray, j, $this.t2_1);
+    }
+    $this.t2_1 = j;
+  }
+  function rehash($this, newHashSize) {
+    registerModification($this);
+    if ($this.t2_1 > $this.w2_1) {
+      compact($this, false);
+    }
+    $this.r2_1 = new Int32Array(newHashSize);
+    $this.u2_1 = computeShift(Companion_instance_1, newHashSize);
+    var i = 0;
+    while (i < $this.t2_1) {
+      var _unary__edvuaz = i;
+      i = _unary__edvuaz + 1 | 0;
+      if (!putRehash($this, _unary__edvuaz)) {
+        throw IllegalStateException_init_$Create$_0('This cannot happen with fixed magic multiplier and grow-only hash array. Have object hashCodes changed?');
+      }
+    }
+  }
+  function putRehash($this, i) {
+    var hash_0 = hash($this, $this.o2_1[i]);
+    var probesLeft = $this.s2_1;
+    while (true) {
+      var index = $this.r2_1[hash_0];
+      if (index === 0) {
+        $this.r2_1[hash_0] = i + 1 | 0;
+        $this.q2_1[i] = hash_0;
+        return true;
+      }
+      probesLeft = probesLeft - 1 | 0;
+      if (probesLeft < 0)
+        return false;
+      var _unary__edvuaz = hash_0;
+      hash_0 = _unary__edvuaz - 1 | 0;
+      if (_unary__edvuaz === 0)
+        hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+    }
+  }
+  function findKey($this, key) {
+    var hash_0 = hash($this, key);
+    var probesLeft = $this.s2_1;
+    while (true) {
+      var index = $this.r2_1[hash_0];
+      if (index === 0)
+        return -1;
+      if (index > 0 && equals($this.o2_1[index - 1 | 0], key))
+        return index - 1 | 0;
+      probesLeft = probesLeft - 1 | 0;
+      if (probesLeft < 0)
+        return -1;
+      var _unary__edvuaz = hash_0;
+      hash_0 = _unary__edvuaz - 1 | 0;
+      if (_unary__edvuaz === 0)
+        hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+    }
+  }
+  function addKey($this, key) {
+    $this.c3();
+    retry: while (true) {
+      var hash_0 = hash($this, key);
+      var tentativeMaxProbeDistance = coerceAtMost(imul($this.s2_1, 2), _get_hashSize__tftcho($this) / 2 | 0);
+      var probeDistance = 0;
+      while (true) {
+        var index = $this.r2_1[hash_0];
+        if (index <= 0) {
+          if ($this.t2_1 >= _get_capacity__a9k9f3($this)) {
+            ensureExtraCapacity($this, 1);
+            continue retry;
+          }
+          var _unary__edvuaz = $this.t2_1;
+          $this.t2_1 = _unary__edvuaz + 1 | 0;
+          var putIndex = _unary__edvuaz;
+          $this.o2_1[putIndex] = key;
+          $this.q2_1[putIndex] = hash_0;
+          $this.r2_1[hash_0] = putIndex + 1 | 0;
+          $this.w2_1 = $this.w2_1 + 1 | 0;
+          registerModification($this);
+          if (probeDistance > $this.s2_1)
+            $this.s2_1 = probeDistance;
+          return putIndex;
+        }
+        if (equals($this.o2_1[index - 1 | 0], key)) {
+          return -index | 0;
+        }
+        probeDistance = probeDistance + 1 | 0;
+        if (probeDistance > tentativeMaxProbeDistance) {
+          rehash($this, imul(_get_hashSize__tftcho($this), 2));
+          continue retry;
+        }
+        var _unary__edvuaz_0 = hash_0;
+        hash_0 = _unary__edvuaz_0 - 1 | 0;
+        if (_unary__edvuaz_0 === 0)
+          hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+      }
+    }
+  }
+  function contentEquals($this, other) {
+    return $this.w2_1 === other.f() && $this.n2(other.p());
+  }
+  function Companion_1() {
+    this.d3_1 = -1640531527;
+    this.e3_1 = 8;
+    this.f3_1 = 2;
+    this.g3_1 = -1;
+  }
+  var Companion_instance_1;
+  function Companion_getInstance_1() {
+    return Companion_instance_1;
+  }
+  function Itr(map) {
+    this.h3_1 = map;
+    this.i3_1 = 0;
+    this.j3_1 = -1;
+    this.k3_1 = this.h3_1.v2_1;
+    this.l3();
+  }
+  protoOf(Itr).l3 = function () {
+    while (this.i3_1 < this.h3_1.t2_1 && this.h3_1.q2_1[this.i3_1] < 0) {
+      this.i3_1 = this.i3_1 + 1 | 0;
+    }
+  };
+  protoOf(Itr).d = function () {
+    return this.i3_1 < this.h3_1.t2_1;
+  };
+  protoOf(Itr).m3 = function () {
+    if (!(this.h3_1.v2_1 === this.k3_1))
+      throw ConcurrentModificationException_init_$Create$();
+  };
+  function EntriesItr(map) {
+    Itr.call(this, map);
+  }
+  protoOf(EntriesItr).e = function () {
+    this.m3();
+    if (this.i3_1 >= this.h3_1.t2_1)
+      throw NoSuchElementException_init_$Create$();
+    var tmp = this;
+    var _unary__edvuaz = this.i3_1;
+    this.i3_1 = _unary__edvuaz + 1 | 0;
+    tmp.j3_1 = _unary__edvuaz;
+    var result = new EntryRef(this.h3_1, this.j3_1);
+    this.l3();
+    return result;
+  };
+  protoOf(EntriesItr).r3 = function () {
+    if (this.i3_1 >= this.h3_1.t2_1)
+      throw NoSuchElementException_init_$Create$();
+    var tmp = this;
+    var _unary__edvuaz = this.i3_1;
+    this.i3_1 = _unary__edvuaz + 1 | 0;
+    tmp.j3_1 = _unary__edvuaz;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = this.h3_1.o2_1[this.j3_1];
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode_0(tmp0_safe_receiver);
+    var tmp_0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver_0 = ensureNotNull(this.h3_1.p2_1)[this.j3_1];
+    var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode_0(tmp0_safe_receiver_0);
+    var result = tmp_0 ^ (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0);
+    this.l3();
+    return result;
+  };
+  protoOf(EntriesItr).s3 = function (sb) {
+    if (this.i3_1 >= this.h3_1.t2_1)
+      throw NoSuchElementException_init_$Create$();
+    var tmp = this;
+    var _unary__edvuaz = this.i3_1;
+    this.i3_1 = _unary__edvuaz + 1 | 0;
+    tmp.j3_1 = _unary__edvuaz;
+    var key = this.h3_1.o2_1[this.j3_1];
+    if (equals(key, this.h3_1))
+      sb.v3('(this Map)');
+    else
+      sb.u3(key);
+    sb.w3(_Char___init__impl__6a9atx(61));
+    var value = ensureNotNull(this.h3_1.p2_1)[this.j3_1];
+    if (equals(value, this.h3_1))
+      sb.v3('(this Map)');
+    else
+      sb.u3(value);
+    this.l3();
+  };
+  function EntryRef(map, index) {
+    this.y2_1 = map;
+    this.z2_1 = index;
+    this.a3_1 = this.y2_1.v2_1;
+  }
+  protoOf(EntryRef).l = function () {
+    checkForComodification(this);
+    return this.y2_1.o2_1[this.z2_1];
+  };
+  protoOf(EntryRef).m = function () {
+    checkForComodification(this);
+    return ensureNotNull(this.y2_1.p2_1)[this.z2_1];
+  };
+  protoOf(EntryRef).equals = function (other) {
+    var tmp;
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, Entry) : false) {
+      tmp_0 = equals(other.l(), this.l());
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = equals(other.m(), this.m());
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(EntryRef).hashCode = function () {
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = this.l();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode_0(tmp0_safe_receiver);
+    var tmp = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver_0 = this.m();
+    var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode_0(tmp0_safe_receiver_0);
+    return tmp ^ (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0);
+  };
+  protoOf(EntryRef).toString = function () {
+    return toString_0(this.l()) + '=' + toString_0(this.m());
+  };
+  function InternalHashMap(keysArray, valuesArray, presenceArray, hashArray, maxProbeDistance, length) {
+    this.o2_1 = keysArray;
+    this.p2_1 = valuesArray;
+    this.q2_1 = presenceArray;
+    this.r2_1 = hashArray;
+    this.s2_1 = maxProbeDistance;
+    this.t2_1 = length;
+    this.u2_1 = computeShift(Companion_instance_1, _get_hashSize__tftcho(this));
+    this.v2_1 = 0;
+    this.w2_1 = 0;
+    this.x2_1 = false;
+  }
+  protoOf(InternalHashMap).f = function () {
+    return this.w2_1;
+  };
+  protoOf(InternalHashMap).o = function (key) {
+    var index = findKey(this, key);
+    if (index < 0)
+      return null;
+    return ensureNotNull(this.p2_1)[index];
+  };
+  protoOf(InternalHashMap).g2 = function (key) {
+    return findKey(this, key) >= 0;
+  };
+  protoOf(InternalHashMap).n1 = function (key, value) {
+    var index = addKey(this, key);
+    var valuesArray = allocateValuesArray(this);
+    if (index < 0) {
+      var oldValue = valuesArray[(-index | 0) - 1 | 0];
+      valuesArray[(-index | 0) - 1 | 0] = value;
+      return oldValue;
+    } else {
+      valuesArray[index] = value;
+      return null;
+    }
+  };
+  protoOf(InternalHashMap).equals = function (other) {
+    var tmp;
+    if (other === this) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, KtMap) : false) {
+        tmp_0 = contentEquals(this, other);
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(InternalHashMap).hashCode = function () {
+    var result = 0;
+    var it = this.j2();
+    while (it.d()) {
+      result = result + it.r3() | 0;
+    }
+    return result;
+  };
+  protoOf(InternalHashMap).toString = function () {
+    var sb = StringBuilder_init_$Create$(2 + imul(this.w2_1, 3) | 0);
+    sb.v3('{');
+    var i = 0;
+    var it = this.j2();
+    while (it.d()) {
+      if (i > 0) {
+        sb.v3(', ');
+      }
+      it.s3(sb);
+      i = i + 1 | 0;
+    }
+    sb.v3('}');
+    return sb.toString();
+  };
+  protoOf(InternalHashMap).c3 = function () {
+    if (this.x2_1)
+      throw UnsupportedOperationException_init_$Create$();
+  };
+  protoOf(InternalHashMap).m2 = function (entry) {
+    var index = findKey(this, entry.l());
+    if (index < 0)
+      return false;
+    return equals(ensureNotNull(this.p2_1)[index], entry.m());
+  };
+  protoOf(InternalHashMap).x3 = function (entry) {
+    return this.m2(isInterface(entry, Entry) ? entry : THROW_CCE());
+  };
+  protoOf(InternalHashMap).j2 = function () {
+    return new EntriesItr(this);
+  };
+  function InternalMap() {
+  }
+  function LinkedHashMap_init_$Init$($this) {
+    HashMap_init_$Init$_0($this);
+    LinkedHashMap.call($this);
+    return $this;
+  }
+  function LinkedHashMap_init_$Create$() {
+    return LinkedHashMap_init_$Init$(objectCreate(protoOf(LinkedHashMap)));
+  }
+  function LinkedHashMap() {
+  }
+  function UnsupportedOperationException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    UnsupportedOperationException.call($this);
+    return $this;
+  }
+  function UnsupportedOperationException_init_$Create$() {
+    var tmp = UnsupportedOperationException_init_$Init$(objectCreate(protoOf(UnsupportedOperationException)));
+    captureStack(tmp, UnsupportedOperationException_init_$Create$);
+    return tmp;
+  }
+  function UnsupportedOperationException() {
+    captureStack(this, UnsupportedOperationException);
+  }
+  function IllegalStateException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    IllegalStateException.call($this);
+    return $this;
+  }
+  function IllegalStateException_init_$Create$() {
+    var tmp = IllegalStateException_init_$Init$(objectCreate(protoOf(IllegalStateException)));
+    captureStack(tmp, IllegalStateException_init_$Create$);
+    return tmp;
+  }
+  function IllegalStateException_init_$Init$_0(message, $this) {
+    RuntimeException_init_$Init$_0(message, $this);
+    IllegalStateException.call($this);
+    return $this;
+  }
+  function IllegalStateException_init_$Create$_0(message) {
+    var tmp = IllegalStateException_init_$Init$_0(message, objectCreate(protoOf(IllegalStateException)));
+    captureStack(tmp, IllegalStateException_init_$Create$_0);
+    return tmp;
+  }
+  function IllegalStateException() {
+    captureStack(this, IllegalStateException);
+  }
+  function IllegalArgumentException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    IllegalArgumentException.call($this);
+    return $this;
+  }
+  function IllegalArgumentException_init_$Create$() {
+    var tmp = IllegalArgumentException_init_$Init$(objectCreate(protoOf(IllegalArgumentException)));
+    captureStack(tmp, IllegalArgumentException_init_$Create$);
+    return tmp;
+  }
+  function IllegalArgumentException_init_$Init$_0(message, $this) {
+    RuntimeException_init_$Init$_0(message, $this);
+    IllegalArgumentException.call($this);
+    return $this;
+  }
+  function IllegalArgumentException_init_$Create$_0(message) {
+    var tmp = IllegalArgumentException_init_$Init$_0(message, objectCreate(protoOf(IllegalArgumentException)));
+    captureStack(tmp, IllegalArgumentException_init_$Create$_0);
+    return tmp;
+  }
+  function IllegalArgumentException() {
+    captureStack(this, IllegalArgumentException);
+  }
+  function RuntimeException_init_$Init$($this) {
+    Exception_init_$Init$($this);
+    RuntimeException.call($this);
+    return $this;
+  }
+  function RuntimeException_init_$Create$() {
+    var tmp = RuntimeException_init_$Init$(objectCreate(protoOf(RuntimeException)));
+    captureStack(tmp, RuntimeException_init_$Create$);
+    return tmp;
+  }
+  function RuntimeException_init_$Init$_0(message, $this) {
+    Exception_init_$Init$_0(message, $this);
+    RuntimeException.call($this);
+    return $this;
+  }
+  function RuntimeException_init_$Create$_0(message) {
+    var tmp = RuntimeException_init_$Init$_0(message, objectCreate(protoOf(RuntimeException)));
+    captureStack(tmp, RuntimeException_init_$Create$_0);
+    return tmp;
+  }
+  function RuntimeException() {
+    captureStack(this, RuntimeException);
+  }
+  function Exception_init_$Init$($this) {
+    extendThrowable($this);
+    Exception.call($this);
+    return $this;
+  }
+  function Exception_init_$Create$() {
+    var tmp = Exception_init_$Init$(objectCreate(protoOf(Exception)));
+    captureStack(tmp, Exception_init_$Create$);
+    return tmp;
+  }
+  function Exception_init_$Init$_0(message, $this) {
+    extendThrowable($this, message);
+    Exception.call($this);
+    return $this;
+  }
+  function Exception_init_$Create$_0(message) {
+    var tmp = Exception_init_$Init$_0(message, objectCreate(protoOf(Exception)));
+    captureStack(tmp, Exception_init_$Create$_0);
+    return tmp;
+  }
+  function Exception() {
+    captureStack(this, Exception);
+  }
+  function NoSuchElementException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    NoSuchElementException.call($this);
+    return $this;
+  }
+  function NoSuchElementException_init_$Create$() {
+    var tmp = NoSuchElementException_init_$Init$(objectCreate(protoOf(NoSuchElementException)));
+    captureStack(tmp, NoSuchElementException_init_$Create$);
+    return tmp;
+  }
+  function NoSuchElementException_init_$Init$_0(message, $this) {
+    RuntimeException_init_$Init$_0(message, $this);
+    NoSuchElementException.call($this);
+    return $this;
+  }
+  function NoSuchElementException_init_$Create$_0(message) {
+    var tmp = NoSuchElementException_init_$Init$_0(message, objectCreate(protoOf(NoSuchElementException)));
+    captureStack(tmp, NoSuchElementException_init_$Create$_0);
+    return tmp;
+  }
+  function NoSuchElementException() {
+    captureStack(this, NoSuchElementException);
+  }
+  function IndexOutOfBoundsException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    IndexOutOfBoundsException.call($this);
+    return $this;
+  }
+  function IndexOutOfBoundsException_init_$Create$() {
+    var tmp = IndexOutOfBoundsException_init_$Init$(objectCreate(protoOf(IndexOutOfBoundsException)));
+    captureStack(tmp, IndexOutOfBoundsException_init_$Create$);
+    return tmp;
+  }
+  function IndexOutOfBoundsException_init_$Init$_0(message, $this) {
+    RuntimeException_init_$Init$_0(message, $this);
+    IndexOutOfBoundsException.call($this);
+    return $this;
+  }
+  function IndexOutOfBoundsException_init_$Create$_0(message) {
+    var tmp = IndexOutOfBoundsException_init_$Init$_0(message, objectCreate(protoOf(IndexOutOfBoundsException)));
+    captureStack(tmp, IndexOutOfBoundsException_init_$Create$_0);
+    return tmp;
+  }
+  function IndexOutOfBoundsException() {
+    captureStack(this, IndexOutOfBoundsException);
+  }
+  function ConcurrentModificationException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    ConcurrentModificationException.call($this);
+    return $this;
+  }
+  function ConcurrentModificationException_init_$Create$() {
+    var tmp = ConcurrentModificationException_init_$Init$(objectCreate(protoOf(ConcurrentModificationException)));
+    captureStack(tmp, ConcurrentModificationException_init_$Create$);
+    return tmp;
+  }
+  function ConcurrentModificationException_init_$Init$_0(message, $this) {
+    RuntimeException_init_$Init$_0(message, $this);
+    ConcurrentModificationException.call($this);
+    return $this;
+  }
+  function ConcurrentModificationException_init_$Create$_0(message) {
+    var tmp = ConcurrentModificationException_init_$Init$_0(message, objectCreate(protoOf(ConcurrentModificationException)));
+    captureStack(tmp, ConcurrentModificationException_init_$Create$_0);
+    return tmp;
+  }
+  function ConcurrentModificationException() {
+    captureStack(this, ConcurrentModificationException);
+  }
+  function NullPointerException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    NullPointerException.call($this);
+    return $this;
+  }
+  function NullPointerException_init_$Create$() {
+    var tmp = NullPointerException_init_$Init$(objectCreate(protoOf(NullPointerException)));
+    captureStack(tmp, NullPointerException_init_$Create$);
+    return tmp;
+  }
+  function NullPointerException() {
+    captureStack(this, NullPointerException);
+  }
+  function ClassCastException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    ClassCastException.call($this);
+    return $this;
+  }
+  function ClassCastException_init_$Create$() {
+    var tmp = ClassCastException_init_$Init$(objectCreate(protoOf(ClassCastException)));
+    captureStack(tmp, ClassCastException_init_$Create$);
+    return tmp;
+  }
+  function ClassCastException() {
+    captureStack(this, ClassCastException);
+  }
+  function lazy(initializer) {
+    return new UnsafeLazyImpl(initializer);
+  }
+  function fillFrom(src, dst) {
+    var srcLen = src.length;
+    var dstLen = dst.length;
+    var index = 0;
+    // Inline function 'kotlin.js.unsafeCast' call
+    var arr = dst;
+    while (index < srcLen && index < dstLen) {
+      var tmp = index;
+      var _unary__edvuaz = index;
+      index = _unary__edvuaz + 1 | 0;
+      arr[tmp] = src[_unary__edvuaz];
+    }
+    return dst;
+  }
+  function arrayCopyResize(source, newSize, defaultValue) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    var result = source.slice(0, newSize);
+    // Inline function 'kotlin.copyArrayType' call
+    if (source.$type$ !== undefined) {
+      result.$type$ = source.$type$;
+    }
+    var index = source.length;
+    if (newSize > index) {
+      // Inline function 'kotlin.js.asDynamic' call
+      result.length = newSize;
+      while (index < newSize) {
+        var _unary__edvuaz = index;
+        index = _unary__edvuaz + 1 | 0;
+        result[_unary__edvuaz] = defaultValue;
+      }
+    }
+    return result;
+  }
+  var INV_2_26;
+  var INV_2_53;
+  function defaultPlatformRandom() {
+    _init_properties_PlatformRandom_kt__6kjv62();
+    // Inline function 'kotlin.js.unsafeCast' call
+    var tmp$ret$0 = Math.random() * Math.pow(2, 32) | 0;
+    return Random_0(tmp$ret$0);
+  }
+  var properties_initialized_PlatformRandom_kt_uibhw8;
+  function _init_properties_PlatformRandom_kt__6kjv62() {
+    if (!properties_initialized_PlatformRandom_kt_uibhw8) {
+      properties_initialized_PlatformRandom_kt_uibhw8 = true;
+      // Inline function 'kotlin.math.pow' call
+      INV_2_26 = Math.pow(2.0, -26);
+      // Inline function 'kotlin.math.pow' call
+      INV_2_53 = Math.pow(2.0, -53);
+    }
+  }
+  function PrimitiveKClassImpl(jClass, givenSimpleName, isInstanceFunction) {
+    KClassImpl.call(this);
+    this.a4_1 = jClass;
+    this.b4_1 = givenSimpleName;
+    this.c4_1 = isInstanceFunction;
+  }
+  protoOf(PrimitiveKClassImpl).d4 = function () {
+    return this.a4_1;
+  };
+  protoOf(PrimitiveKClassImpl).equals = function (other) {
+    if (!(other instanceof PrimitiveKClassImpl))
+      return false;
+    return protoOf(KClassImpl).equals.call(this, other) && this.b4_1 === other.b4_1;
+  };
+  protoOf(PrimitiveKClassImpl).e4 = function () {
+    return this.b4_1;
+  };
+  function KClassImpl() {
+  }
+  protoOf(KClassImpl).equals = function (other) {
+    var tmp;
+    if (other instanceof NothingKClassImpl) {
+      tmp = false;
+    } else {
+      if (other instanceof KClassImpl) {
+        tmp = equals(this.d4(), other.d4());
+      } else {
+        tmp = false;
+      }
+    }
+    return tmp;
+  };
+  protoOf(KClassImpl).hashCode = function () {
+    var tmp0_safe_receiver = this.e4();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : getStringHashCode(tmp0_safe_receiver);
+    return tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+  };
+  protoOf(KClassImpl).toString = function () {
+    return 'class ' + this.e4();
+  };
+  function NothingKClassImpl() {
+  }
+  function StringBuilder_init_$Init$(capacity, $this) {
+    StringBuilder_init_$Init$_0($this);
+    return $this;
+  }
+  function StringBuilder_init_$Create$(capacity) {
+    return StringBuilder_init_$Init$(capacity, objectCreate(protoOf(StringBuilder)));
+  }
+  function StringBuilder_init_$Init$_0($this) {
+    StringBuilder.call($this, '');
+    return $this;
+  }
+  function StringBuilder_init_$Create$_0() {
+    return StringBuilder_init_$Init$_0(objectCreate(protoOf(StringBuilder)));
+  }
+  function StringBuilder(content) {
+    this.t3_1 = content;
+  }
+  protoOf(StringBuilder).w3 = function (value) {
+    this.t3_1 = this.t3_1 + toString(value);
+    return this;
+  };
+  protoOf(StringBuilder).b = function (value) {
+    this.t3_1 = this.t3_1 + toString_0(value);
+    return this;
+  };
+  protoOf(StringBuilder).u3 = function (value) {
+    this.t3_1 = this.t3_1 + toString_0(value);
+    return this;
+  };
+  protoOf(StringBuilder).v3 = function (value) {
+    var tmp = this;
+    var tmp_0 = this.t3_1;
+    tmp.t3_1 = tmp_0 + (value == null ? 'null' : value);
+    return this;
+  };
+  protoOf(StringBuilder).toString = function () {
+    return this.t3_1;
+  };
+  function AbstractCollection$toString$lambda(this$0) {
+    return function (it) {
+      return it === this$0 ? '(this Collection)' : toString_0(it);
+    };
+  }
+  function AbstractCollection() {
+  }
+  protoOf(AbstractCollection).j = function (element) {
+    var tmp$ret$0;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.any' call
+      var tmp;
+      if (isInterface(this, Collection)) {
+        tmp = this.h();
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        tmp$ret$0 = false;
+        break $l$block_0;
+      }
+      var _iterator__ex2g4s = this.c();
+      while (_iterator__ex2g4s.d()) {
+        var element_0 = _iterator__ex2g4s.e();
+        if (equals(element_0, element)) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$0 = false;
+    }
+    return tmp$ret$0;
+  };
+  protoOf(AbstractCollection).k = function (elements) {
+    var tmp$ret$0;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.all' call
+      var tmp;
+      if (isInterface(elements, Collection)) {
+        tmp = elements.h();
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        tmp$ret$0 = true;
+        break $l$block_0;
+      }
+      var _iterator__ex2g4s = elements.c();
+      while (_iterator__ex2g4s.d()) {
+        var element = _iterator__ex2g4s.e();
+        if (!this.j(element)) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  };
+  protoOf(AbstractCollection).h = function () {
+    return this.f() === 0;
+  };
+  protoOf(AbstractCollection).toString = function () {
+    return joinToString_0(this, ', ', '[', ']', VOID, VOID, AbstractCollection$toString$lambda(this));
+  };
+  protoOf(AbstractCollection).toArray = function () {
+    return collectionToArray(this);
+  };
+  function Companion_2() {
+    this.g1_1 = 2147483639;
+  }
+  protoOf(Companion_2).x1 = function (index, size) {
+    if (index < 0 || index >= size) {
+      throw IndexOutOfBoundsException_init_$Create$_0('index: ' + index + ', size: ' + size);
+    }
+  };
+  protoOf(Companion_2).y1 = function (index, size) {
+    if (index < 0 || index > size) {
+      throw IndexOutOfBoundsException_init_$Create$_0('index: ' + index + ', size: ' + size);
+    }
+  };
+  protoOf(Companion_2).b3 = function (oldCapacity, minCapacity) {
+    var newCapacity = oldCapacity + (oldCapacity >> 1) | 0;
+    if ((newCapacity - minCapacity | 0) < 0)
+      newCapacity = minCapacity;
+    if ((newCapacity - 2147483639 | 0) > 0)
+      newCapacity = minCapacity > 2147483639 ? 2147483647 : 2147483639;
+    return newCapacity;
+  };
+  protoOf(Companion_2).i1 = function (c) {
+    var hashCode = 1;
+    var _iterator__ex2g4s = c.c();
+    while (_iterator__ex2g4s.d()) {
+      var e = _iterator__ex2g4s.e();
+      var tmp = imul(31, hashCode);
+      var tmp1_elvis_lhs = e == null ? null : hashCode_0(e);
+      hashCode = tmp + (tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs) | 0;
+    }
+    return hashCode;
+  };
+  protoOf(Companion_2).h1 = function (c, other) {
+    if (!(c.f() === other.f()))
+      return false;
+    var otherIterator = other.c();
+    var _iterator__ex2g4s = c.c();
+    while (_iterator__ex2g4s.d()) {
+      var elem = _iterator__ex2g4s.e();
+      var elemOther = otherIterator.e();
+      if (!equals(elem, elemOther)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var Companion_instance_2;
+  function Companion_getInstance_2() {
+    return Companion_instance_2;
+  }
+  function toString_2($this, entry) {
+    return toString_3($this, entry.l()) + '=' + toString_3($this, entry.m());
+  }
+  function toString_3($this, o) {
+    return o === $this ? '(this Map)' : toString_0(o);
+  }
+  function implFindEntry($this, key) {
+    var tmp0 = $this.p();
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s = tmp0.c();
+      while (_iterator__ex2g4s.d()) {
+        var element = _iterator__ex2g4s.e();
+        if (equals(element.l(), key)) {
+          tmp$ret$1 = element;
+          break $l$block;
+        }
+      }
+      tmp$ret$1 = null;
+    }
+    return tmp$ret$1;
+  }
+  function Companion_3() {
+  }
+  var Companion_instance_3;
+  function Companion_getInstance_3() {
+    return Companion_instance_3;
+  }
+  function AbstractMap$toString$lambda(this$0) {
+    return function (it) {
+      return toString_2(this$0, it);
+    };
+  }
+  function AbstractMap() {
+    this.o1_1 = null;
+    this.p1_1 = null;
+  }
+  protoOf(AbstractMap).n = function (key) {
+    return !(implFindEntry(this, key) == null);
+  };
+  protoOf(AbstractMap).q1 = function (entry) {
+    if (!(!(entry == null) ? isInterface(entry, Entry) : false))
+      return false;
+    var key = entry.l();
+    var value = entry.m();
+    // Inline function 'kotlin.collections.get' call
+    var ourValue = (isInterface(this, KtMap) ? this : THROW_CCE()).o(key);
+    if (!equals(value, ourValue)) {
+      return false;
+    }
+    var tmp;
+    if (ourValue == null) {
+      // Inline function 'kotlin.collections.containsKey' call
+      tmp = !(isInterface(this, KtMap) ? this : THROW_CCE()).n(key);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      return false;
+    }
+    return true;
+  };
+  protoOf(AbstractMap).equals = function (other) {
+    if (other === this)
+      return true;
+    if (!(!(other == null) ? isInterface(other, KtMap) : false))
+      return false;
+    if (!(this.f() === other.f()))
+      return false;
+    var tmp0 = other.p();
+    var tmp$ret$0;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.all' call
+      var tmp;
+      if (isInterface(tmp0, Collection)) {
+        tmp = tmp0.h();
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        tmp$ret$0 = true;
+        break $l$block_0;
+      }
+      var _iterator__ex2g4s = tmp0.c();
+      while (_iterator__ex2g4s.d()) {
+        var element = _iterator__ex2g4s.e();
+        if (!this.q1(element)) {
+          tmp$ret$0 = false;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  };
+  protoOf(AbstractMap).o = function (key) {
+    var tmp0_safe_receiver = implFindEntry(this, key);
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.m();
+  };
+  protoOf(AbstractMap).hashCode = function () {
+    return hashCode_0(this.p());
+  };
+  protoOf(AbstractMap).f = function () {
+    return this.p().f();
+  };
+  protoOf(AbstractMap).toString = function () {
+    var tmp = this.p();
+    return joinToString_0(tmp, ', ', '{', '}', VOID, VOID, AbstractMap$toString$lambda(this));
+  };
+  function Companion_4() {
+  }
+  protoOf(Companion_4).s1 = function (c) {
+    var hashCode = 0;
+    var _iterator__ex2g4s = c.c();
+    while (_iterator__ex2g4s.d()) {
+      var element = _iterator__ex2g4s.e();
+      var tmp = hashCode;
+      var tmp1_elvis_lhs = element == null ? null : hashCode_0(element);
+      hashCode = tmp + (tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs) | 0;
+    }
+    return hashCode;
+  };
+  protoOf(Companion_4).r1 = function (c, other) {
+    if (!(c.f() === other.f()))
+      return false;
+    return c.k(other);
+  };
+  var Companion_instance_4;
+  function Companion_getInstance_4() {
+    return Companion_instance_4;
+  }
+  function collectionToArrayCommonImpl(collection) {
+    if (collection.h()) {
+      // Inline function 'kotlin.emptyArray' call
+      return [];
+    }
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = collection.f();
+    var destination = Array(size);
+    var iterator = collection.c();
+    var index = 0;
+    while (iterator.d()) {
+      var _unary__edvuaz = index;
+      index = _unary__edvuaz + 1 | 0;
+      destination[_unary__edvuaz] = iterator.e();
+    }
+    return destination;
+  }
+  function emptyList() {
+    return EmptyList_getInstance();
+  }
+  function EmptyList() {
+    EmptyList_instance = this;
+    this.f4_1 = new Long(-1478467534, -1720727600);
+  }
+  protoOf(EmptyList).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, KtList) : false) {
+      tmp = other.h();
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(EmptyList).hashCode = function () {
+    return 1;
+  };
+  protoOf(EmptyList).toString = function () {
+    return '[]';
+  };
+  protoOf(EmptyList).f = function () {
+    return 0;
+  };
+  protoOf(EmptyList).h = function () {
+    return true;
+  };
+  protoOf(EmptyList).g = function (index) {
+    throw IndexOutOfBoundsException_init_$Create$_0("Empty list doesn't contain element at index " + index + '.');
+  };
+  protoOf(EmptyList).c = function () {
+    return EmptyIterator_instance;
+  };
+  var EmptyList_instance;
+  function EmptyList_getInstance() {
+    if (EmptyList_instance == null)
+      new EmptyList();
+    return EmptyList_instance;
+  }
+  function EmptyIterator() {
+  }
+  protoOf(EmptyIterator).d = function () {
+    return false;
+  };
+  protoOf(EmptyIterator).e = function () {
+    throw NoSuchElementException_init_$Create$();
+  };
+  var EmptyIterator_instance;
+  function EmptyIterator_getInstance() {
+    return EmptyIterator_instance;
+  }
+  function optimizeReadOnlyList(_this__u8e3s4) {
+    switch (_this__u8e3s4.f()) {
+      case 0:
+        return emptyList();
+      case 1:
+        return listOf(_this__u8e3s4.g(0));
+      default:
+        return _this__u8e3s4;
+    }
+  }
+  function collectionSizeOrDefault(_this__u8e3s4, default_0) {
+    var tmp;
+    if (isInterface(_this__u8e3s4, Collection)) {
+      tmp = _this__u8e3s4.f();
+    } else {
+      tmp = default_0;
+    }
+    return tmp;
+  }
+  function compareValues(a, b) {
+    if (a === b)
+      return 0;
+    if (a == null)
+      return -1;
+    if (b == null)
+      return 1;
+    return compareTo((!(a == null) ? isComparable(a) : false) ? a : THROW_CCE(), b);
+  }
+  function Default() {
+    Default_instance = this;
+    Random.call(this);
+    this.g4_1 = defaultPlatformRandom();
+  }
+  var Default_instance;
+  function Default_getInstance() {
+    if (Default_instance == null)
+      new Default();
+    return Default_instance;
+  }
+  function Random() {
+    Default_getInstance();
+  }
+  function Random_0(seed) {
+    return XorWowRandom_init_$Create$(seed, seed >> 31);
+  }
+  function XorWowRandom_init_$Init$(seed1, seed2, $this) {
+    XorWowRandom.call($this, seed1, seed2, 0, 0, ~seed1, seed1 << 10 ^ (seed2 >>> 4 | 0));
+    return $this;
+  }
+  function XorWowRandom_init_$Create$(seed1, seed2) {
+    return XorWowRandom_init_$Init$(seed1, seed2, objectCreate(protoOf(XorWowRandom)));
+  }
+  function checkInvariants($this) {
+    // Inline function 'kotlin.require' call
+    if (!!(($this.h4_1 | $this.i4_1 | $this.j4_1 | $this.k4_1 | $this.l4_1) === 0)) {
+      var message = 'Initial state must have at least one non-zero element.';
+      throw IllegalArgumentException_init_$Create$_0(toString_1(message));
+    }
+  }
+  function Companion_5() {
+    Companion_instance_5 = this;
+    this.n4_1 = new Long(0, 0);
+  }
+  var Companion_instance_5;
+  function Companion_getInstance_5() {
+    if (Companion_instance_5 == null)
+      new Companion_5();
+    return Companion_instance_5;
+  }
+  function XorWowRandom(x, y, z, w, v, addend) {
+    Companion_getInstance_5();
+    Random.call(this);
+    this.h4_1 = x;
+    this.i4_1 = y;
+    this.j4_1 = z;
+    this.k4_1 = w;
+    this.l4_1 = v;
+    this.m4_1 = addend;
+    checkInvariants(this);
+    // Inline function 'kotlin.repeat' call
+    var inductionVariable = 0;
+    if (inductionVariable < 64)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        this.o4();
+      }
+       while (inductionVariable < 64);
+  }
+  protoOf(XorWowRandom).o4 = function () {
+    var t = this.h4_1;
+    t = t ^ (t >>> 2 | 0);
+    this.h4_1 = this.i4_1;
+    this.i4_1 = this.j4_1;
+    this.j4_1 = this.k4_1;
+    var v0 = this.l4_1;
+    this.k4_1 = v0;
+    t = t ^ t << 1 ^ v0 ^ v0 << 4;
+    this.l4_1 = t;
+    this.m4_1 = this.m4_1 + 362437 | 0;
+    return t + this.m4_1 | 0;
+  };
+  function appendElement(_this__u8e3s4, element, transform) {
+    if (!(transform == null))
+      _this__u8e3s4.b(transform(element));
+    else {
+      if (element == null ? true : isCharSequence(element))
+        _this__u8e3s4.b(element);
+      else {
+        if (element instanceof Char)
+          _this__u8e3s4.w3(element.p4_1);
+        else {
+          _this__u8e3s4.b(toString_1(element));
+        }
+      }
+    }
+  }
+  function UnsafeLazyImpl(initializer) {
+    this.q4_1 = initializer;
+    this.r4_1 = UNINITIALIZED_VALUE_instance;
+  }
+  protoOf(UnsafeLazyImpl).m = function () {
+    if (this.r4_1 === UNINITIALIZED_VALUE_instance) {
+      this.r4_1 = ensureNotNull(this.q4_1)();
+      this.q4_1 = null;
+    }
+    var tmp = this.r4_1;
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  protoOf(UnsafeLazyImpl).s4 = function () {
+    return !(this.r4_1 === UNINITIALIZED_VALUE_instance);
+  };
+  protoOf(UnsafeLazyImpl).toString = function () {
+    return this.s4() ? toString_0(this.m()) : 'Lazy value not initialized yet.';
+  };
+  function UNINITIALIZED_VALUE() {
+  }
+  var UNINITIALIZED_VALUE_instance;
+  function UNINITIALIZED_VALUE_getInstance() {
+    return UNINITIALIZED_VALUE_instance;
+  }
+  //region block: post-declaration
+  protoOf(InternalHashMap).n2 = containsAllEntries;
+  //endregion
+  //region block: init
+  Unit_instance = new Unit();
+  _stableSortingIsSupported = null;
+  Companion_instance_1 = new Companion_1();
+  Companion_instance_2 = new Companion_2();
+  Companion_instance_3 = new Companion_3();
+  Companion_instance_4 = new Companion_4();
+  EmptyIterator_instance = new EmptyIterator();
+  UNINITIALIZED_VALUE_instance = new UNINITIALIZED_VALUE();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = VOID;
+  _.$_$.b = ArrayList_init_$Create$_0;
+  _.$_$.c = LinkedHashMap_init_$Create$;
+  _.$_$.d = IllegalArgumentException_init_$Create$_0;
+  _.$_$.e = IllegalStateException_init_$Create$_0;
+  _.$_$.f = Unit_instance;
+  _.$_$.g = KtMap;
+  _.$_$.h = collectionSizeOrDefault;
+  _.$_$.i = first;
+  _.$_$.j = sortedWith;
+  _.$_$.k = compareValues;
+  _.$_$.l = FunctionAdapter;
+  _.$_$.m = defineProp;
+  _.$_$.n = equals;
+  _.$_$.o = hashCode_0;
+  _.$_$.p = initMetadataForClass;
+  _.$_$.q = initMetadataForCompanion;
+  _.$_$.r = initMetadataForObject;
+  _.$_$.s = isInterface;
+  _.$_$.t = protoOf;
+  _.$_$.u = toString_1;
+  _.$_$.v = Random;
+  _.$_$.w = Comparator;
+  _.$_$.x = THROW_CCE;
+  _.$_$.y = ensureNotNull;
+  _.$_$.z = lazy;
+  _.$_$.a1 = toString_0;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=kotlin-kotlin-stdlib.js.map