@xiuper/mpp-core 0.0.2

package/Kotlin-Immutable-Collections-kotlinx-collections-immutable.js

@@ -0,0 +1,1241 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'Kotlin-Immutable-Collections-kotlinx-collections-immutable'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'Kotlin-Immutable-Collections-kotlinx-collections-immutable'.");
+    }
+    globalThis['Kotlin-Immutable-Collections-kotlinx-collections-immutable'] = factory(typeof globalThis['Kotlin-Immutable-Collections-kotlinx-collections-immutable'] === 'undefined' ? {} : globalThis['Kotlin-Immutable-Collections-kotlinx-collections-immutable'], globalThis['kotlin-kotlin-stdlib']);
+  }
+}(function (_, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var THROW_CCE = kotlin_kotlin.$_$.zk;
+  var protoOf = kotlin_kotlin.$_$.we;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.vd;
+  var equals = kotlin_kotlin.$_$.md;
+  var AbstractMap = kotlin_kotlin.$_$.j6;
+  var hashCode = kotlin_kotlin.$_$.td;
+  var KtMap = kotlin_kotlin.$_$.v6;
+  var isInterface = kotlin_kotlin.$_$.je;
+  var initMetadataForClass = kotlin_kotlin.$_$.ud;
+  var VOID = kotlin_kotlin.$_$.h;
+  var AbstractMutableMap = kotlin_kotlin.$_$.k6;
+  var KtMutableMap = kotlin_kotlin.$_$.x6;
+  var Entry = kotlin_kotlin.$_$.t6;
+  var toString = kotlin_kotlin.$_$.gm;
+  var Unit_instance = kotlin_kotlin.$_$.h6;
+  var NoSuchElementException_init_$Create$ = kotlin_kotlin.$_$.p2;
+  var AbstractSet = kotlin_kotlin.$_$.l6;
+  var Collection = kotlin_kotlin.$_$.n6;
+  var KtSet = kotlin_kotlin.$_$.z6;
+  var AbstractCollection = kotlin_kotlin.$_$.i6;
+  var objectCreate = kotlin_kotlin.$_$.ve;
+  var until = kotlin_kotlin.$_$.of;
+  var step = kotlin_kotlin.$_$.nf;
+  var countOneBits = kotlin_kotlin.$_$.pl;
+  var arrayCopy = kotlin_kotlin.$_$.d7;
+  var copyOf = kotlin_kotlin.$_$.f8;
+  var ensureNotNull = kotlin_kotlin.$_$.sl;
+  var ConcurrentModificationException_init_$Create$ = kotlin_kotlin.$_$.s1;
+  var initMetadataForObject = kotlin_kotlin.$_$.ae;
+  var AssertionError_init_$Create$ = kotlin_kotlin.$_$.r1;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(PersistentHashMap, 'PersistentHashMap', VOID, AbstractMap, [AbstractMap, KtMap]);
+  initMetadataForClass(PersistentHashMapBuilder, 'PersistentHashMapBuilder', VOID, AbstractMutableMap, [KtMutableMap, AbstractMutableMap]);
+  initMetadataForClass(PersistentHashMapBaseIterator, 'PersistentHashMapBaseIterator');
+  initMetadataForClass(PersistentHashMapKeysIterator, 'PersistentHashMapKeysIterator', VOID, PersistentHashMapBaseIterator);
+  initMetadataForClass(PersistentHashMapValuesIterator, 'PersistentHashMapValuesIterator', VOID, PersistentHashMapBaseIterator);
+  initMetadataForClass(PersistentHashMapEntriesIterator, 'PersistentHashMapEntriesIterator', VOID, PersistentHashMapBaseIterator);
+  initMetadataForClass(MapEntry, 'MapEntry', VOID, VOID, [Entry]);
+  initMetadataForClass(TrieNodeBaseIterator, 'TrieNodeBaseIterator');
+  initMetadataForClass(TrieNodeKeysIterator, 'TrieNodeKeysIterator', TrieNodeKeysIterator, TrieNodeBaseIterator);
+  initMetadataForClass(TrieNodeValuesIterator, 'TrieNodeValuesIterator', TrieNodeValuesIterator, TrieNodeBaseIterator);
+  initMetadataForClass(TrieNodeEntriesIterator, 'TrieNodeEntriesIterator', TrieNodeEntriesIterator, TrieNodeBaseIterator);
+  initMetadataForClass(PersistentHashMapKeys, 'PersistentHashMapKeys', VOID, AbstractSet, [Collection, KtSet, AbstractSet]);
+  initMetadataForClass(PersistentHashMapValues, 'PersistentHashMapValues', VOID, AbstractCollection, [Collection, AbstractCollection]);
+  initMetadataForClass(PersistentHashMapEntries, 'PersistentHashMapEntries', VOID, AbstractSet, [Collection, KtSet, AbstractSet]);
+  initMetadataForClass(ModificationResult, 'ModificationResult');
+  initMetadataForCompanion(Companion_0);
+  initMetadataForClass(TrieNode, 'TrieNode');
+  initMetadataForCompanion(Companion_1);
+  initMetadataForClass(PersistentOrderedMap, 'PersistentOrderedMap', VOID, AbstractMap, [AbstractMap, KtMap]);
+  initMetadataForClass(LinkedValue, 'LinkedValue');
+  initMetadataForClass(PersistentOrderedMapBuilder, 'PersistentOrderedMapBuilder', VOID, AbstractMutableMap, [AbstractMutableMap, KtMutableMap]);
+  initMetadataForClass(PersistentOrderedMapKeysIterator, 'PersistentOrderedMapKeysIterator');
+  initMetadataForClass(PersistentOrderedMapValuesIterator, 'PersistentOrderedMapValuesIterator');
+  initMetadataForClass(PersistentOrderedMapEntriesIterator, 'PersistentOrderedMapEntriesIterator');
+  initMetadataForClass(PersistentOrderedMapLinksIterator, 'PersistentOrderedMapLinksIterator');
+  initMetadataForClass(PersistentOrderedMapKeys, 'PersistentOrderedMapKeys', VOID, AbstractSet, [Collection, KtSet, AbstractSet]);
+  initMetadataForClass(PersistentOrderedMapValues, 'PersistentOrderedMapValues', VOID, AbstractCollection, [Collection, AbstractCollection]);
+  initMetadataForClass(PersistentOrderedMapEntries, 'PersistentOrderedMapEntries', VOID, AbstractSet, [Collection, KtSet, AbstractSet]);
+  initMetadataForObject(EndOfChain, 'EndOfChain');
+  initMetadataForObject(MapImplementation, 'MapImplementation');
+  //endregion
+  function persistentMapOf() {
+    return Companion_getInstance_1().cfz();
+  }
+  function createEntries($this) {
+    return new PersistentHashMapEntries($this);
+  }
+  function Companion() {
+    Companion_instance = this;
+    this.dfz_1 = new PersistentHashMap(Companion_getInstance_0().efz_1, 0);
+  }
+  protoOf(Companion).cfz = function () {
+    var tmp = this.dfz_1;
+    return tmp instanceof PersistentHashMap ? tmp : THROW_CCE();
+  };
+  var Companion_instance;
+  function Companion_getInstance() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function PersistentHashMap$equals$lambda(a, b) {
+    return equals(a, b.ffz_1);
+  }
+  function PersistentHashMap$equals$lambda_0(a, b) {
+    return equals(a, b.ffz_1);
+  }
+  function PersistentHashMap$equals$lambda_1(a, b) {
+    return equals(a, b);
+  }
+  function PersistentHashMap$equals$lambda_2(a, b) {
+    return equals(a, b);
+  }
+  function PersistentHashMap(node, size) {
+    Companion_getInstance();
+    AbstractMap.call(this);
+    this.kfz_1 = node;
+    this.lfz_1 = size;
+  }
+  protoOf(PersistentHashMap).s = function () {
+    return this.lfz_1;
+  };
+  protoOf(PersistentHashMap).k2 = function () {
+    return new PersistentHashMapKeys(this);
+  };
+  protoOf(PersistentHashMap).l2 = function () {
+    return new PersistentHashMapValues(this);
+  };
+  protoOf(PersistentHashMap).z = function () {
+    return createEntries(this);
+  };
+  protoOf(PersistentHashMap).h2 = function (key) {
+    // Inline function 'kotlin.hashCode' call
+    var tmp1_elvis_lhs = key == null ? null : hashCode(key);
+    var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    return this.kfz_1.qfz(tmp$ret$0, key, 0);
+  };
+  protoOf(PersistentHashMap).j2 = function (key) {
+    // Inline function 'kotlin.hashCode' call
+    var tmp1_elvis_lhs = key == null ? null : hashCode(key);
+    var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    return this.kfz_1.rfz(tmp$ret$0, key, 0);
+  };
+  protoOf(PersistentHashMap).r2 = function (key, value) {
+    // Inline function 'kotlin.hashCode' call
+    var tmp1_elvis_lhs = key == null ? null : hashCode(key);
+    var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    var tmp0_elvis_lhs = this.kfz_1.sfz(tmp$ret$0, key, value, 0);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return this;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var newNodeResult = tmp;
+    return new PersistentHashMap(newNodeResult.tfz_1, this.lfz_1 + newNodeResult.ufz_1 | 0);
+  };
+  protoOf(PersistentHashMap).s2 = function (key) {
+    // Inline function 'kotlin.hashCode' call
+    var tmp1_elvis_lhs = key == null ? null : hashCode(key);
+    var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    var newNode = this.kfz_1.vfz(tmp$ret$0, key, 0);
+    if (this.kfz_1 === newNode) {
+      return this;
+    }
+    if (newNode == null) {
+      return Companion_getInstance().cfz();
+    }
+    return new PersistentHashMap(newNode, this.lfz_1 - 1 | 0);
+  };
+  protoOf(PersistentHashMap).equals = function (other) {
+    if (other === this)
+      return true;
+    if (!(!(other == null) ? isInterface(other, KtMap) : false))
+      return false;
+    if (!(this.lfz_1 === other.s()))
+      return false;
+    var tmp;
+    if (other instanceof PersistentOrderedMap) {
+      tmp = this.kfz_1.bg0(other.lg0_1.kfz_1, PersistentHashMap$equals$lambda);
+    } else {
+      if (other instanceof PersistentOrderedMapBuilder) {
+        var tmp_0 = other.gg0_1.ag0_1;
+        tmp = this.kfz_1.bg0(tmp_0, PersistentHashMap$equals$lambda_0);
+      } else {
+        if (other instanceof PersistentHashMap) {
+          tmp = this.kfz_1.bg0(other.kfz_1, PersistentHashMap$equals$lambda_1);
+        } else {
+          if (other instanceof PersistentHashMapBuilder) {
+            var tmp_1 = other.ag0_1;
+            tmp = this.kfz_1.bg0(tmp_1, PersistentHashMap$equals$lambda_2);
+          } else {
+            tmp = protoOf(AbstractMap).equals.call(this, other);
+          }
+        }
+      }
+    }
+    return tmp;
+  };
+  protoOf(PersistentHashMap).hashCode = function () {
+    return protoOf(AbstractMap).hashCode.call(this);
+  };
+  function PersistentHashMapBuilder() {
+  }
+  function PersistentHashMapKeysIterator(node) {
+    var tmp = 0;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var tmp_0 = Array(8);
+    while (tmp < 8) {
+      tmp_0[tmp] = new TrieNodeKeysIterator();
+      tmp = tmp + 1 | 0;
+    }
+    PersistentHashMapBaseIterator.call(this, node, tmp_0);
+  }
+  function PersistentHashMapValuesIterator(node) {
+    var tmp = 0;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var tmp_0 = Array(8);
+    while (tmp < 8) {
+      tmp_0[tmp] = new TrieNodeValuesIterator();
+      tmp = tmp + 1 | 0;
+    }
+    PersistentHashMapBaseIterator.call(this, node, tmp_0);
+  }
+  function PersistentHashMapEntriesIterator(node) {
+    var tmp = 0;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var tmp_0 = Array(8);
+    while (tmp < 8) {
+      tmp_0[tmp] = new TrieNodeEntriesIterator();
+      tmp = tmp + 1 | 0;
+    }
+    PersistentHashMapBaseIterator.call(this, node, tmp_0);
+  }
+  function MapEntry(key, value) {
+    this.pg0_1 = key;
+    this.qg0_1 = value;
+  }
+  protoOf(MapEntry).a1 = function () {
+    return this.pg0_1;
+  };
+  protoOf(MapEntry).b1 = function () {
+    return this.qg0_1;
+  };
+  protoOf(MapEntry).hashCode = function () {
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = this.a1();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+    var tmp = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver_0 = this.b1();
+    var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+    return tmp ^ (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0);
+  };
+  protoOf(MapEntry).equals = function (other) {
+    var tmp0_safe_receiver = (!(other == null) ? isInterface(other, Entry) : false) ? other : null;
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp = (equals(tmp0_safe_receiver.a1(), this.a1()) && equals(tmp0_safe_receiver.b1(), this.b1()));
+    }
+    var tmp1_elvis_lhs = tmp;
+    return tmp1_elvis_lhs == null ? false : tmp1_elvis_lhs;
+  };
+  protoOf(MapEntry).toString = function () {
+    return toString(this.a1()) + '=' + toString(this.b1());
+  };
+  function moveToNextNodeWithData($this, pathIndex) {
+    if ($this.mg0_1[pathIndex].ug0()) {
+      return pathIndex;
+    }
+    if ($this.mg0_1[pathIndex].yg0()) {
+      var node = $this.mg0_1[pathIndex].vg0();
+      if (pathIndex === 6) {
+        $this.mg0_1[pathIndex + 1 | 0].xg0(node.pfz_1, node.pfz_1.length);
+      } else {
+        $this.mg0_1[pathIndex + 1 | 0].xg0(node.pfz_1, imul(2, node.wg0()));
+      }
+      return moveToNextNodeWithData($this, pathIndex + 1 | 0);
+    }
+    return -1;
+  }
+  function ensureNextEntryIsReady($this) {
+    if ($this.mg0_1[$this.ng0_1].ug0()) {
+      return Unit_instance;
+    }
+    var inductionVariable = $this.ng0_1;
+    if (0 <= inductionVariable)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + -1 | 0;
+        var result = moveToNextNodeWithData($this, i);
+        if (result === -1 && $this.mg0_1[i].yg0()) {
+          $this.mg0_1[i].zg0();
+          result = moveToNextNodeWithData($this, i);
+        }
+        if (!(result === -1)) {
+          $this.ng0_1 = result;
+          return Unit_instance;
+        }
+        if (i > 0) {
+          $this.mg0_1[i - 1 | 0].zg0();
+        }
+        $this.mg0_1[i].xg0(Companion_getInstance_0().efz_1.pfz_1, 0);
+      }
+       while (0 <= inductionVariable);
+    $this.og0_1 = false;
+  }
+  function checkHasNext($this) {
+    if (!$this.q())
+      throw NoSuchElementException_init_$Create$();
+  }
+  function PersistentHashMapBaseIterator(node, path) {
+    this.mg0_1 = path;
+    this.ng0_1 = 0;
+    this.og0_1 = true;
+    this.mg0_1[0].xg0(node.pfz_1, imul(2, node.wg0()));
+    this.ng0_1 = 0;
+    ensureNextEntryIsReady(this);
+  }
+  protoOf(PersistentHashMapBaseIterator).q = function () {
+    return this.og0_1;
+  };
+  protoOf(PersistentHashMapBaseIterator).r = function () {
+    checkHasNext(this);
+    var result = this.mg0_1[this.ng0_1].r();
+    ensureNextEntryIsReady(this);
+    return result;
+  };
+  function TrieNodeBaseIterator() {
+    this.rg0_1 = Companion_getInstance_0().efz_1.pfz_1;
+    this.sg0_1 = 0;
+    this.tg0_1 = 0;
+  }
+  protoOf(TrieNodeBaseIterator).ag1 = function (buffer, dataSize, index) {
+    this.rg0_1 = buffer;
+    this.sg0_1 = dataSize;
+    this.tg0_1 = index;
+  };
+  protoOf(TrieNodeBaseIterator).xg0 = function (buffer, dataSize) {
+    this.ag1(buffer, dataSize, 0);
+  };
+  protoOf(TrieNodeBaseIterator).ug0 = function () {
+    return this.tg0_1 < this.sg0_1;
+  };
+  protoOf(TrieNodeBaseIterator).yg0 = function () {
+    assert(this.tg0_1 >= this.sg0_1);
+    return this.tg0_1 < this.rg0_1.length;
+  };
+  protoOf(TrieNodeBaseIterator).vg0 = function () {
+    assert(this.yg0());
+    var tmp = this.rg0_1[this.tg0_1];
+    return tmp instanceof TrieNode ? tmp : THROW_CCE();
+  };
+  protoOf(TrieNodeBaseIterator).zg0 = function () {
+    assert(this.yg0());
+    this.tg0_1 = this.tg0_1 + 1 | 0;
+  };
+  protoOf(TrieNodeBaseIterator).q = function () {
+    return this.ug0();
+  };
+  function TrieNodeKeysIterator() {
+    TrieNodeBaseIterator.call(this);
+  }
+  protoOf(TrieNodeKeysIterator).r = function () {
+    assert(this.ug0());
+    this.tg0_1 = this.tg0_1 + 2 | 0;
+    var tmp = this.rg0_1[this.tg0_1 - 2 | 0];
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  function TrieNodeValuesIterator() {
+    TrieNodeBaseIterator.call(this);
+  }
+  protoOf(TrieNodeValuesIterator).r = function () {
+    assert(this.ug0());
+    this.tg0_1 = this.tg0_1 + 2 | 0;
+    var tmp = this.rg0_1[this.tg0_1 - 1 | 0];
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  };
+  function TrieNodeEntriesIterator() {
+    TrieNodeBaseIterator.call(this);
+  }
+  protoOf(TrieNodeEntriesIterator).r = function () {
+    assert(this.ug0());
+    this.tg0_1 = this.tg0_1 + 2 | 0;
+    var tmp = this.rg0_1[this.tg0_1 - 2 | 0];
+    var tmp_0 = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+    var tmp_1 = this.rg0_1[this.tg0_1 - 1 | 0];
+    return new MapEntry(tmp_0, (tmp_1 == null ? true : !(tmp_1 == null)) ? tmp_1 : THROW_CCE());
+  };
+  function PersistentHashMapKeys(map) {
+    AbstractSet.call(this);
+    this.kg1_1 = map;
+  }
+  protoOf(PersistentHashMapKeys).s = function () {
+    return this.kg1_1.lfz_1;
+  };
+  protoOf(PersistentHashMapKeys).q6 = function (element) {
+    return this.kg1_1.h2(element);
+  };
+  protoOf(PersistentHashMapKeys).w = function (element) {
+    if (!(element == null ? true : !(element == null)))
+      return false;
+    return this.q6((element == null ? true : !(element == null)) ? element : THROW_CCE());
+  };
+  protoOf(PersistentHashMapKeys).p = function () {
+    return new PersistentHashMapKeysIterator(this.kg1_1.kfz_1);
+  };
+  function PersistentHashMapValues(map) {
+    AbstractCollection.call(this);
+    this.lg1_1 = map;
+  }
+  protoOf(PersistentHashMapValues).s = function () {
+    return this.lg1_1.lfz_1;
+  };
+  protoOf(PersistentHashMapValues).v6 = function (element) {
+    return this.lg1_1.i2(element);
+  };
+  protoOf(PersistentHashMapValues).w = function (element) {
+    if (!(element == null ? true : !(element == null)))
+      return false;
+    return this.v6((element == null ? true : !(element == null)) ? element : THROW_CCE());
+  };
+  protoOf(PersistentHashMapValues).p = function () {
+    return new PersistentHashMapValuesIterator(this.lg1_1.kfz_1);
+  };
+  function PersistentHashMapEntries(map) {
+    AbstractSet.call(this);
+    this.mg1_1 = map;
+  }
+  protoOf(PersistentHashMapEntries).s = function () {
+    return this.mg1_1.lfz_1;
+  };
+  protoOf(PersistentHashMapEntries).ng1 = function (element) {
+    return MapImplementation_instance.og1(this.mg1_1, element);
+  };
+  protoOf(PersistentHashMapEntries).w = function (element) {
+    if (!(!(element == null) ? isInterface(element, Entry) : false))
+      return false;
+    return this.ng1((!(element == null) ? isInterface(element, Entry) : false) ? element : THROW_CCE());
+  };
+  protoOf(PersistentHashMapEntries).p = function () {
+    return new PersistentHashMapEntriesIterator(this.mg1_1.kfz_1);
+  };
+  function TrieNode_init_$Init$(dataMap, nodeMap, buffer, $this) {
+    TrieNode.call($this, dataMap, nodeMap, buffer, null);
+    return $this;
+  }
+  function TrieNode_init_$Create$(dataMap, nodeMap, buffer) {
+    return TrieNode_init_$Init$(dataMap, nodeMap, buffer, objectCreate(protoOf(TrieNode)));
+  }
+  function ModificationResult(node, sizeDelta) {
+    this.tfz_1 = node;
+    this.ufz_1 = sizeDelta;
+  }
+  function asInsertResult($this) {
+    return new ModificationResult($this, 1);
+  }
+  function asUpdateResult($this) {
+    return new ModificationResult($this, 0);
+  }
+  function hasNodeAt($this, positionMask) {
+    return !(($this.nfz_1 & positionMask) === 0);
+  }
+  function keyAtIndex($this, keyIndex) {
+    var tmp = $this.pfz_1[keyIndex];
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  }
+  function valueAtKeyIndex($this, keyIndex) {
+    var tmp = $this.pfz_1[keyIndex + 1 | 0];
+    return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+  }
+  function insertEntryAt($this, positionMask, key, value) {
+    var keyIndex = $this.pg1(positionMask);
+    var newBuffer = insertEntryAtIndex($this.pfz_1, keyIndex, key, value);
+    return TrieNode_init_$Create$($this.mfz_1 | positionMask, $this.nfz_1, newBuffer);
+  }
+  function updateValueAtIndex($this, keyIndex, value) {
+    // Inline function 'kotlin.collections.copyOf' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var newBuffer = $this.pfz_1.slice();
+    newBuffer[keyIndex + 1 | 0] = value;
+    return TrieNode_init_$Create$($this.mfz_1, $this.nfz_1, newBuffer);
+  }
+  function updateNodeAtIndex($this, nodeIndex, positionMask, newNode, owner) {
+    var newNodeBuffer = newNode.pfz_1;
+    if (newNodeBuffer.length === 2 && newNode.nfz_1 === 0) {
+      if ($this.pfz_1.length === 1) {
+        newNode.mfz_1 = $this.nfz_1;
+        return newNode;
+      }
+      var keyIndex = $this.pg1(positionMask);
+      var newBuffer = replaceNodeWithEntry($this.pfz_1, nodeIndex, keyIndex, newNodeBuffer[0], newNodeBuffer[1]);
+      return new TrieNode($this.mfz_1 ^ positionMask, $this.nfz_1 ^ positionMask, newBuffer, owner);
+    }
+    if (!(owner == null) && $this.ofz_1 === owner) {
+      $this.pfz_1[nodeIndex] = newNode;
+      return $this;
+    }
+    // Inline function 'kotlin.collections.copyOf' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var newBuffer_0 = $this.pfz_1.slice();
+    newBuffer_0[nodeIndex] = newNode;
+    return new TrieNode($this.mfz_1, $this.nfz_1, newBuffer_0, owner);
+  }
+  function updateNodeAtIndex$default($this, nodeIndex, positionMask, newNode, owner, $super) {
+    owner = owner === VOID ? null : owner;
+    return updateNodeAtIndex($this, nodeIndex, positionMask, newNode, owner);
+  }
+  function removeNodeAtIndex($this, nodeIndex, positionMask) {
+    if ($this.pfz_1.length === 1)
+      return null;
+    var newBuffer = removeNodeAtIndex_0($this.pfz_1, nodeIndex);
+    return TrieNode_init_$Create$($this.mfz_1, $this.nfz_1 ^ positionMask, newBuffer);
+  }
+  function bufferMoveEntryToNode($this, keyIndex, positionMask, newKeyHash, newKey, newValue, shift, owner) {
+    var storedKey = keyAtIndex($this, keyIndex);
+    // Inline function 'kotlin.hashCode' call
+    var tmp1_elvis_lhs = storedKey == null ? null : hashCode(storedKey);
+    var storedKeyHash = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+    var storedValue = valueAtKeyIndex($this, keyIndex);
+    var newNode = makeNode($this, storedKeyHash, storedKey, storedValue, newKeyHash, newKey, newValue, shift + 5 | 0, owner);
+    var nodeIndex = $this.qg1(positionMask) + 1 | 0;
+    return replaceEntryWithNode($this.pfz_1, keyIndex, nodeIndex, newNode);
+  }
+  function moveEntryToNode($this, keyIndex, positionMask, newKeyHash, newKey, newValue, shift) {
+    var newBuffer = bufferMoveEntryToNode($this, keyIndex, positionMask, newKeyHash, newKey, newValue, shift, null);
+    return TrieNode_init_$Create$($this.mfz_1 ^ positionMask, $this.nfz_1 | positionMask, newBuffer);
+  }
+  function makeNode($this, keyHash1, key1, value1, keyHash2, key2, value2, shift, owner) {
+    if (shift > 30) {
+      // Inline function 'kotlin.arrayOf' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var tmp$ret$2 = [key1, value1, key2, value2];
+      return new TrieNode(0, 0, tmp$ret$2, owner);
+    }
+    var setBit1 = indexSegment(keyHash1, shift);
+    var setBit2 = indexSegment(keyHash2, shift);
+    if (!(setBit1 === setBit2)) {
+      var tmp;
+      if (setBit1 < setBit2) {
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        tmp = [key1, value1, key2, value2];
+      } else {
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        tmp = [key2, value2, key1, value1];
+      }
+      var nodeBuffer = tmp;
+      return new TrieNode(1 << setBit1 | 1 << setBit2, 0, nodeBuffer, owner);
+    }
+    var node = makeNode($this, keyHash1, key1, value1, keyHash2, key2, value2, shift + 5 | 0, owner);
+    var tmp_0 = 1 << setBit1;
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp$ret$11 = [node];
+    return new TrieNode(0, tmp_0, tmp$ret$11, owner);
+  }
+  function removeEntryAtIndex($this, keyIndex, positionMask) {
+    if ($this.pfz_1.length === 2)
+      return null;
+    var newBuffer = removeEntryAtIndex_0($this.pfz_1, keyIndex);
+    return TrieNode_init_$Create$($this.mfz_1 ^ positionMask, $this.nfz_1, newBuffer);
+  }
+  function collisionRemoveEntryAtIndex($this, i) {
+    if ($this.pfz_1.length === 2)
+      return null;
+    var newBuffer = removeEntryAtIndex_0($this.pfz_1, i);
+    return TrieNode_init_$Create$(0, 0, newBuffer);
+  }
+  function collisionKeyIndex($this, key) {
+    var progression = step(until(0, $this.pfz_1.length), 2);
+    var inductionVariable = progression.d1_1;
+    var last = progression.e1_1;
+    var step_0 = progression.f1_1;
+    if (step_0 > 0 && inductionVariable <= last || (step_0 < 0 && last <= inductionVariable))
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + step_0 | 0;
+        if (equals(key, keyAtIndex($this, i)))
+          return i;
+      }
+       while (!(i === last));
+    return -1;
+  }
+  function collisionContainsKey($this, key) {
+    return !(collisionKeyIndex($this, key) === -1);
+  }
+  function collisionGet($this, key) {
+    var keyIndex = collisionKeyIndex($this, key);
+    return !(keyIndex === -1) ? valueAtKeyIndex($this, keyIndex) : null;
+  }
+  function collisionPut($this, key, value) {
+    var keyIndex = collisionKeyIndex($this, key);
+    if (!(keyIndex === -1)) {
+      if (value === valueAtKeyIndex($this, keyIndex)) {
+        return null;
+      }
+      // Inline function 'kotlin.collections.copyOf' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var newBuffer = $this.pfz_1.slice();
+      newBuffer[keyIndex + 1 | 0] = value;
+      return asUpdateResult(TrieNode_init_$Create$(0, 0, newBuffer));
+    }
+    var newBuffer_0 = insertEntryAtIndex($this.pfz_1, 0, key, value);
+    return asInsertResult(TrieNode_init_$Create$(0, 0, newBuffer_0));
+  }
+  function collisionRemove($this, key) {
+    var keyIndex = collisionKeyIndex($this, key);
+    if (!(keyIndex === -1)) {
+      return collisionRemoveEntryAtIndex($this, keyIndex);
+    }
+    return $this;
+  }
+  function replaceNode($this, targetNode, newNode, nodeIndex, positionMask) {
+    return newNode == null ? removeNodeAtIndex($this, nodeIndex, positionMask) : !(targetNode === newNode) ? updateNodeAtIndex$default($this, nodeIndex, positionMask, newNode) : $this;
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+    var tmp = this;
+    // Inline function 'kotlin.emptyArray' call
+    var tmp$ret$0 = [];
+    tmp.efz_1 = TrieNode_init_$Create$(0, 0, tmp$ret$0);
+  }
+  var Companion_instance_0;
+  function Companion_getInstance_0() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function TrieNode(dataMap, nodeMap, buffer, ownedBy) {
+    Companion_getInstance_0();
+    this.mfz_1 = dataMap;
+    this.nfz_1 = nodeMap;
+    this.ofz_1 = ownedBy;
+    this.pfz_1 = buffer;
+  }
+  protoOf(TrieNode).wg0 = function () {
+    return countOneBits(this.mfz_1);
+  };
+  protoOf(TrieNode).rg1 = function (positionMask) {
+    return !((this.mfz_1 & positionMask) === 0);
+  };
+  protoOf(TrieNode).pg1 = function (positionMask) {
+    return imul(2, countOneBits(this.mfz_1 & (positionMask - 1 | 0)));
+  };
+  protoOf(TrieNode).qg1 = function (positionMask) {
+    return (this.pfz_1.length - 1 | 0) - countOneBits(this.nfz_1 & (positionMask - 1 | 0)) | 0;
+  };
+  protoOf(TrieNode).sg1 = function (nodeIndex) {
+    var tmp = this.pfz_1[nodeIndex];
+    return tmp instanceof TrieNode ? tmp : THROW_CCE();
+  };
+  protoOf(TrieNode).qfz = function (keyHash, key, shift) {
+    var keyPositionMask = 1 << indexSegment(keyHash, shift);
+    if (this.rg1(keyPositionMask)) {
+      return equals(key, keyAtIndex(this, this.pg1(keyPositionMask)));
+    }
+    if (hasNodeAt(this, keyPositionMask)) {
+      var targetNode = this.sg1(this.qg1(keyPositionMask));
+      if (shift === 30) {
+        return collisionContainsKey(targetNode, key);
+      }
+      return targetNode.qfz(keyHash, key, shift + 5 | 0);
+    }
+    return false;
+  };
+  protoOf(TrieNode).rfz = function (keyHash, key, shift) {
+    var keyPositionMask = 1 << indexSegment(keyHash, shift);
+    if (this.rg1(keyPositionMask)) {
+      var keyIndex = this.pg1(keyPositionMask);
+      if (equals(key, keyAtIndex(this, keyIndex))) {
+        return valueAtKeyIndex(this, keyIndex);
+      }
+      return null;
+    }
+    if (hasNodeAt(this, keyPositionMask)) {
+      var targetNode = this.sg1(this.qg1(keyPositionMask));
+      if (shift === 30) {
+        return collisionGet(targetNode, key);
+      }
+      return targetNode.rfz(keyHash, key, shift + 5 | 0);
+    }
+    return null;
+  };
+  protoOf(TrieNode).sfz = function (keyHash, key, value, shift) {
+    var keyPositionMask = 1 << indexSegment(keyHash, shift);
+    if (this.rg1(keyPositionMask)) {
+      var keyIndex = this.pg1(keyPositionMask);
+      if (equals(key, keyAtIndex(this, keyIndex))) {
+        if (valueAtKeyIndex(this, keyIndex) === value)
+          return null;
+        return asUpdateResult(updateValueAtIndex(this, keyIndex, value));
+      }
+      return asInsertResult(moveEntryToNode(this, keyIndex, keyPositionMask, keyHash, key, value, shift));
+    }
+    if (hasNodeAt(this, keyPositionMask)) {
+      var nodeIndex = this.qg1(keyPositionMask);
+      var targetNode = this.sg1(nodeIndex);
+      var tmp;
+      if (shift === 30) {
+        var tmp0_elvis_lhs = collisionPut(targetNode, key, value);
+        var tmp_0;
+        if (tmp0_elvis_lhs == null) {
+          return null;
+        } else {
+          tmp_0 = tmp0_elvis_lhs;
+        }
+        tmp = tmp_0;
+      } else {
+        var tmp1_elvis_lhs = targetNode.sfz(keyHash, key, value, shift + 5 | 0);
+        var tmp_1;
+        if (tmp1_elvis_lhs == null) {
+          return null;
+        } else {
+          tmp_1 = tmp1_elvis_lhs;
+        }
+        tmp = tmp_1;
+      }
+      var putResult = tmp;
+      // Inline function 'kotlinx.collections.immutable.implementations.immutableMap.ModificationResult.replaceNode' call
+      // Inline function 'kotlin.apply' call
+      var tmp_2 = putResult;
+      var node = putResult.tfz_1;
+      tmp_2.tfz_1 = updateNodeAtIndex$default(this, nodeIndex, keyPositionMask, node);
+      return putResult;
+    }
+    return asInsertResult(insertEntryAt(this, keyPositionMask, key, value));
+  };
+  protoOf(TrieNode).vfz = function (keyHash, key, shift) {
+    var keyPositionMask = 1 << indexSegment(keyHash, shift);
+    if (this.rg1(keyPositionMask)) {
+      var keyIndex = this.pg1(keyPositionMask);
+      if (equals(key, keyAtIndex(this, keyIndex))) {
+        return removeEntryAtIndex(this, keyIndex, keyPositionMask);
+      }
+      return this;
+    }
+    if (hasNodeAt(this, keyPositionMask)) {
+      var nodeIndex = this.qg1(keyPositionMask);
+      var targetNode = this.sg1(nodeIndex);
+      var tmp;
+      if (shift === 30) {
+        tmp = collisionRemove(targetNode, key);
+      } else {
+        tmp = targetNode.vfz(keyHash, key, shift + 5 | 0);
+      }
+      var newNode = tmp;
+      return replaceNode(this, targetNode, newNode, nodeIndex, keyPositionMask);
+    }
+    return this;
+  };
+  protoOf(TrieNode).bg0 = function (that, equalityComparator) {
+    if (this === that)
+      return true;
+    if (!(this.mfz_1 === that.mfz_1) || !(this.nfz_1 === that.nfz_1))
+      return false;
+    if (this.mfz_1 === 0 && this.nfz_1 === 0) {
+      if (!(this.pfz_1.length === that.pfz_1.length))
+        return false;
+      var tmp0 = step(until(0, this.pfz_1.length), 2);
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var tmp;
+        if (isInterface(tmp0, Collection)) {
+          tmp = tmp0.m();
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var inductionVariable = tmp0.d1_1;
+        var last = tmp0.e1_1;
+        var step_0 = tmp0.f1_1;
+        if (step_0 > 0 && inductionVariable <= last || (step_0 < 0 && last <= inductionVariable))
+          do {
+            var element = inductionVariable;
+            inductionVariable = inductionVariable + step_0 | 0;
+            var i = element;
+            var thatKey = keyAtIndex(that, i);
+            var thatValue = valueAtKeyIndex(that, i);
+            var keyIndex = collisionKeyIndex(this, thatKey);
+            var tmp_0;
+            if (!(keyIndex === -1)) {
+              var value = valueAtKeyIndex(this, keyIndex);
+              tmp_0 = equalityComparator(value, thatValue);
+            } else {
+              tmp_0 = false;
+            }
+            if (!tmp_0) {
+              tmp$ret$0 = false;
+              break $l$block_0;
+            }
+          }
+           while (!(element === last));
+        tmp$ret$0 = true;
+      }
+      return tmp$ret$0;
+    }
+    var valueSize = imul(countOneBits(this.mfz_1), 2);
+    var progression = step(until(0, valueSize), 2);
+    var inductionVariable_0 = progression.d1_1;
+    var last_0 = progression.e1_1;
+    var step_1 = progression.f1_1;
+    if (step_1 > 0 && inductionVariable_0 <= last_0 || (step_1 < 0 && last_0 <= inductionVariable_0))
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + step_1 | 0;
+        if (!equals(keyAtIndex(this, i_0), keyAtIndex(that, i_0)))
+          return false;
+        if (!equalityComparator(valueAtKeyIndex(this, i_0), valueAtKeyIndex(that, i_0)))
+          return false;
+      }
+       while (!(i_0 === last_0));
+    var inductionVariable_1 = valueSize;
+    var last_1 = this.pfz_1.length;
+    if (inductionVariable_1 < last_1)
+      do {
+        var i_1 = inductionVariable_1;
+        inductionVariable_1 = inductionVariable_1 + 1 | 0;
+        if (!this.sg1(i_1).bg0(that.sg1(i_1), equalityComparator))
+          return false;
+      }
+       while (inductionVariable_1 < last_1);
+    return true;
+  };
+  function insertEntryAtIndex(_this__u8e3s4, keyIndex, key, value) {
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = _this__u8e3s4.length + 2 | 0;
+    var newBuffer = Array(size);
+    // Inline function 'kotlin.collections.copyInto' call
+    arrayCopy(_this__u8e3s4, newBuffer, 0, 0, keyIndex);
+    var tmp4 = keyIndex + 2 | 0;
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = _this__u8e3s4.length;
+    arrayCopy(_this__u8e3s4, newBuffer, tmp4, keyIndex, endIndex);
+    newBuffer[keyIndex] = key;
+    newBuffer[keyIndex + 1 | 0] = value;
+    return newBuffer;
+  }
+  function replaceNodeWithEntry(_this__u8e3s4, nodeIndex, keyIndex, key, value) {
+    var newBuffer = copyOf(_this__u8e3s4, _this__u8e3s4.length + 1 | 0);
+    var tmp4 = nodeIndex + 2 | 0;
+    var tmp6 = nodeIndex + 1 | 0;
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = _this__u8e3s4.length;
+    arrayCopy(newBuffer, newBuffer, tmp4, tmp6, endIndex);
+    // Inline function 'kotlin.collections.copyInto' call
+    var destinationOffset = keyIndex + 2 | 0;
+    arrayCopy(newBuffer, newBuffer, destinationOffset, keyIndex, nodeIndex);
+    newBuffer[keyIndex] = key;
+    newBuffer[keyIndex + 1 | 0] = value;
+    return newBuffer;
+  }
+  function removeNodeAtIndex_0(_this__u8e3s4, nodeIndex) {
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = _this__u8e3s4.length - 1 | 0;
+    var newBuffer = Array(size);
+    // Inline function 'kotlin.collections.copyInto' call
+    arrayCopy(_this__u8e3s4, newBuffer, 0, 0, nodeIndex);
+    var tmp6 = nodeIndex + 1 | 0;
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = _this__u8e3s4.length;
+    arrayCopy(_this__u8e3s4, newBuffer, nodeIndex, tmp6, endIndex);
+    return newBuffer;
+  }
+  function replaceEntryWithNode(_this__u8e3s4, keyIndex, nodeIndex, newNode) {
+    var newNodeIndex = nodeIndex - 2 | 0;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = (_this__u8e3s4.length - 2 | 0) + 1 | 0;
+    var newBuffer = Array(size);
+    // Inline function 'kotlin.collections.copyInto' call
+    arrayCopy(_this__u8e3s4, newBuffer, 0, 0, keyIndex);
+    // Inline function 'kotlin.collections.copyInto' call
+    var startIndex = keyIndex + 2 | 0;
+    arrayCopy(_this__u8e3s4, newBuffer, keyIndex, startIndex, nodeIndex);
+    newBuffer[newNodeIndex] = newNode;
+    var tmp4 = newNodeIndex + 1 | 0;
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = _this__u8e3s4.length;
+    arrayCopy(_this__u8e3s4, newBuffer, tmp4, nodeIndex, endIndex);
+    return newBuffer;
+  }
+  function indexSegment(index, shift) {
+    return index >> shift & 31;
+  }
+  function removeEntryAtIndex_0(_this__u8e3s4, keyIndex) {
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = _this__u8e3s4.length - 2 | 0;
+    var newBuffer = Array(size);
+    // Inline function 'kotlin.collections.copyInto' call
+    arrayCopy(_this__u8e3s4, newBuffer, 0, 0, keyIndex);
+    var tmp6 = keyIndex + 2 | 0;
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = _this__u8e3s4.length;
+    arrayCopy(_this__u8e3s4, newBuffer, keyIndex, tmp6, endIndex);
+    return newBuffer;
+  }
+  function createEntries_0($this) {
+    return new PersistentOrderedMapEntries($this);
+  }
+  function Companion_1() {
+    Companion_instance_1 = this;
+    this.bfz_1 = new PersistentOrderedMap(EndOfChain_instance, EndOfChain_instance, Companion_getInstance().cfz());
+  }
+  protoOf(Companion_1).cfz = function () {
+    var tmp = this.bfz_1;
+    return tmp instanceof PersistentOrderedMap ? tmp : THROW_CCE();
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_1() {
+    if (Companion_instance_1 == null)
+      new Companion_1();
+    return Companion_instance_1;
+  }
+  function PersistentOrderedMap$equals$lambda(a, b) {
+    return equals(a.ffz_1, b.ffz_1);
+  }
+  function PersistentOrderedMap$equals$lambda_0(a, b) {
+    return equals(a.ffz_1, b.ffz_1);
+  }
+  function PersistentOrderedMap$equals$lambda_1(a, b) {
+    return equals(a.ffz_1, b);
+  }
+  function PersistentOrderedMap$equals$lambda_2(a, b) {
+    return equals(a.ffz_1, b);
+  }
+  function PersistentOrderedMap(firstKey, lastKey, hashMap) {
+    Companion_getInstance_1();
+    AbstractMap.call(this);
+    this.jg0_1 = firstKey;
+    this.kg0_1 = lastKey;
+    this.lg0_1 = hashMap;
+  }
+  protoOf(PersistentOrderedMap).s = function () {
+    return this.lg0_1.lfz_1;
+  };
+  protoOf(PersistentOrderedMap).k2 = function () {
+    return new PersistentOrderedMapKeys(this);
+  };
+  protoOf(PersistentOrderedMap).l2 = function () {
+    return new PersistentOrderedMapValues(this);
+  };
+  protoOf(PersistentOrderedMap).z = function () {
+    return createEntries_0(this);
+  };
+  protoOf(PersistentOrderedMap).h2 = function (key) {
+    return this.lg0_1.h2(key);
+  };
+  protoOf(PersistentOrderedMap).j2 = function (key) {
+    var tmp0_safe_receiver = this.lg0_1.j2(key);
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.ffz_1;
+  };
+  protoOf(PersistentOrderedMap).r2 = function (key, value) {
+    if (this.m()) {
+      var newMap = this.lg0_1.r2(key, LinkedValue_init_$Create$(value));
+      return new PersistentOrderedMap(key, key, newMap);
+    }
+    var links = this.lg0_1.j2(key);
+    if (!(links == null)) {
+      if (links.ffz_1 === value) {
+        return this;
+      }
+      var newMap_0 = this.lg0_1.r2(key, links.tg1(value));
+      return new PersistentOrderedMap(this.jg0_1, this.kg0_1, newMap_0);
+    }
+    var tmp = this.kg0_1;
+    var lastKey = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+    var lastLinks = ensureNotNull(this.lg0_1.j2(lastKey));
+    var newMap_1 = this.lg0_1.r2(lastKey, lastLinks.ug1(key)).r2(key, LinkedValue_init_$Create$_0(value, lastKey));
+    return new PersistentOrderedMap(this.jg0_1, key, newMap_1);
+  };
+  protoOf(PersistentOrderedMap).s2 = function (key) {
+    var tmp0_elvis_lhs = this.lg0_1.j2(key);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return this;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var links = tmp;
+    var newMap = this.lg0_1.s2(key);
+    if (links.vg1()) {
+      var tmp0 = newMap;
+      // Inline function 'kotlin.collections.get' call
+      var key_0 = links.gfz_1;
+      var tmp$ret$0 = (isInterface(tmp0, KtMap) ? tmp0 : THROW_CCE()).j2(key_0);
+      var previousLinks = ensureNotNull(tmp$ret$0);
+      var tmp_0 = newMap;
+      var tmp_1 = links.gfz_1;
+      newMap = tmp_0.r2((tmp_1 == null ? true : !(tmp_1 == null)) ? tmp_1 : THROW_CCE(), previousLinks.ug1(links.hfz_1));
+    }
+    if (links.xg1()) {
+      var tmp0_0 = newMap;
+      // Inline function 'kotlin.collections.get' call
+      var key_1 = links.hfz_1;
+      var tmp$ret$1 = (isInterface(tmp0_0, KtMap) ? tmp0_0 : THROW_CCE()).j2(key_1);
+      var nextLinks = ensureNotNull(tmp$ret$1);
+      var tmp_2 = newMap;
+      var tmp_3 = links.hfz_1;
+      newMap = tmp_2.r2((tmp_3 == null ? true : !(tmp_3 == null)) ? tmp_3 : THROW_CCE(), nextLinks.wg1(links.gfz_1));
+    }
+    var newFirstKey = !links.vg1() ? links.hfz_1 : this.jg0_1;
+    var newLastKey = !links.xg1() ? links.gfz_1 : this.kg0_1;
+    return new PersistentOrderedMap(newFirstKey, newLastKey, newMap);
+  };
+  protoOf(PersistentOrderedMap).equals = function (other) {
+    if (other === this)
+      return true;
+    if (!(!(other == null) ? isInterface(other, KtMap) : false))
+      return false;
+    if (!(this.s() === other.s()))
+      return false;
+    var tmp;
+    if (other instanceof PersistentOrderedMap) {
+      tmp = this.lg0_1.kfz_1.bg0(other.lg0_1.kfz_1, PersistentOrderedMap$equals$lambda);
+    } else {
+      if (other instanceof PersistentOrderedMapBuilder) {
+        var tmp_0 = other.gg0_1.ag0_1;
+        tmp = this.lg0_1.kfz_1.bg0(tmp_0, PersistentOrderedMap$equals$lambda_0);
+      } else {
+        if (other instanceof PersistentHashMap) {
+          tmp = this.lg0_1.kfz_1.bg0(other.kfz_1, PersistentOrderedMap$equals$lambda_1);
+        } else {
+          if (other instanceof PersistentHashMapBuilder) {
+            var tmp_1 = other.ag0_1;
+            tmp = this.lg0_1.kfz_1.bg0(tmp_1, PersistentOrderedMap$equals$lambda_2);
+          } else {
+            tmp = protoOf(AbstractMap).equals.call(this, other);
+          }
+        }
+      }
+    }
+    return tmp;
+  };
+  protoOf(PersistentOrderedMap).hashCode = function () {
+    return protoOf(AbstractMap).hashCode.call(this);
+  };
+  function LinkedValue_init_$Init$(value, $this) {
+    LinkedValue.call($this, value, EndOfChain_instance, EndOfChain_instance);
+    return $this;
+  }
+  function LinkedValue_init_$Create$(value) {
+    return LinkedValue_init_$Init$(value, objectCreate(protoOf(LinkedValue)));
+  }
+  function LinkedValue_init_$Init$_0(value, previous, $this) {
+    LinkedValue.call($this, value, previous, EndOfChain_instance);
+    return $this;
+  }
+  function LinkedValue_init_$Create$_0(value, previous) {
+    return LinkedValue_init_$Init$_0(value, previous, objectCreate(protoOf(LinkedValue)));
+  }
+  function LinkedValue(value, previous, next) {
+    this.ffz_1 = value;
+    this.gfz_1 = previous;
+    this.hfz_1 = next;
+  }
+  protoOf(LinkedValue).tg1 = function (newValue) {
+    return new LinkedValue(newValue, this.gfz_1, this.hfz_1);
+  };
+  protoOf(LinkedValue).wg1 = function (newPrevious) {
+    return new LinkedValue(this.ffz_1, newPrevious, this.hfz_1);
+  };
+  protoOf(LinkedValue).ug1 = function (newNext) {
+    return new LinkedValue(this.ffz_1, this.gfz_1, newNext);
+  };
+  protoOf(LinkedValue).xg1 = function () {
+    return !(this.hfz_1 === EndOfChain_instance);
+  };
+  protoOf(LinkedValue).vg1 = function () {
+    return !(this.gfz_1 === EndOfChain_instance);
+  };
+  function PersistentOrderedMapBuilder() {
+  }
+  function PersistentOrderedMapKeysIterator(map) {
+    this.yg1_1 = new PersistentOrderedMapLinksIterator(map.jg0_1, map.lg0_1);
+  }
+  protoOf(PersistentOrderedMapKeysIterator).q = function () {
+    return this.yg1_1.q();
+  };
+  protoOf(PersistentOrderedMapKeysIterator).r = function () {
+    var tmp = this.yg1_1.zg1_1;
+    var nextKey = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+    this.yg1_1.r();
+    return nextKey;
+  };
+  function PersistentOrderedMapValuesIterator(map) {
+    this.cg2_1 = new PersistentOrderedMapLinksIterator(map.jg0_1, map.lg0_1);
+  }
+  protoOf(PersistentOrderedMapValuesIterator).q = function () {
+    return this.cg2_1.q();
+  };
+  protoOf(PersistentOrderedMapValuesIterator).r = function () {
+    return this.cg2_1.r().ffz_1;
+  };
+  function PersistentOrderedMapEntriesIterator(map) {
+    this.dg2_1 = new PersistentOrderedMapLinksIterator(map.jg0_1, map.lg0_1);
+  }
+  protoOf(PersistentOrderedMapEntriesIterator).q = function () {
+    return this.dg2_1.q();
+  };
+  protoOf(PersistentOrderedMapEntriesIterator).r = function () {
+    var tmp = this.dg2_1.zg1_1;
+    var nextKey = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+    var nextValue = this.dg2_1.r().ffz_1;
+    return new MapEntry(nextKey, nextValue);
+  };
+  function PersistentOrderedMapLinksIterator(nextKey, hashMap) {
+    this.zg1_1 = nextKey;
+    this.ag2_1 = hashMap;
+    this.bg2_1 = 0;
+  }
+  protoOf(PersistentOrderedMapLinksIterator).q = function () {
+    return this.bg2_1 < this.ag2_1.s();
+  };
+  protoOf(PersistentOrderedMapLinksIterator).r = function () {
+    if (!this.q()) {
+      throw NoSuchElementException_init_$Create$();
+    }
+    var tmp0 = this.ag2_1;
+    var tmp = this.zg1_1;
+    // Inline function 'kotlin.collections.getOrElse' call
+    var key = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+    var tmp0_elvis_lhs = tmp0.j2(key);
+    var tmp_0;
+    if (tmp0_elvis_lhs == null) {
+      throw ConcurrentModificationException_init_$Create$('Hash code of a key (' + toString(this.zg1_1) + ') has changed after it was added to the persistent map.');
+    } else {
+      tmp_0 = tmp0_elvis_lhs;
+    }
+    var result = tmp_0;
+    this.bg2_1 = this.bg2_1 + 1 | 0;
+    this.zg1_1 = result.hfz_1;
+    return result;
+  };
+  function PersistentOrderedMapKeys(map) {
+    AbstractSet.call(this);
+    this.eg2_1 = map;
+  }
+  protoOf(PersistentOrderedMapKeys).s = function () {
+    return this.eg2_1.s();
+  };
+  protoOf(PersistentOrderedMapKeys).q6 = function (element) {
+    return this.eg2_1.h2(element);
+  };
+  protoOf(PersistentOrderedMapKeys).w = function (element) {
+    if (!(element == null ? true : !(element == null)))
+      return false;
+    return this.q6((element == null ? true : !(element == null)) ? element : THROW_CCE());
+  };
+  protoOf(PersistentOrderedMapKeys).p = function () {
+    return new PersistentOrderedMapKeysIterator(this.eg2_1);
+  };
+  function PersistentOrderedMapValues(map) {
+    AbstractCollection.call(this);
+    this.fg2_1 = map;
+  }
+  protoOf(PersistentOrderedMapValues).s = function () {
+    return this.fg2_1.s();
+  };
+  protoOf(PersistentOrderedMapValues).v6 = function (element) {
+    return this.fg2_1.i2(element);
+  };
+  protoOf(PersistentOrderedMapValues).w = function (element) {
+    if (!(element == null ? true : !(element == null)))
+      return false;
+    return this.v6((element == null ? true : !(element == null)) ? element : THROW_CCE());
+  };
+  protoOf(PersistentOrderedMapValues).p = function () {
+    return new PersistentOrderedMapValuesIterator(this.fg2_1);
+  };
+  function PersistentOrderedMapEntries(map) {
+    AbstractSet.call(this);
+    this.gg2_1 = map;
+  }
+  protoOf(PersistentOrderedMapEntries).s = function () {
+    return this.gg2_1.s();
+  };
+  protoOf(PersistentOrderedMapEntries).ng1 = function (element) {
+    return MapImplementation_instance.og1(this.gg2_1, element);
+  };
+  protoOf(PersistentOrderedMapEntries).w = function (element) {
+    if (!(!(element == null) ? isInterface(element, Entry) : false))
+      return false;
+    return this.ng1((!(element == null) ? isInterface(element, Entry) : false) ? element : THROW_CCE());
+  };
+  protoOf(PersistentOrderedMapEntries).p = function () {
+    return new PersistentOrderedMapEntriesIterator(this.gg2_1);
+  };
+  function EndOfChain() {
+  }
+  var EndOfChain_instance;
+  function EndOfChain_getInstance() {
+    return EndOfChain_instance;
+  }
+  function MapImplementation() {
+  }
+  protoOf(MapImplementation).og1 = function (map, element) {
+    var tmp = !(element == null) ? element : THROW_CCE();
+    if (!(!(tmp == null) ? isInterface(tmp, Entry) : false))
+      return false;
+    var tmp0_safe_receiver = map.j2(element.a1());
+    var tmp_0;
+    if (tmp0_safe_receiver == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = equals(tmp0_safe_receiver, element.b1());
+    }
+    var tmp1_elvis_lhs = tmp_0;
+    return tmp1_elvis_lhs == null ? element.b1() == null && map.h2(element.a1()) : tmp1_elvis_lhs;
+  };
+  var MapImplementation_instance;
+  function MapImplementation_getInstance() {
+    return MapImplementation_instance;
+  }
+  function assert(condition) {
+    if (!condition) {
+      throw AssertionError_init_$Create$('Assertion failed');
+    }
+  }
+  //region block: init
+  EndOfChain_instance = new EndOfChain();
+  MapImplementation_instance = new MapImplementation();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = persistentMapOf;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=Kotlin-Immutable-Collections-kotlinx-collections-immutable.js.map