@continuous-excellence/coupling-cli 0.0.0

package/kotlin/kotlin-kotlin-stdlib/kotlin/collections/InternalHashMap.mjs

@@ -0,0 +1,748 @@
+import {
+  coerceAtLeast2bkz8m9ik7hep as coerceAtLeast,
+  coerceAtMost322komnqp70ag as coerceAtMost,
+} from '../ranges/_Ranges.mjs';
+import { takeHighestOneBit9p7rdtda63bc as takeHighestOneBit } from '../NumbersJs.mjs';
+import {
+  ConcurrentModificationException3974vl9oonkcj as ConcurrentModificationException,
+  RuntimeException1r3t0zl97011n as RuntimeException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  NoSuchElementException679xzhnp5bpj as NoSuchElementException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException,
+} from '../exceptions.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { Companion_instance1a0yry1hi33tg as Companion_instance } from './AbstractList.mjs';
+import {
+  copyOfUninitializedElements3uqjltwtgc0ej as copyOfUninitializedElements,
+  arrayOfUninitializedElementsg6b068zrcm8j as arrayOfUninitializedElements,
+  resetRangeiqi6axdujnmn as resetRange,
+  resetAt1d0jjdeh7nn7m as resetAt,
+} from './ArrayFunctions.mjs';
+import { copyOf3rutauicler23 as copyOf } from './_ArraysJs.mjs';
+import {
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+  createThis2j2avj17cvnv2 as createThis,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../js/coreRuntime.mjs';
+import {
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../hacks.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx } from '../Char.mjs';
+import {
+  Entry2xmjmyutzoq3p as Entry,
+  KtMap140uvy3s5zad8 as KtMap,
+} from './Collections.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../js/typeCheckUtils.mjs';
+import { toString30pk9tzaqopn as toString_0 } from '../Library.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../text/StringBuilderJs.mjs';
+import {
+  containsAllEntries1q58uduc9e3y6 as containsAllEntries,
+  InternalMap26d9hvxb47nvz as InternalMap,
+} from './InternalMap.mjs';
+//region block: imports
+var imul = Math.imul;
+var clz32 = Math.clz32;
+//endregion
+//region block: pre-declaration
+//endregion
+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.ab_1.h9_1 === $this.cb_1))
+    throw ConcurrentModificationException().za('The backing map has been modified after this entry was obtained.');
+}
+function _get_capacity__a9k9f3($this) {
+  return $this.a9_1.length;
+}
+function _get_hashSize__tftcho($this) {
+  return $this.d9_1.length;
+}
+function registerModification($this) {
+  $this.h9_1 = $this.h9_1 + 1 | 0;
+}
+function ensureExtraCapacity($this, n) {
+  if (shouldCompact($this, n)) {
+    compact($this, true);
+  } else {
+    ensureCapacity($this, $this.f9_1 + n | 0);
+  }
+}
+function shouldCompact($this, extraCapacity) {
+  var spareCapacity = _get_capacity__a9k9f3($this) - $this.f9_1 | 0;
+  var gaps = $this.f9_1 - $this.v2() | 0;
+  return spareCapacity < extraCapacity && (gaps + spareCapacity | 0) >= extraCapacity && gaps >= (_get_capacity__a9k9f3($this) / 4 | 0);
+}
+function ensureCapacity($this, minCapacity) {
+  if (minCapacity < 0)
+    throw RuntimeException().db('too many elements');
+  if (minCapacity > _get_capacity__a9k9f3($this)) {
+    var newSize = Companion_instance.eb(_get_capacity__a9k9f3($this), minCapacity);
+    $this.a9_1 = copyOfUninitializedElements($this.a9_1, newSize);
+    var tmp = $this;
+    var tmp0_safe_receiver = $this.b9_1;
+    tmp.b9_1 = tmp0_safe_receiver == null ? null : copyOfUninitializedElements(tmp0_safe_receiver, newSize);
+    $this.c9_1 = copyOf($this.c9_1, newSize);
+    var newHashSize = computeHashSize(Companion_instance_0, newSize);
+    if (newHashSize > _get_hashSize__tftcho($this)) {
+      rehash($this, newHashSize);
+    }
+  }
+}
+function allocateValuesArray($this) {
+  var curValuesArray = $this.b9_1;
+  if (!(curValuesArray == null))
+    return curValuesArray;
+  var newValuesArray = arrayOfUninitializedElements(_get_capacity__a9k9f3($this));
+  $this.b9_1 = newValuesArray;
+  return newValuesArray;
+}
+function hash($this, key) {
+  return key == null ? 0 : imul(hashCode(key), -1640531527) >>> $this.g9_1 | 0;
+}
+function compact($this, updateHashArray) {
+  var i = 0;
+  var j = 0;
+  var valuesArray = $this.b9_1;
+  while (i < $this.f9_1) {
+    var hash = $this.c9_1[i];
+    if (hash >= 0) {
+      $this.a9_1[j] = $this.a9_1[i];
+      if (!(valuesArray == null)) {
+        valuesArray[j] = valuesArray[i];
+      }
+      if (updateHashArray) {
+        $this.c9_1[j] = hash;
+        $this.d9_1[hash] = j + 1 | 0;
+      }
+      j = j + 1 | 0;
+    }
+    i = i + 1 | 0;
+  }
+  resetRange($this.a9_1, j, $this.f9_1);
+  if (valuesArray == null)
+    null;
+  else {
+    resetRange(valuesArray, j, $this.f9_1);
+  }
+  $this.f9_1 = j;
+}
+function rehash($this, newHashSize) {
+  registerModification($this);
+  if ($this.f9_1 > $this.i9_1) {
+    compact($this, false);
+  }
+  $this.d9_1 = new Int32Array(newHashSize);
+  $this.g9_1 = computeShift(Companion_instance_0, newHashSize);
+  var i = 0;
+  while (i < $this.f9_1) {
+    var _unary__edvuaz = i;
+    i = _unary__edvuaz + 1 | 0;
+    if (!putRehash($this, _unary__edvuaz)) {
+      throw IllegalStateException().o('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.a9_1[i]);
+  var probesLeft = $this.e9_1;
+  while (true) {
+    var index = $this.d9_1[hash_0];
+    if (index === 0) {
+      $this.d9_1[hash_0] = i + 1 | 0;
+      $this.c9_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.e9_1;
+  while (true) {
+    var index = $this.d9_1[hash_0];
+    if (index === 0)
+      return -1;
+    if (index > 0 && equals($this.a9_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 findValue($this, value) {
+  var i = $this.f9_1;
+  $l$loop: while (true) {
+    i = i - 1 | 0;
+    if (!(i >= 0)) {
+      break $l$loop;
+    }
+    if ($this.c9_1[i] >= 0 && equals(ensureNotNull($this.b9_1)[i], value))
+      return i;
+  }
+  return -1;
+}
+function addKey($this, key) {
+  $this.z9();
+  retry: while (true) {
+    var hash_0 = hash($this, key);
+    var tentativeMaxProbeDistance = coerceAtMost(imul($this.e9_1, 2), _get_hashSize__tftcho($this) / 2 | 0);
+    var probeDistance = 0;
+    while (true) {
+      var index = $this.d9_1[hash_0];
+      if (index <= 0) {
+        if ($this.f9_1 >= _get_capacity__a9k9f3($this)) {
+          ensureExtraCapacity($this, 1);
+          continue retry;
+        }
+        var _unary__edvuaz = $this.f9_1;
+        $this.f9_1 = _unary__edvuaz + 1 | 0;
+        var putIndex = _unary__edvuaz;
+        $this.a9_1[putIndex] = key;
+        $this.c9_1[putIndex] = hash_0;
+        $this.d9_1[hash_0] = putIndex + 1 | 0;
+        $this.i9_1 = $this.i9_1 + 1 | 0;
+        registerModification($this);
+        if (probeDistance > $this.e9_1)
+          $this.e9_1 = probeDistance;
+        return putIndex;
+      }
+      if (equals($this.a9_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 removeEntryAt($this, index) {
+  resetAt($this.a9_1, index);
+  var tmp0_safe_receiver = $this.b9_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    resetAt(tmp0_safe_receiver, index);
+  }
+  removeHashAt($this, $this.c9_1[index]);
+  $this.c9_1[index] = -1;
+  $this.i9_1 = $this.i9_1 - 1 | 0;
+  registerModification($this);
+}
+function removeHashAt($this, removedHash) {
+  var hash_0 = removedHash;
+  var hole = removedHash;
+  var probeDistance = 0;
+  var patchAttemptsLeft = coerceAtMost(imul($this.e9_1, 2), _get_hashSize__tftcho($this) / 2 | 0);
+  while (true) {
+    var _unary__edvuaz = hash_0;
+    hash_0 = _unary__edvuaz - 1 | 0;
+    if (_unary__edvuaz === 0)
+      hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+    probeDistance = probeDistance + 1 | 0;
+    if (probeDistance > $this.e9_1) {
+      $this.d9_1[hole] = 0;
+      return Unit_instance;
+    }
+    var index = $this.d9_1[hash_0];
+    if (index === 0) {
+      $this.d9_1[hole] = 0;
+      return Unit_instance;
+    }
+    if (index < 0) {
+      $this.d9_1[hole] = -1;
+      hole = hash_0;
+      probeDistance = 0;
+    } else {
+      var otherHash = hash($this, $this.a9_1[index - 1 | 0]);
+      if (((otherHash - hash_0 | 0) & (_get_hashSize__tftcho($this) - 1 | 0)) >= probeDistance) {
+        $this.d9_1[hole] = index;
+        $this.c9_1[index - 1 | 0] = hole;
+        hole = hash_0;
+        probeDistance = 0;
+      }
+    }
+    patchAttemptsLeft = patchAttemptsLeft - 1 | 0;
+    if (patchAttemptsLeft < 0) {
+      $this.d9_1[hole] = -1;
+      return Unit_instance;
+    }
+  }
+}
+function contentEquals($this, other) {
+  return $this.i9_1 === other.v2() && $this.ma(other.e3());
+}
+function putEntry($this, entry) {
+  var index = addKey($this, entry.f3());
+  var valuesArray = allocateValuesArray($this);
+  if (index >= 0) {
+    valuesArray[index] = entry.g3();
+    return true;
+  }
+  var oldValue = valuesArray[(-index | 0) - 1 | 0];
+  if (!equals(entry.g3(), oldValue)) {
+    valuesArray[(-index | 0) - 1 | 0] = entry.g3();
+    return true;
+  }
+  return false;
+}
+function putAllEntries($this, from) {
+  if (from.o1())
+    return false;
+  ensureExtraCapacity($this, from.v2());
+  var it = from.q1();
+  var updated = false;
+  while (it.r1()) {
+    if (putEntry($this, it.s1()))
+      updated = true;
+  }
+  return updated;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        this.fb_1 = -1640531527;
+        this.gb_1 = 8;
+        this.hb_1 = 2;
+        this.ib_1 = -1;
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  return Companion_instance_0;
+}
+var ItrClass;
+function Itr() {
+  if (ItrClass === VOID) {
+    class $ {
+      constructor(map) {
+        this.jb_1 = map;
+        this.kb_1 = 0;
+        this.lb_1 = -1;
+        this.mb_1 = this.jb_1.h9_1;
+        this.nb();
+      }
+      nb() {
+        while (this.kb_1 < this.jb_1.f9_1 && this.jb_1.c9_1[this.kb_1] < 0) {
+          this.kb_1 = this.kb_1 + 1 | 0;
+        }
+      }
+      r1() {
+        return this.kb_1 < this.jb_1.f9_1;
+      }
+      s6() {
+        this.ob();
+        // Inline function 'kotlin.check' call
+        if (!!(this.lb_1 === -1)) {
+          var message = 'Call next() before removing element from the iterator.';
+          throw IllegalStateException().o(toString(message));
+        }
+        this.jb_1.z9();
+        removeEntryAt(this.jb_1, this.lb_1);
+        this.lb_1 = -1;
+        this.mb_1 = this.jb_1.h9_1;
+      }
+      ob() {
+        if (!(this.jb_1.h9_1 === this.mb_1))
+          throw ConcurrentModificationException().pb();
+      }
+    }
+    initMetadataForClass($, 'Itr');
+    ItrClass = $;
+  }
+  return ItrClass;
+}
+var KeysItrClass;
+function KeysItr() {
+  if (KeysItrClass === VOID) {
+    class $ extends Itr() {
+      s1() {
+        this.ob();
+        if (this.kb_1 >= this.jb_1.f9_1)
+          throw NoSuchElementException().w6();
+        var tmp = this;
+        var _unary__edvuaz = this.kb_1;
+        this.kb_1 = _unary__edvuaz + 1 | 0;
+        tmp.lb_1 = _unary__edvuaz;
+        var result = this.jb_1.a9_1[this.lb_1];
+        this.nb();
+        return result;
+      }
+    }
+    initMetadataForClass($, 'KeysItr');
+    KeysItrClass = $;
+  }
+  return KeysItrClass;
+}
+var ValuesItrClass;
+function ValuesItr() {
+  if (ValuesItrClass === VOID) {
+    class $ extends Itr() {
+      s1() {
+        this.ob();
+        if (this.kb_1 >= this.jb_1.f9_1)
+          throw NoSuchElementException().w6();
+        var tmp = this;
+        var _unary__edvuaz = this.kb_1;
+        this.kb_1 = _unary__edvuaz + 1 | 0;
+        tmp.lb_1 = _unary__edvuaz;
+        var result = ensureNotNull(this.jb_1.b9_1)[this.lb_1];
+        this.nb();
+        return result;
+      }
+    }
+    initMetadataForClass($, 'ValuesItr');
+    ValuesItrClass = $;
+  }
+  return ValuesItrClass;
+}
+var EntriesItrClass;
+function EntriesItr() {
+  if (EntriesItrClass === VOID) {
+    class $ extends Itr() {
+      s1() {
+        this.ob();
+        if (this.kb_1 >= this.jb_1.f9_1)
+          throw NoSuchElementException().w6();
+        var tmp = this;
+        var _unary__edvuaz = this.kb_1;
+        this.kb_1 = _unary__edvuaz + 1 | 0;
+        tmp.lb_1 = _unary__edvuaz;
+        var result = new (EntryRef())(this.jb_1, this.lb_1);
+        this.nb();
+        return result;
+      }
+      cc() {
+        if (this.kb_1 >= this.jb_1.f9_1)
+          throw NoSuchElementException().w6();
+        var tmp = this;
+        var _unary__edvuaz = this.kb_1;
+        this.kb_1 = _unary__edvuaz + 1 | 0;
+        tmp.lb_1 = _unary__edvuaz;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver = this.jb_1.a9_1[this.lb_1];
+        var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(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.jb_1.b9_1)[this.lb_1];
+        var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+        var result = tmp_0 ^ (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0);
+        this.nb();
+        return result;
+      }
+      dc(sb) {
+        if (this.kb_1 >= this.jb_1.f9_1)
+          throw NoSuchElementException().w6();
+        var tmp = this;
+        var _unary__edvuaz = this.kb_1;
+        this.kb_1 = _unary__edvuaz + 1 | 0;
+        tmp.lb_1 = _unary__edvuaz;
+        var key = this.jb_1.a9_1[this.lb_1];
+        if (equals(key, this.jb_1))
+          sb.n1('(this Map)');
+        else
+          sb.t1(key);
+        sb.p1(_Char___init__impl__6a9atx(61));
+        var value = ensureNotNull(this.jb_1.b9_1)[this.lb_1];
+        if (equals(value, this.jb_1))
+          sb.n1('(this Map)');
+        else
+          sb.t1(value);
+        this.nb();
+      }
+    }
+    initMetadataForClass($, 'EntriesItr');
+    EntriesItrClass = $;
+  }
+  return EntriesItrClass;
+}
+var EntryRefClass;
+function EntryRef() {
+  if (EntryRefClass === VOID) {
+    class $ {
+      constructor(map, index) {
+        this.ab_1 = map;
+        this.bb_1 = index;
+        this.cb_1 = this.ab_1.h9_1;
+      }
+      f3() {
+        checkForComodification(this);
+        return this.ab_1.a9_1[this.bb_1];
+      }
+      g3() {
+        checkForComodification(this);
+        return ensureNotNull(this.ab_1.b9_1)[this.bb_1];
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (!(other == null) ? isInterface(other, Entry()) : false) {
+          tmp_0 = equals(other.f3(), this.f3());
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = equals(other.g3(), this.g3());
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver = this.f3();
+        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.g3();
+        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);
+      }
+      toString() {
+        return toString_0(this.f3()) + '=' + toString_0(this.g3());
+      }
+    }
+    initMetadataForClass($, 'EntryRef', VOID, VOID, [Entry()]);
+    EntryRefClass = $;
+  }
+  return EntryRefClass;
+}
+var InternalHashMapClass;
+function InternalHashMap() {
+  if (InternalHashMapClass === VOID) {
+    class $ {
+      static ec(keysArray, valuesArray, presenceArray, hashArray, maxProbeDistance, length) {
+        var $this = createThis(this);
+        $this.a9_1 = keysArray;
+        $this.b9_1 = valuesArray;
+        $this.c9_1 = presenceArray;
+        $this.d9_1 = hashArray;
+        $this.e9_1 = maxProbeDistance;
+        $this.f9_1 = length;
+        $this.g9_1 = computeShift(Companion_instance_0, _get_hashSize__tftcho($this));
+        $this.h9_1 = 0;
+        $this.i9_1 = 0;
+        $this.j9_1 = false;
+        return $this;
+      }
+      v2() {
+        return this.i9_1;
+      }
+      static k9() {
+        return this.ua(8);
+      }
+      static ua(initialCapacity) {
+        return this.ec(arrayOfUninitializedElements(initialCapacity), null, new Int32Array(initialCapacity), new Int32Array(computeHashSize(Companion_instance_0, initialCapacity)), 2, 0);
+      }
+      static p9(original) {
+        var $this = this.ua(original.v2());
+        $this.x4(original);
+        return $this;
+      }
+      static m9(initialCapacity, loadFactor) {
+        var $this = this.ua(initialCapacity);
+        // Inline function 'kotlin.require' call
+        if (!(loadFactor > 0)) {
+          var message = 'Non-positive load factor: ' + loadFactor;
+          throw IllegalArgumentException().r2(toString(message));
+        }
+        return $this;
+      }
+      fc() {
+        this.z9();
+        this.j9_1 = true;
+      }
+      n4(value) {
+        return findValue(this, value) >= 0;
+      }
+      o4(key) {
+        var index = findKey(this, key);
+        if (index < 0)
+          return null;
+        return ensureNotNull(this.b9_1)[index];
+      }
+      q9(key) {
+        return findKey(this, key) >= 0;
+      }
+      v4(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;
+        }
+      }
+      x4(from) {
+        this.z9();
+        putAllEntries(this, from.e3());
+      }
+      w4(key) {
+        this.z9();
+        var index = findKey(this, key);
+        if (index < 0)
+          return null;
+        var oldValue = ensureNotNull(this.b9_1)[index];
+        removeEntryAt(this, index);
+        return oldValue;
+      }
+      r4() {
+        this.z9();
+        var inductionVariable = 0;
+        var last = this.f9_1 - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var hash = this.c9_1[i];
+            if (hash >= 0) {
+              this.d9_1[hash] = 0;
+              this.c9_1[i] = -1;
+            }
+          }
+           while (!(i === last));
+        resetRange(this.a9_1, 0, this.f9_1);
+        var tmp0_safe_receiver = this.b9_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          resetRange(tmp0_safe_receiver, 0, this.f9_1);
+        }
+        this.i9_1 = 0;
+        this.f9_1 = 0;
+        registerModification(this);
+      }
+      equals(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;
+      }
+      hashCode() {
+        var result = 0;
+        var it = this.ga();
+        while (it.r1()) {
+          result = result + it.cc() | 0;
+        }
+        return result;
+      }
+      toString() {
+        var sb = StringBuilder().gc(2 + imul(this.i9_1, 3) | 0);
+        sb.n1('{');
+        var i = 0;
+        var it = this.ga();
+        while (it.r1()) {
+          if (i > 0) {
+            sb.n1(', ');
+          }
+          it.dc(sb);
+          i = i + 1 | 0;
+        }
+        sb.n1('}');
+        return sb.toString();
+      }
+      z9() {
+        if (this.j9_1)
+          throw UnsupportedOperationException().r8();
+      }
+      x9(key) {
+        this.z9();
+        var index = findKey(this, key);
+        if (index < 0)
+          return false;
+        removeEntryAt(this, index);
+        return true;
+      }
+      ka(entry) {
+        var index = findKey(this, entry.f3());
+        if (index < 0)
+          return false;
+        return equals(ensureNotNull(this.b9_1)[index], entry.g3());
+      }
+      hc(entry) {
+        return this.ka(isInterface(entry, Entry()) ? entry : THROW_CCE());
+      }
+      la(entry) {
+        this.z9();
+        var index = findKey(this, entry.f3());
+        if (index < 0)
+          return false;
+        if (!equals(ensureNotNull(this.b9_1)[index], entry.g3()))
+          return false;
+        removeEntryAt(this, index);
+        return true;
+      }
+      y9() {
+        return new (KeysItr())(this);
+      }
+      da() {
+        return new (ValuesItr())(this);
+      }
+      ga() {
+        return new (EntriesItr())(this);
+      }
+    }
+    protoOf($).ma = containsAllEntries;
+    initMetadataForClass($, 'InternalHashMap', $.k9, VOID, [InternalMap()]);
+    InternalHashMapClass = $;
+  }
+  return InternalHashMapClass;
+}
+//region block: init
+Companion_instance_0 = new (Companion())();
+//endregion
+//region block: exports
+export {
+  InternalHashMap as InternalHashMapmpvpylj0ut6l,
+};
+//endregion
+
+//# sourceMappingURL=InternalHashMap.mjs.map