diff --git a/std/assembly/map.ts b/std/assembly/map.ts
index a90ce8b622..ecdcc7799e 100644
--- a/std/assembly/map.ts
+++ b/std/assembly/map.ts
@@ -58,7 +58,7 @@ export class Map<K,V> {
 
   // buckets referencing their respective first entry, usize[bucketsMask + 1]
   private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * <i32>BUCKET_SIZE);
-  private bucketsMask: u32 = INITIAL_CAPACITY - 1;
+  private bucketsMask: u64 = INITIAL_CAPACITY - 1;
 
   // entries in insertion order, MapEntry<K,V>[entriesCapacity]
   private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * <i32>ENTRY_SIZE<K,V>());
@@ -83,7 +83,7 @@ export class Map<K,V> {
     this.entriesCount = 0;
   }
 
-  private find(key: K, hashCode: u32): MapEntry<K,V> | null {
+  private find(key: K, hashCode: u64): MapEntry<K,V> | null {
     var entry = load<MapEntry<K,V>>( // unmanaged!
       changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE
     );
@@ -118,11 +118,11 @@ export class Map<K,V> {
     } else {
       // check if rehashing is necessary
       if (this.entriesOffset == this.entriesCapacity) {
-        this.rehash(
+        this.rehash(u32(
           this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D
             ?  this.bucketsMask           // just rehash if 1/4+ entries are empty
             : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N
-        );
+        ));
       }
       // append new entry
       let entries = this.entries;
@@ -151,7 +151,7 @@ export class Map<K,V> {
     entry.taggedNext |= EMPTY;
     --this.entriesCount;
     // check if rehashing is appropriate
-    var halfBucketsMask = this.bucketsMask >> 1;
+    var halfBucketsMask = <u32>(this.bucketsMask >> 1);
     if (
       halfBucketsMask + 1 >= max<u32>(INITIAL_CAPACITY, this.entriesCount) &&
       this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D
@@ -176,8 +176,8 @@ export class Map<K,V> {
         let oldEntryKey = oldEntry.key;
         newEntry.key = oldEntryKey;
         newEntry.value = oldEntry.value;
-        let newBucketIndex = HASH<K>(oldEntryKey) & newBucketsMask;
-        let newBucketPtrBase = changetype<usize>(newBuckets) + <usize>newBucketIndex * BUCKET_SIZE;
+        let newBucketIndex = <usize>(HASH<K>(oldEntryKey) & newBucketsMask);
+        let newBucketPtrBase = changetype<usize>(newBuckets) + newBucketIndex * BUCKET_SIZE;
         newEntry.taggedNext = load<usize>(newBucketPtrBase);
         store<usize>(newBucketPtrBase, newPtr);
         newPtr += ENTRY_SIZE<K,V>();
diff --git a/std/assembly/set.ts b/std/assembly/set.ts
index f8396a5216..e29858e0ac 100644
--- a/std/assembly/set.ts
+++ b/std/assembly/set.ts
@@ -55,7 +55,7 @@ export class Set<T> {
 
   // buckets referencing their respective first entry, usize[bucketsMask + 1]
   private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * <i32>BUCKET_SIZE);
-  private bucketsMask: u32 = INITIAL_CAPACITY - 1;
+  private bucketsMask: u64 = INITIAL_CAPACITY - 1;
 
   // entries in insertion order, SetEntry<K>[entriesCapacity]
   private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * <i32>ENTRY_SIZE<T>());
@@ -80,7 +80,7 @@ export class Set<T> {
     this.entriesCount = 0;
   }
 
-  private find(key: T, hashCode: u32): SetEntry<T> | null {
+  private find(key: T, hashCode: u64): SetEntry<T> | null {
     var entry = load<SetEntry<T>>( // unmanaged!
       changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE
     );
@@ -103,11 +103,11 @@ export class Set<T> {
     if (!entry) {
       // check if rehashing is necessary
       if (this.entriesOffset == this.entriesCapacity) {
-        this.rehash(
+        this.rehash(u32(
           this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D
             ?  this.bucketsMask           // just rehash if 1/4+ entries are empty
             : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N
-        );
+        ));
       }
       // append new entry
       entry = changetype<SetEntry<T>>(changetype<usize>(this.entries) + <usize>(this.entriesOffset++) * ENTRY_SIZE<T>());
@@ -136,7 +136,7 @@ export class Set<T> {
     entry.taggedNext |= EMPTY;
     --this.entriesCount;
     // check if rehashing is appropriate
-    var halfBucketsMask = this.bucketsMask >> 1;
+    var halfBucketsMask = <u32>(this.bucketsMask >> 1);
     if (
       halfBucketsMask + 1 >= max<u32>(INITIAL_CAPACITY, this.entriesCount) &&
       this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D
diff --git a/std/assembly/util/hash.ts b/std/assembly/util/hash.ts
index c168fa4903..e9808bed99 100644
--- a/std/assembly/util/hash.ts
+++ b/std/assembly/util/hash.ts
@@ -1,6 +1,4 @@
-// @ts-ignore: decorator
-@inline
-export function HASH<T>(key: T): u32 {
+export function HASH<T>(key: T): u64 {
   if (isString<T>()) {
     return hashStr(changetype<string>(key));
   } else if (isReference<T>()) {
@@ -10,63 +8,133 @@ export function HASH<T>(key: T): u32 {
     if (sizeof<T>() == 4) return hash32(reinterpret<u32>(f32(key)));
     if (sizeof<T>() == 8) return hash64(reinterpret<u64>(f64(key)));
   } else {
-    if (sizeof<T>() == 1) return hash8 (u32(key));
-    if (sizeof<T>() == 2) return hash16(u32(key));
-    if (sizeof<T>() == 4) return hash32(u32(key));
+    if (sizeof<T>() <= 4) return hash32(u32(key), sizeof<T>());
     if (sizeof<T>() == 8) return hash64(u64(key));
   }
   return unreachable();
 }
 
-// FNV-1a 32-bit as a starting point, see: http://isthe.com/chongo/tech/comp/fnv/
+// XXHash 64-bit, see: https://cyan4973.github.io/xxHash
 
+// primes
 // @ts-ignore: decorator
-@inline const FNV_OFFSET: u32 = 2166136261;
-
+@inline const XXH64_P1: u64 = 11400714785074694791;
+// @ts-ignore: decorator
+@inline const XXH64_P2: u64 = 14029467366897019727;
 // @ts-ignore: decorator
-@inline const FNV_PRIME: u32 = 16777619;
+@inline const XXH64_P3: u64 = 1609587929392839161;
+// @ts-ignore: decorator
+@inline const XXH64_P4: u64 = 9650029242287828579;
+// @ts-ignore: decorator
+@inline const XXH64_P5: u64 = 2870177450012600261;
+// @ts-ignore: decorator
+@inline const XXH64_SEED: u64 = 0;
 
-function hash8(key: u32): u32 {
-  return (FNV_OFFSET ^ key) * FNV_PRIME;
+// @ts-ignore: decorator
+@inline
+function hash32(key: u32, len: u64 = 4): u64 {
+  var h: u64 = XXH64_SEED + XXH64_P5 + len;
+  h ^= u64(key) * XXH64_P1;
+  h  = rotl(h, 23) * XXH64_P2 + XXH64_P3;
+  h ^= h >> 33;
+  h *= XXH64_P2;
+  h ^= h >> 29;
+  h *= XXH64_P3;
+  h ^= h >> 32;
+  return h;
 }
 
-function hash16(key: u32): u32 {
-  var v = FNV_OFFSET;
-  v = (v ^ ( key        & 0xff)) * FNV_PRIME;
-  v = (v ^ ( key >>  8        )) * FNV_PRIME;
-  return v;
+// @ts-ignore: decorator
+@inline
+function hash64(key: u64): u64 {
+  var h: u64 = XXH64_SEED + XXH64_P5 + 8;
+  h ^= rotl(key * XXH64_P2, 31) * XXH64_P1;
+  h  = rotl(h, 27) * XXH64_P1 + XXH64_P4;
+  h ^= h >> 33;
+  h *= XXH64_P2;
+  h ^= h >> 29;
+  h *= XXH64_P3;
+  h ^= h >> 32;
+  return h;
 }
 
-function hash32(key: u32): u32 {
-  var v = FNV_OFFSET;
-  v = (v ^ ( key        & 0xff)) * FNV_PRIME;
-  v = (v ^ ((key >>  8) & 0xff)) * FNV_PRIME;
-  v = (v ^ ((key >> 16) & 0xff)) * FNV_PRIME;
-  v = (v ^ ( key >> 24        )) * FNV_PRIME;
-  return v;
+// @ts-ignore: decorator
+@inline
+function mix1(h: u64, key: u64): u64 {
+  return rotl(h + key * XXH64_P2, 31) * XXH64_P1;
 }
 
-function hash64(key: u64): u32 {
-  var l = <u32> key;
-  var h = <u32>(key >>> 32);
-  var v = FNV_OFFSET;
-  v = (v ^ ( l        & 0xff)) * FNV_PRIME;
-  v = (v ^ ((l >>  8) & 0xff)) * FNV_PRIME;
-  v = (v ^ ((l >> 16) & 0xff)) * FNV_PRIME;
-  v = (v ^ ( l >> 24        )) * FNV_PRIME;
-  v = (v ^ ( h        & 0xff)) * FNV_PRIME;
-  v = (v ^ ((h >>  8) & 0xff)) * FNV_PRIME;
-  v = (v ^ ((h >> 16) & 0xff)) * FNV_PRIME;
-  v = (v ^ ( h >> 24        )) * FNV_PRIME;
-  return v;
+// @ts-ignore: decorator
+@inline
+function mix2(h: u64, s: u64): u64 {
+  return (h ^ (rotl(s, 31) * XXH64_P1)) * XXH64_P1 + XXH64_P4;
 }
 
-function hashStr(key: string): u32 {
-  var v = FNV_OFFSET;
-  if (key !== null) {
-    for (let i: usize = 0, k: usize = key.length << 1; i < k; ++i) {
-      v = (v ^ <u32>load<u8>(changetype<usize>(key) + i)) * FNV_PRIME;
+// @ts-ignore: decorator
+@inline
+function hashStr(key: string): u64 {
+  if (key === null) {
+    return XXH64_SEED;
+  }
+
+  var len = key.length << 1;
+  var h: u64 = 0;
+  let i = 0;
+
+  if (len >= 32) {
+    let s1 = XXH64_SEED + XXH64_P1 + XXH64_P2;
+    let s2 = XXH64_SEED + XXH64_P2;
+    let s3 = XXH64_SEED;
+    let s4 = XXH64_SEED - XXH64_P1;
+    let ln = len;
+
+    let n = len - 32;
+    while (i <= n) {
+      s1 = mix1(s1, load<u64>(changetype<usize>(key) + i    ));
+      s2 = mix1(s2, load<u64>(changetype<usize>(key) + i,  8));
+      s3 = mix1(s3, load<u64>(changetype<usize>(key) + i, 16));
+      s4 = mix1(s4, load<u64>(changetype<usize>(key) + i, 24));
+      i += 32;
     }
+    h = rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);
+
+    s1 *= XXH64_P2;
+    s2 *= XXH64_P2;
+    s3 *= XXH64_P2;
+    s4 *= XXH64_P2;
+
+    h = mix2(h, s1);
+    h = mix2(h, s2);
+    h = mix2(h, s3);
+    h = mix2(h, s4);
+    h += <u64>ln;
+  } else {
+    h = <u64>len + XXH64_SEED + XXH64_P5;
   }
-  return v;
+
+  var n = len - 8;
+  while (i <= n) {
+    h ^= rotl(load<u64>(changetype<usize>(key) + i) * XXH64_P2, 31) * XXH64_P1;
+    h  = rotl(h, 27) * XXH64_P1 + XXH64_P4;
+    i += 8;
+  }
+
+  if (i + 4 <= len) {
+    h ^= <u64>load<u32>(changetype<usize>(key) + i) * XXH64_P1;
+    h  = rotl(h, 23) * XXH64_P2 + XXH64_P3;
+    i += 4;
+  }
+
+  while (i < len) {
+    h += <u64>load<u8>(changetype<usize>(key) + i) * XXH64_P5;
+    h = rotl(h, 11) * XXH64_P1;
+    i++;
+  }
+
+  h ^= h >> 33;
+  h *= XXH64_P2;
+  h ^= h >> 29;
+  h *= XXH64_P3;
+  h ^= h >> 32;
+  return h;
 }
diff --git a/tests/compiler/std/hash.optimized.wat b/tests/compiler/std/hash.optimized.wat
index 6314777b30..3f355dda16 100644
--- a/tests/compiler/std/hash.optimized.wat
+++ b/tests/compiler/std/hash.optimized.wat
@@ -12,92 +12,62 @@
  (data (i32.const 1112) "\01\00\00\00\04\00\00\00a\00b")
  (data (i32.const 1132) "\1c")
  (data (i32.const 1144) "\01\00\00\00\06\00\00\00a\00b\00c")
- (global $~lib/memory/__stack_pointer (mut i32) (i32.const 17548))
+ (data (i32.const 1164) "\1c")
+ (data (i32.const 1176) "\01\00\00\00\08\00\00\00a\00b\00c\00d")
+ (data (i32.const 1196) "\1c")
+ (data (i32.const 1208) "\01\00\00\00\n\00\00\00a\00b\00c\00d\00e")
+ (data (i32.const 1228) "\1c")
+ (data (i32.const 1240) "\01\00\00\00\0c\00\00\00a\00b\00c\00d\00e\00f")
+ (data (i32.const 1260) ",")
+ (data (i32.const 1272) "\01\00\00\00\0e\00\00\00a\00b\00c\00d\00e\00f\00g")
+ (data (i32.const 1308) ",")
+ (data (i32.const 1320) "\01\00\00\00\10\00\00\00a\00b\00c\00d\00e\00f\00g\00h")
+ (data (i32.const 1356) ",")
+ (data (i32.const 1368) "\01\00\00\00\12\00\00\00a\00b\00c\00d\00e\00f\00g\00h\00i")
+ (global $~lib/memory/__stack_pointer (mut i32) (i32.const 17788))
  (export "memory" (memory $0))
  (start $~start)
  (func $~start
-  global.get $~lib/memory/__stack_pointer
-  i32.const 8
-  i32.sub
-  global.set $~lib/memory/__stack_pointer
-  call $~stack_check
-  global.get $~lib/memory/__stack_pointer
-  i64.const 0
-  i64.store
-  global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store
-  i32.const 0
-  call $~lib/util/hash/hashStr
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1056
-  i32.store offset=4
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1056
-  i32.store
-  i32.const 1056
-  call $~lib/util/hash/hashStr
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1088
-  i32.store offset=4
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1088
-  i32.store
-  i32.const 1088
-  call $~lib/util/hash/hashStr
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1120
-  i32.store offset=4
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1120
-  i32.store
-  i32.const 1120
-  call $~lib/util/hash/hashStr
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1152
-  i32.store offset=4
-  global.get $~lib/memory/__stack_pointer
-  i32.const 1152
-  i32.store
-  i32.const 1152
-  call $~lib/util/hash/hashStr
-  global.get $~lib/memory/__stack_pointer
-  i32.const 8
-  i32.add
-  global.set $~lib/memory/__stack_pointer
+  call $start:std/hash
  )
  (func $~stack_check
   global.get $~lib/memory/__stack_pointer
-  i32.const 1164
+  i32.const 1404
   i32.lt_s
   if
-   i32.const 17568
-   i32.const 17616
+   i32.const 17808
+   i32.const 17856
    i32.const 1
    i32.const 1
    call $~lib/builtins/abort
    unreachable
   end
  )
- (func $~lib/util/hash/hashStr (param $0 i32)
+ (func $~lib/util/hash/HASH<~lib/string/String|null> (param $0 i32)
   (local $1 i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
+  (local $4 i32)
+  (local $5 i64)
+  (local $6 i64)
+  (local $7 i64)
+  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
   global.get $~lib/memory/__stack_pointer
-  i32.const 0
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
   i32.store
-  i32.const -2128831035
-  local.set $2
   local.get $0
   if
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.store
+   i32.store offset=4
    local.get $0
    i32.const 20
    i32.sub
@@ -106,30 +76,309 @@
    i32.shr_u
    i32.const 1
    i32.shl
-   local.set $3
-   loop $for-loop|0
+   local.tee $3
+   i32.const 32
+   i32.ge_s
+   if (result i64)
+    i64.const 6983438078262162902
+    local.set $2
+    i64.const -4417276706812531889
+    local.set $5
+    i64.const 7046029288634856825
+    local.set $6
+    local.get $3
+    i32.const 32
+    i32.sub
+    local.set $8
+    loop $while-continue|0
+     local.get $1
+     local.get $8
+     i32.le_s
+     if
+      local.get $2
+      local.get $0
+      local.get $1
+      i32.add
+      local.tee $4
+      i64.load
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $2
+      local.get $5
+      local.get $4
+      i64.load offset=8
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $5
+      local.get $7
+      local.get $4
+      i64.load offset=16
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $7
+      local.get $6
+      local.get $4
+      i64.load offset=24
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $6
+      local.get $1
+      i32.const 32
+      i32.add
+      local.set $1
+      br $while-continue|0
+     end
+    end
+    local.get $3
+    i64.extend_i32_s
+    local.get $2
+    i64.const 1
+    i64.rotl
+    local.get $5
+    i64.const 7
+    i64.rotl
+    i64.add
+    local.get $7
+    i64.const 12
+    i64.rotl
+    i64.add
+    local.get $6
+    i64.const 18
+    i64.rotl
+    i64.add
+    local.get $2
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    local.get $5
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    local.get $7
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    local.get $6
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    i64.add
+   else
+    local.get $3
+    i64.extend_i32_s
+    i64.const 2870177450012600261
+    i64.add
+   end
+   local.set $2
+   local.get $3
+   i32.const 8
+   i32.sub
+   local.set $4
+   loop $while-continue|1
+    local.get $1
+    local.get $4
+    i32.le_s
+    if
+     local.get $2
+     local.get $0
+     local.get $1
+     i32.add
+     i64.load
+     i64.const -4417276706812531889
+     i64.mul
+     i64.const 31
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.xor
+     i64.const 27
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.const 8796714831421723037
+     i64.sub
+     local.set $2
+     local.get $1
+     i32.const 8
+     i32.add
+     local.set $1
+     br $while-continue|1
+    end
+   end
+   local.get $3
+   local.get $1
+   i32.const 4
+   i32.add
+   i32.ge_s
+   if
+    local.get $2
+    local.get $0
+    local.get $1
+    i32.add
+    i64.load32_u
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const 23
+    i64.rotl
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 1609587929392839161
+    i64.add
+    local.set $2
+    local.get $1
+    i32.const 4
+    i32.add
+    local.set $1
+   end
+   loop $while-continue|2
     local.get $1
     local.get $3
-    i32.lt_u
+    i32.lt_s
     if
      local.get $2
      local.get $0
      local.get $1
      i32.add
-     i32.load8_u
-     i32.xor
-     i32.const 16777619
-     i32.mul
+     i64.load8_u
+     i64.const 2870177450012600261
+     i64.mul
+     i64.add
+     i64.const 11
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
      local.set $2
      local.get $1
      i32.const 1
      i32.add
      local.set $1
-     br $for-loop|0
+     br $while-continue|2
     end
    end
   end
   global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $start:std/hash
+  (local $0 f32)
+  (local $1 i64)
+  (local $2 f64)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  i32.const 0
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1056
+  i32.store
+  i32.const 1056
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1088
+  i32.store
+  i32.const 1088
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1120
+  i32.store
+  i32.const 1120
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1152
+  i32.store
+  i32.const 1152
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1184
+  i32.store
+  i32.const 1184
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1216
+  i32.store
+  i32.const 1216
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1248
+  i32.store
+  i32.const 1248
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1280
+  i32.store
+  i32.const 1280
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1328
+  i32.store
+  i32.const 1328
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1376
+  i32.store
+  i32.const 1376
+  call $~lib/util/hash/HASH<~lib/string/String|null>
+  global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
diff --git a/tests/compiler/std/hash.ts b/tests/compiler/std/hash.ts
index b46889ba88..714866475e 100644
--- a/tests/compiler/std/hash.ts
+++ b/tests/compiler/std/hash.ts
@@ -1,6 +1,6 @@
 import { HASH } from "util/hash";
 
-function check(hash: u32): bool {
+function check(hash: u64): bool {
   return true;
 }
 
@@ -9,6 +9,12 @@ check(HASH<string>(""));
 check(HASH<string>("a"));
 check(HASH<string>("ab"));
 check(HASH<string>("abc"));
+check(HASH<string>("abcd"));
+check(HASH<string>("abcde"));
+check(HASH<string>("abcdef"));
+check(HASH<string>("abcdefg"));
+check(HASH<string>("abcdefgh"));
+check(HASH<string>("abcdefghi"));
 
 check(HASH<f32>(0.0));
 check(HASH<f32>(1.0));
diff --git a/tests/compiler/std/hash.untouched.wat b/tests/compiler/std/hash.untouched.wat
index cc30a79cee..a89bc952f4 100644
--- a/tests/compiler/std/hash.untouched.wat
+++ b/tests/compiler/std/hash.untouched.wat
@@ -1,18 +1,27 @@
 (module
- (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $none_=>_none (func))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
+ (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $i64_=>_i32 (func (param i64) (result i32)))
+ (type $f32_=>_i64 (func (param f32) (result i64)))
+ (type $f64_=>_i64 (func (param f64) (result i64)))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
  (memory $0 1)
  (data (i32.const 12) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00")
  (data (i32.const 44) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00a\00\00\00\00\00\00\00\00\00\00\00")
  (data (i32.const 76) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\04\00\00\00a\00b\00\00\00\00\00\00\00\00\00")
  (data (i32.const 108) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\06\00\00\00a\00b\00c\00\00\00\00\00\00\00")
+ (data (i32.const 140) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00a\00b\00c\00d\00\00\00\00\00")
+ (data (i32.const 172) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\n\00\00\00a\00b\00c\00d\00e\00\00\00")
+ (data (i32.const 204) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\0c\00\00\00a\00b\00c\00d\00e\00f\00")
+ (data (i32.const 236) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\0e\00\00\00a\00b\00c\00d\00e\00f\00g\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00")
+ (data (i32.const 284) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00a\00b\00c\00d\00e\00f\00g\00h\00\00\00\00\00\00\00\00\00\00\00\00\00")
+ (data (i32.const 332) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\12\00\00\00a\00b\00c\00d\00e\00f\00g\00h\00i\00\00\00\00\00\00\00\00\00\00\00")
  (table $0 1 funcref)
- (global $~lib/memory/__data_end i32 (i32.const 140))
- (global $~lib/memory/__stack_pointer (mut i32) (i32.const 16524))
- (global $~lib/memory/__heap_base i32 (i32.const 16524))
+ (global $~lib/memory/__data_end i32 (i32.const 380))
+ (global $~lib/memory/__stack_pointer (mut i32) (i32.const 16764))
+ (global $~lib/memory/__heap_base i32 (i32.const 16764))
  (export "memory" (memory $0))
  (start $~start)
  (func $~lib/string/String#get:length (param $0 i32) (result i32)
@@ -23,138 +32,150 @@
   i32.const 1
   i32.shr_u
  )
- (func $std/hash/check (param $0 i32) (result i32)
+ (func $std/hash/check (param $0 i64) (result i32)
   i32.const 1
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  (local $1 i32)
-  i32.const -2128831035
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
- )
- (func $~lib/util/hash/hash64 (param $0 i64) (result i32)
+ (func $~lib/util/hash/HASH<f32> (param $0 f32) (result i64)
   (local $1 i32)
-  (local $2 i32)
-  (local $3 i32)
+  (local $2 i64)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  drop
+  i32.const 4
+  i32.const 4
+  i32.eq
+  drop
   local.get $0
-  i32.wrap_i64
+  i32.reinterpret_f32
   local.set $1
-  local.get $0
-  i64.const 32
-  i64.shr_u
-  i32.wrap_i64
+  i64.const 4
   local.set $2
-  i32.const -2128831035
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $2
+  i64.add
   local.set $3
   local.get $3
   local.get $1
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
   local.set $3
   local.get $3
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
   local.set $3
   local.get $3
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
   local.get $3
-  local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.const 33
+  i64.shr_u
+  i64.xor
   local.set $3
   local.get $3
-  local.get $2
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.const -4417276706812531889
+  i64.mul
   local.set $3
   local.get $3
-  local.get $2
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
   local.set $3
   local.get $3
-  local.get $2
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.const 1609587929392839161
+  i64.mul
   local.set $3
   local.get $3
-  local.get $2
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
   local.set $3
   local.get $3
+  return
+ )
+ (func $~lib/util/hash/HASH<f64> (param $0 f64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  drop
+  i32.const 8
+  i32.const 4
+  i32.eq
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
+  local.get $0
+  i64.reinterpret_f64
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $1
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
  )
  (func $~start
   call $start:std/hash
@@ -164,83 +185,432 @@
   global.get $~lib/memory/__data_end
   i32.lt_s
   if
-   i32.const 16544
-   i32.const 16592
+   i32.const 16784
+   i32.const 16832
    i32.const 1
    i32.const 1
    call $~lib/builtins/abort
    unreachable
   end
  )
- (func $~lib/util/hash/hashStr (param $0 i32) (result i32)
+ (func $~lib/util/hash/HASH<~lib/string/String|null> (param $0 i32) (result i64)
   (local $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
+  (local $6 i64)
+  (local $7 i64)
+  (local $8 i64)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  (local $12 i64)
+  (local $13 i64)
+  (local $14 i32)
+  (local $15 i64)
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
   global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store
-  i32.const -2128831035
-  local.set $1
-  local.get $0
-  i32.const 0
-  i32.ne
-  if
-   i32.const 0
-   local.set $2
-   local.get $0
-   local.set $5
+  i64.const 0
+  i64.store
+  i32.const 1
+  drop
+  block $~lib/util/hash/hashStr|inlined.0 (result i64)
    global.get $~lib/memory/__stack_pointer
-   local.get $5
+   local.get $0
+   local.tee $1
    i32.store
-   local.get $5
+   local.get $1
+   i32.const 0
+   i32.eq
+   if
+    i64.const 0
+    br $~lib/util/hash/hashStr|inlined.0
+   end
+   local.get $1
+   local.set $14
+   global.get $~lib/memory/__stack_pointer
+   local.get $14
+   i32.store offset=4
+   local.get $14
    call $~lib/string/String#get:length
    i32.const 1
    i32.shl
+   local.set $2
+   i64.const 0
    local.set $3
-   loop $for-loop|0
+   i32.const 0
+   local.set $4
+   local.get $2
+   i32.const 32
+   i32.ge_s
+   if
+    i64.const 0
+    i64.const -7046029288634856825
+    i64.add
+    i64.const -4417276706812531889
+    i64.add
+    local.set $5
+    i64.const 0
+    i64.const -4417276706812531889
+    i64.add
+    local.set $6
+    i64.const 0
+    local.set $7
+    i64.const 0
+    i64.const -7046029288634856825
+    i64.sub
+    local.set $8
+    local.get $2
+    local.set $9
     local.get $2
+    i32.const 32
+    i32.sub
+    local.set $10
+    loop $while-continue|0
+     local.get $4
+     local.get $10
+     i32.le_s
+     local.set $11
+     local.get $11
+     if
+      local.get $5
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $5
+      local.get $6
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=8
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $6
+      local.get $7
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=16
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $7
+      local.get $8
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=24
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $8
+      local.get $4
+      i32.const 32
+      i32.add
+      local.set $4
+      br $while-continue|0
+     end
+    end
+    local.get $5
+    i64.const 1
+    i64.rotl
+    local.get $6
+    i64.const 7
+    i64.rotl
+    i64.add
+    local.get $7
+    i64.const 12
+    i64.rotl
+    i64.add
+    local.get $8
+    i64.const 18
+    i64.rotl
+    i64.add
+    local.set $3
+    local.get $5
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $5
+    local.get $6
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $6
+    local.get $7
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $7
+    local.get $8
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $8
+    local.get $3
+    local.set $13
+    local.get $5
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $6
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $7
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $8
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.get $9
+    i64.extend_i32_s
+    i64.add
+    local.set $3
+   else
+    local.get $2
+    i64.extend_i32_s
+    i64.const 0
+    i64.add
+    i64.const 2870177450012600261
+    i64.add
+    local.set $3
+   end
+   local.get $2
+   i32.const 8
+   i32.sub
+   local.set $10
+   loop $while-continue|1
+    local.get $4
+    local.get $10
+    i32.le_s
+    local.set $9
+    local.get $9
+    if
+     local.get $3
+     local.get $1
+     local.get $4
+     i32.add
+     i64.load
+     i64.const -4417276706812531889
+     i64.mul
+     i64.const 31
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.xor
+     local.set $3
+     local.get $3
+     i64.const 27
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.const -8796714831421723037
+     i64.add
+     local.set $3
+     local.get $4
+     i32.const 8
+     i32.add
+     local.set $4
+     br $while-continue|1
+    end
+   end
+   local.get $4
+   i32.const 4
+   i32.add
+   local.get $2
+   i32.le_s
+   if
     local.get $3
-    i32.lt_u
+    local.get $1
+    local.get $4
+    i32.add
+    i64.load32_u
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    local.set $3
+    local.get $3
+    i64.const 23
+    i64.rotl
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 1609587929392839161
+    i64.add
+    local.set $3
+    local.get $4
+    i32.const 4
+    i32.add
     local.set $4
+   end
+   loop $while-continue|2
     local.get $4
+    local.get $2
+    i32.lt_s
+    local.set $9
+    local.get $9
     if
+     local.get $3
      local.get $1
-     local.get $0
-     local.get $2
+     local.get $4
      i32.add
-     i32.load8_u
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     local.set $1
-     local.get $2
+     i64.load8_u
+     i64.const 2870177450012600261
+     i64.mul
+     i64.add
+     local.set $3
+     local.get $3
+     i64.const 11
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     local.set $3
+     local.get $4
      i32.const 1
      i32.add
-     local.set $2
-     br $for-loop|0
+     local.set $4
+     br $while-continue|2
     end
    end
+   local.get $3
+   local.get $3
+   i64.const 33
+   i64.shr_u
+   i64.xor
+   local.set $3
+   local.get $3
+   i64.const -4417276706812531889
+   i64.mul
+   local.set $3
+   local.get $3
+   local.get $3
+   i64.const 29
+   i64.shr_u
+   i64.xor
+   local.set $3
+   local.get $3
+   i64.const 1609587929392839161
+   i64.mul
+   local.set $3
+   local.get $3
+   local.get $3
+   i64.const 32
+   i64.shr_u
+   i64.xor
+   local.set $3
+   local.get $3
   end
-  local.get $1
-  local.set $5
+  local.set $15
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $5
+  local.get $15
+  return
  )
- (func $start:std/hash
-  (local $0 i32)
-  (local $1 f32)
-  (local $2 f64)
-  (local $3 i32)
+ (func $~lib/util/hash/HASH<~lib/string/String> (param $0 i32) (result i64)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i64)
+  (local $4 i32)
+  (local $5 i64)
+  (local $6 i64)
+  (local $7 i64)
+  (local $8 i64)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  (local $12 i64)
+  (local $13 i64)
+  (local $14 i32)
+  (local $15 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -249,360 +619,538 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<~lib/string/String|null>|inlined.0 (result i32)
-   i32.const 0
-   local.set $0
-   i32.const 1
-   drop
-   local.get $0
-   local.set $3
-   global.get $~lib/memory/__stack_pointer
-   local.get $3
-   i32.store
-   local.get $3
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String|null>|inlined.0
-  end
-  call $std/hash/check
+  i32.const 1
   drop
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.0 (result i32)
+  block $~lib/util/hash/hashStr|inlined.1 (result i64)
    global.get $~lib/memory/__stack_pointer
-   i32.const 32
-   local.tee $0
-   i32.store offset=4
-   i32.const 1
-   drop
    local.get $0
-   local.set $3
-   global.get $~lib/memory/__stack_pointer
-   local.get $3
+   local.tee $1
    i32.store
-   local.get $3
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.0
-  end
-  call $std/hash/check
-  drop
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.1 (result i32)
+   local.get $1
+   i32.const 0
+   i32.eq
+   if
+    i64.const 0
+    br $~lib/util/hash/hashStr|inlined.1
+   end
+   local.get $1
+   local.set $14
    global.get $~lib/memory/__stack_pointer
-   i32.const 64
-   local.tee $0
+   local.get $14
    i32.store offset=4
+   local.get $14
+   call $~lib/string/String#get:length
    i32.const 1
-   drop
-   local.get $0
+   i32.shl
+   local.set $2
+   i64.const 0
    local.set $3
-   global.get $~lib/memory/__stack_pointer
+   i32.const 0
+   local.set $4
+   local.get $2
+   i32.const 32
+   i32.ge_s
+   if
+    i64.const 0
+    i64.const -7046029288634856825
+    i64.add
+    i64.const -4417276706812531889
+    i64.add
+    local.set $5
+    i64.const 0
+    i64.const -4417276706812531889
+    i64.add
+    local.set $6
+    i64.const 0
+    local.set $7
+    i64.const 0
+    i64.const -7046029288634856825
+    i64.sub
+    local.set $8
+    local.get $2
+    local.set $9
+    local.get $2
+    i32.const 32
+    i32.sub
+    local.set $10
+    loop $while-continue|0
+     local.get $4
+     local.get $10
+     i32.le_s
+     local.set $11
+     local.get $11
+     if
+      local.get $5
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $5
+      local.get $6
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=8
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $6
+      local.get $7
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=16
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $7
+      local.get $8
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=24
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $8
+      local.get $4
+      i32.const 32
+      i32.add
+      local.set $4
+      br $while-continue|0
+     end
+    end
+    local.get $5
+    i64.const 1
+    i64.rotl
+    local.get $6
+    i64.const 7
+    i64.rotl
+    i64.add
+    local.get $7
+    i64.const 12
+    i64.rotl
+    i64.add
+    local.get $8
+    i64.const 18
+    i64.rotl
+    i64.add
+    local.set $3
+    local.get $5
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $5
+    local.get $6
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $6
+    local.get $7
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $7
+    local.get $8
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $8
+    local.get $3
+    local.set $13
+    local.get $5
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $6
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $7
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $8
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.get $9
+    i64.extend_i32_s
+    i64.add
+    local.set $3
+   else
+    local.get $2
+    i64.extend_i32_s
+    i64.const 0
+    i64.add
+    i64.const 2870177450012600261
+    i64.add
+    local.set $3
+   end
+   local.get $2
+   i32.const 8
+   i32.sub
+   local.set $10
+   loop $while-continue|1
+    local.get $4
+    local.get $10
+    i32.le_s
+    local.set $9
+    local.get $9
+    if
+     local.get $3
+     local.get $1
+     local.get $4
+     i32.add
+     i64.load
+     i64.const -4417276706812531889
+     i64.mul
+     i64.const 31
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.xor
+     local.set $3
+     local.get $3
+     i64.const 27
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.const -8796714831421723037
+     i64.add
+     local.set $3
+     local.get $4
+     i32.const 8
+     i32.add
+     local.set $4
+     br $while-continue|1
+    end
+   end
+   local.get $4
+   i32.const 4
+   i32.add
+   local.get $2
+   i32.le_s
+   if
+    local.get $3
+    local.get $1
+    local.get $4
+    i32.add
+    i64.load32_u
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    local.set $3
+    local.get $3
+    i64.const 23
+    i64.rotl
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 1609587929392839161
+    i64.add
+    local.set $3
+    local.get $4
+    i32.const 4
+    i32.add
+    local.set $4
+   end
+   loop $while-continue|2
+    local.get $4
+    local.get $2
+    i32.lt_s
+    local.set $9
+    local.get $9
+    if
+     local.get $3
+     local.get $1
+     local.get $4
+     i32.add
+     i64.load8_u
+     i64.const 2870177450012600261
+     i64.mul
+     i64.add
+     local.set $3
+     local.get $3
+     i64.const 11
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     local.set $3
+     local.get $4
+     i32.const 1
+     i32.add
+     local.set $4
+     br $while-continue|2
+    end
+   end
    local.get $3
-   i32.store
    local.get $3
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.1
-  end
-  call $std/hash/check
-  drop
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.2 (result i32)
-   global.get $~lib/memory/__stack_pointer
-   i32.const 96
-   local.tee $0
-   i32.store offset=4
-   i32.const 1
-   drop
-   local.get $0
+   i64.const 33
+   i64.shr_u
+   i64.xor
    local.set $3
-   global.get $~lib/memory/__stack_pointer
    local.get $3
-   i32.store
+   i64.const -4417276706812531889
+   i64.mul
+   local.set $3
    local.get $3
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.2
-  end
-  call $std/hash/check
-  drop
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.3 (result i32)
-   global.get $~lib/memory/__stack_pointer
-   i32.const 128
-   local.tee $0
-   i32.store offset=4
-   i32.const 1
-   drop
-   local.get $0
+   local.get $3
+   i64.const 29
+   i64.shr_u
+   i64.xor
    local.set $3
-   global.get $~lib/memory/__stack_pointer
    local.get $3
-   i32.store
+   i64.const 1609587929392839161
+   i64.mul
+   local.set $3
+   local.get $3
+   local.get $3
+   i64.const 32
+   i64.shr_u
+   i64.xor
+   local.set $3
    local.get $3
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.3
   end
+  local.set $15
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $15
+  return
+ )
+ (func $start:std/hash
+  (local $0 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  i32.const 0
+  call $~lib/util/hash/HASH<~lib/string/String|null>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f32>|inlined.0 (result i32)
-   f32.const 0
-   local.set $1
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $1
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.0
-  end
+  i32.const 32
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f32>|inlined.1 (result i32)
-   f32.const 1
-   local.set $1
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $1
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.1
-  end
+  i32.const 64
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f32>|inlined.2 (result i32)
-   f32.const 1.100000023841858
-   local.set $1
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $1
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.2
-  end
+  i32.const 96
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f32>|inlined.3 (result i32)
-   f32.const 0
-   local.set $1
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $1
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.3
-  end
+  i32.const 128
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f32>|inlined.4 (result i32)
-   f32.const inf
-   local.set $1
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $1
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.4
-  end
+  i32.const 160
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f32>|inlined.5 (result i32)
-   f32.const nan:0x400000
-   local.set $1
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $1
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.5
-  end
+  i32.const 192
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f64>|inlined.0 (result i32)
-   f64.const 0
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.0
-  end
+  i32.const 224
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f64>|inlined.1 (result i32)
-   f64.const 1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.1
-  end
+  i32.const 256
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f64>|inlined.2 (result i32)
-   f64.const 1.1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.2
-  end
+  i32.const 304
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f64>|inlined.3 (result i32)
-   f64.const 0
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.3
-  end
+  i32.const 352
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f64>|inlined.4 (result i32)
-   f64.const inf
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.4
-  end
+  f32.const 0
+  call $~lib/util/hash/HASH<f32>
   call $std/hash/check
   drop
-  block $~lib/util/hash/HASH<f64>|inlined.5 (result i32)
-   f64.const nan:0x8000000000000
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.5
-  end
+  f32.const 1
+  call $~lib/util/hash/HASH<f32>
+  call $std/hash/check
+  drop
+  f32.const 1.100000023841858
+  call $~lib/util/hash/HASH<f32>
+  call $std/hash/check
+  drop
+  f32.const 0
+  call $~lib/util/hash/HASH<f32>
+  call $std/hash/check
+  drop
+  f32.const inf
+  call $~lib/util/hash/HASH<f32>
+  call $std/hash/check
+  drop
+  f32.const nan:0x400000
+  call $~lib/util/hash/HASH<f32>
+  call $std/hash/check
+  drop
+  f64.const 0
+  call $~lib/util/hash/HASH<f64>
+  call $std/hash/check
+  drop
+  f64.const 1
+  call $~lib/util/hash/HASH<f64>
+  call $std/hash/check
+  drop
+  f64.const 1.1
+  call $~lib/util/hash/HASH<f64>
+  call $std/hash/check
+  drop
+  f64.const 0
+  call $~lib/util/hash/HASH<f64>
+  call $std/hash/check
+  drop
+  f64.const inf
+  call $~lib/util/hash/HASH<f64>
+  call $std/hash/check
+  drop
+  f64.const nan:0x8000000000000
+  call $~lib/util/hash/HASH<f64>
   call $std/hash/check
   drop
   global.get $~lib/memory/__stack_pointer
-  i32.const 8
+  i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
diff --git a/tests/compiler/std/map.optimized.wat b/tests/compiler/std/map.optimized.wat
index f07c4f15db..b9ed5ff757 100644
--- a/tests/compiler/std/map.optimized.wat
+++ b/tests/compiler/std/map.optimized.wat
@@ -1,17 +1,18 @@
 (module
  (type $i32_i32_=>_none (func (param i32 i32)))
  (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
- (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
  (type $none_=>_none (func))
+ (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $i32_=>_none (func (param i32)))
- (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
+ (type $i32_i32_i64_=>_i32 (func (param i32 i32 i64) (result i32)))
  (type $i32_i64_=>_i32 (func (param i32 i64) (result i32)))
  (type $i32_i64_=>_none (func (param i32 i64)))
  (type $i32_i64_i32_=>_none (func (param i32 i64 i32)))
  (type $i32_i64_i64_=>_none (func (param i32 i64 i64)))
  (type $none_=>_i32 (func (result i32)))
- (type $i32_i64_i32_=>_i32 (func (param i32 i64 i32) (result i32)))
+ (type $i32_i64_i64_=>_i32 (func (param i32 i64 i64) (result i32)))
  (type $i32_f32_=>_i32 (func (param i32 f32) (result i32)))
  (type $i32_f64_=>_i32 (func (param i32 f64) (result i32)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
@@ -22,9 +23,11 @@
  (type $i32_f64_=>_none (func (param i32 f64)))
  (type $i32_f64_i32_=>_none (func (param i32 f64 i32)))
  (type $i32_f64_f64_=>_none (func (param i32 f64 f64)))
- (type $i64_=>_i32 (func (param i64) (result i32)))
- (type $i32_f32_i32_=>_i32 (func (param i32 f32 i32) (result i32)))
- (type $i32_f64_i32_=>_i32 (func (param i32 f64 i32) (result i32)))
+ (type $i32_f32_i64_=>_i32 (func (param i32 f32 i64) (result i32)))
+ (type $i32_f64_i64_=>_i32 (func (param i32 f64 i64) (result i32)))
+ (type $i64_=>_i64 (func (param i64) (result i64)))
+ (type $f32_=>_i64 (func (param f32) (result i64)))
+ (type $f64_=>_i64 (func (param f64) (result i64)))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
  (memory $0 1)
  (data (i32.const 1036) "<")
@@ -1823,18 +1826,58 @@
  (func $~lib/map/Map<i8,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i8,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<i8> (param $0 i32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.const 24
+  i32.shl
+  i32.const 24
+  i32.shr_s
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600262
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
+ (func $~lib/map/Map<i8,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -1845,7 +1888,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -1862,7 +1905,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -1910,10 +1953,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -1942,13 +1985,12 @@
      i32.store offset=4
      local.get $2
      local.get $6
-     local.get $1
      local.get $7
-     i32.const -2128831035
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     i32.and
+     call $~lib/util/hash/HASH<i8>
+     local.get $1
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -1975,17 +2017,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2339,10 +2382,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -2371,13 +2414,12 @@
      i32.store8 offset=1
      local.get $2
      local.get $6
-     local.get $1
      local.get $7
-     i32.const -2128831035
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     i32.and
+     call $~lib/util/hash/HASH<i8>
+     local.get $1
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2404,60 +2446,66 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+ (func $~lib/util/hash/HASH<i32> (param $0 i32) (result i64)
+  (local $1 i64)
   local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600265
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
- (func $~lib/map/Map<i32,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i32,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -2468,7 +2516,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -2483,7 +2531,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -2531,10 +2579,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -2564,9 +2612,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2593,17 +2643,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2615,21 +2666,57 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u8> (param $0 i32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.const 255
+  i32.and
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600262
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
  (func $~lib/map/Map<u8,i32>#rehash (param $0 i32) (param $1 i32)
   (local $2 i32)
@@ -2670,10 +2757,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -2702,13 +2789,12 @@
      i32.store offset=4
      local.get $2
      local.get $6
-     local.get $1
      local.get $7
-     i32.const -2128831035
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     i32.and
+     call $~lib/util/hash/HASH<u8>
+     local.get $1
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2735,17 +2821,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2790,10 +2877,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -2822,13 +2909,12 @@
      i32.store8 offset=1
      local.get $2
      local.get $6
-     local.get $1
      local.get $7
-     i32.const -2128831035
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     i32.and
+     call $~lib/util/hash/HASH<u8>
+     local.get $1
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2855,44 +2941,70 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/util/hash/hash16 (param $0 i32) (result i32)
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+ (func $~lib/util/hash/HASH<i16> (param $0 i32) (result i64)
+  (local $1 i64)
   local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i32.const 16
+  i32.shl
+  i32.const 16
+  i32.shr_s
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600263
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
- (func $~lib/map/Map<i16,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i16,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -2903,7 +3015,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -2920,7 +3032,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -2968,10 +3080,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -3001,9 +3113,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash16
+     call $~lib/util/hash/HASH<i16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3030,17 +3144,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3094,10 +3209,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -3127,9 +3242,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash16
+     call $~lib/util/hash/HASH<i16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3156,22 +3273,59 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
+ (func $~lib/util/hash/HASH<u16> (param $0 i32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.const 65535
+  i32.and
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600263
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
  (func $~lib/map/Map<u16,i32>#rehash (param $0 i32) (param $1 i32)
   (local $2 i32)
   (local $3 i32)
@@ -3211,10 +3365,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -3244,9 +3398,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash16
+     call $~lib/util/hash/HASH<u16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3273,17 +3429,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3328,10 +3485,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -3361,9 +3518,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash16
+     call $~lib/util/hash/HASH<u16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3390,29 +3549,32 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/map/Map<u32,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u32,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3423,7 +3585,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3438,7 +3600,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3486,10 +3648,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -3519,9 +3681,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3548,17 +3712,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3603,10 +3768,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -3636,9 +3801,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3665,95 +3832,68 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/util/hash/hash64 (param $0 i64) (result i32)
-  (local $1 i32)
+ (func $~lib/util/hash/HASH<i64> (param $0 i64) (result i64)
   local.get $0
-  i32.wrap_i64
-  local.tee $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600269
+  i64.xor
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 8796714831421723037
+  i64.sub
+  local.tee $0
+  local.get $0
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $0
+  local.get $0
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $0
   local.get $0
   i64.const 32
   i64.shr_u
-  i32.wrap_i64
-  local.tee $1
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.xor
  )
- (func $~lib/map/Map<i64,i32>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i64,i32>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3764,7 +3904,7 @@
    if
     local.get $0
     i32.load offset=12
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3779,7 +3919,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3828,10 +3968,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 4
   i32.shl
   i32.add
@@ -3861,9 +4001,11 @@
      local.get $2
      local.get $8
      local.get $5
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3890,17 +4032,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3955,10 +4098,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 24
   i32.mul
   i32.add
@@ -3988,9 +4131,11 @@
      local.get $2
      local.get $8
      local.get $5
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4017,17 +4162,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -4039,29 +4185,31 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/map/Map<u64,i32>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u64,i32>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -4072,7 +4220,7 @@
    if
     local.get $0
     i32.load offset=12
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -4087,7 +4235,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -4136,10 +4284,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 4
   i32.shl
   i32.add
@@ -4169,9 +4317,11 @@
      local.get $2
      local.get $8
      local.get $5
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4198,17 +4348,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -4254,10 +4405,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 24
   i32.mul
   i32.add
@@ -4287,9 +4438,11 @@
      local.get $2
      local.get $8
      local.get $5
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4316,29 +4469,67 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/map/Map<f32,i32>#find (param $0 i32) (param $1 f32) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<f32> (param $0 f32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.reinterpret_f32
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600265
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
+ (func $~lib/map/Map<f32,i32>#find (param $0 i32) (param $1 f32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -4349,7 +4540,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -4364,7 +4555,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -4413,10 +4604,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -4446,10 +4637,11 @@
      local.get $2
      local.get $8
      local.get $5
-     i32.reinterpret_f32
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<f32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4476,17 +4668,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -4532,10 +4725,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -4565,10 +4758,11 @@
      local.get $2
      local.get $8
      local.get $5
-     i32.reinterpret_f32
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<f32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4595,29 +4789,70 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/map/Map<f64,i32>#find (param $0 i32) (param $1 f64) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<f64> (param $0 f64) (result i64)
+  (local $1 i64)
+  local.get $0
+  i64.reinterpret_f64
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600269
+  i64.xor
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 8796714831421723037
+  i64.sub
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
+ (func $~lib/map/Map<f64,i32>#find (param $0 i32) (param $1 f64) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -4628,7 +4863,7 @@
    if
     local.get $0
     i32.load offset=12
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -4643,7 +4878,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -4692,10 +4927,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 4
   i32.shl
   i32.add
@@ -4725,10 +4960,11 @@
      local.get $2
      local.get $8
      local.get $5
-     i64.reinterpret_f64
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<f64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4755,17 +4991,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -4811,10 +5048,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 24
   i32.mul
   i32.add
@@ -4844,10 +5081,11 @@
      local.get $2
      local.get $8
      local.get $5
-     i64.reinterpret_f64
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<f64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -4874,17 +5112,18 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -4922,7 +5161,7 @@
    i32.load
    call $~lib/rt/itcms/__visit
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    call $~lib/rt/itcms/__visit
    return
   end
@@ -5012,14 +5251,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<i8>
   call $~lib/map/Map<i8,i32>#find
   i32.const 0
   i32.ne
@@ -5030,7 +5262,7 @@
  )
  (func $~lib/map/Map<i8,i32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5040,23 +5272,15 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
+  local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store
-  local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.tee $3
-  local.set $4
   local.get $0
   local.get $1
-  local.get $3
+  local.get $4
   call $~lib/map/Map<i8,i32>#find
   local.tee $3
   if
@@ -5065,9 +5289,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -5075,39 +5299,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i8,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -5121,17 +5346,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -5162,14 +5388,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<i8>
   call $~lib/map/Map<i8,i32>#find
   local.tee $0
   i32.eqz
@@ -5255,11 +5474,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $0
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5441,11 +5660,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $4
   call $~lib/array/Array<i32>#constructor
   local.tee $0
@@ -5501,7 +5720,7 @@
  (func $~lib/map/Map<i8,i8>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -5510,25 +5729,21 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
+  local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store
+  local.get $1
+  local.set $3
   local.get $0
   i32.load
-  local.get $1
-  local.tee $3
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.tee $5
+  local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -5571,9 +5786,9 @@
    i32.store8 offset=1
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -5581,39 +5796,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i8,i8>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $1
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $1
    local.get $4
    i32.const 3
@@ -5627,17 +5843,18 @@
    i32.store8 offset=1
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $1
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -5655,7 +5872,7 @@
  )
  (func $~lib/map/Map<i32,i32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5666,7 +5883,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -5682,9 +5899,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -5692,39 +5909,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i32,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -5738,17 +5956,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -5780,14 +5999,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<i8>
   call $~lib/map/Map<i8,i32>#find
   local.tee $1
   i32.eqz
@@ -5806,20 +6018,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -5828,9 +6041,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -5885,7 +6098,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 3
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -5895,21 +6108,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -6000,7 +6213,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6120,7 +6333,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6157,7 +6370,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 6
   call $~lib/rt/itcms/__new
   local.tee $1
@@ -6167,21 +6380,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $1
-  i32.const 3
-  i32.store offset=4
-  local.get $1
+  i64.const 3
+  i64.store offset=8
+  local.get $1
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $1
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $1
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $1
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -6289,7 +6502,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6304,7 +6517,7 @@
   local.get $4
   i32.store offset=4
   local.get $4
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6394,7 +6607,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -6489,7 +6702,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -6509,7 +6722,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -6538,12 +6751,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<u8>
   call $~lib/map/Map<i8,i32>#find
   i32.const 0
   i32.ne
@@ -6554,7 +6762,7 @@
  )
  (func $~lib/map/Map<u8,i32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6564,21 +6772,15 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
+  local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store
-  local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.tee $3
-  local.set $4
   local.get $0
   local.get $1
-  local.get $3
+  local.get $4
   call $~lib/map/Map<i8,i32>#find
   local.tee $3
   if
@@ -6587,9 +6789,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -6597,39 +6799,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u8,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -6643,17 +6846,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -6684,12 +6888,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<u8>
   call $~lib/map/Map<i8,i32>#find
   local.tee $0
   i32.eqz
@@ -6724,11 +6923,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $0
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6845,7 +7044,7 @@
  (func $~lib/map/Map<u8,u8>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -6854,23 +7053,21 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
+  local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store
+  local.get $1
+  local.set $3
   local.get $0
   i32.load
-  local.get $1
-  local.tee $3
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.tee $5
+  local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -6913,9 +7110,9 @@
    i32.store8 offset=1
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -6923,39 +7120,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u8,u8>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $1
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $1
    local.get $4
    i32.const 3
@@ -6969,17 +7167,18 @@
    i32.store8 offset=1
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $1
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -7011,12 +7210,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<u8>
   call $~lib/map/Map<i8,i32>#find
   local.tee $1
   i32.eqz
@@ -7035,20 +7229,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -7057,9 +7252,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -7114,7 +7309,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 8
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -7124,21 +7319,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -7223,7 +7418,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7335,7 +7530,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7372,7 +7567,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 10
   call $~lib/rt/itcms/__new
   local.tee $1
@@ -7382,21 +7577,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $1
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $1
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $1
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $1
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $1
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -7504,7 +7699,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7519,7 +7714,7 @@
   local.get $4
   i32.store offset=4
   local.get $4
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7605,7 +7800,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -7696,7 +7891,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -7716,7 +7911,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -7745,11 +7940,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   call $~lib/map/Map<i16,i32>#find
   i32.const 0
   i32.ne
@@ -7760,7 +7951,7 @@
  )
  (func $~lib/map/Map<i16,i32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -7771,11 +7962,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -7791,9 +7978,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -7801,39 +7988,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i16,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -7847,17 +8035,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -7888,11 +8077,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   call $~lib/map/Map<i16,i32>#find
   local.tee $0
   i32.eqz
@@ -7982,11 +8167,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -8107,7 +8292,7 @@
  (func $~lib/map/Map<i16,i16>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -8117,11 +8302,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -8132,8 +8313,9 @@
   i32.load
   local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -8176,9 +8358,9 @@
    i32.store16 offset=2
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -8186,39 +8368,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i16,i16>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $1
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $1
    local.get $4
    i32.const 3
@@ -8232,17 +8415,18 @@
    i32.store16 offset=2
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $1
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -8274,11 +8458,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   call $~lib/map/Map<i16,i32>#find
   local.tee $1
   i32.eqz
@@ -8297,20 +8477,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -8319,9 +8500,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -8376,7 +8557,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 11
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -8386,21 +8567,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -8491,7 +8672,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -8611,7 +8792,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -8648,7 +8829,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 13
   call $~lib/rt/itcms/__new
   local.tee $1
@@ -8658,21 +8839,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $1
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $1
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $1
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $1
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $1
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -8782,7 +8963,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -8797,7 +8978,7 @@
   local.get $4
   i32.store offset=4
   local.get $4
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -8887,7 +9068,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -8982,7 +9163,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -9002,7 +9183,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -9031,9 +9212,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   call $~lib/map/Map<i16,i32>#find
   i32.const 0
   i32.ne
@@ -9044,7 +9223,7 @@
  )
  (func $~lib/map/Map<u16,i32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -9055,9 +9234,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -9073,9 +9250,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -9083,39 +9260,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u16,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -9129,17 +9307,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -9170,9 +9349,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   call $~lib/map/Map<i16,i32>#find
   local.tee $0
   i32.eqz
@@ -9209,11 +9386,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -9334,7 +9511,7 @@
  (func $~lib/map/Map<u16,u16>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -9344,9 +9521,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -9357,8 +9532,9 @@
   i32.load
   local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -9401,9 +9577,9 @@
    i32.store16 offset=2
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -9411,39 +9587,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u16,u16>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $1
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $1
    local.get $4
    i32.const 3
@@ -9457,17 +9634,18 @@
    i32.store16 offset=2
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $1
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -9499,9 +9677,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   call $~lib/map/Map<i16,i32>#find
   local.tee $1
   i32.eqz
@@ -9520,20 +9696,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -9542,9 +9719,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -9599,7 +9776,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 14
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -9609,21 +9786,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -9708,7 +9885,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -9820,7 +9997,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -9857,7 +10034,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 16
   call $~lib/rt/itcms/__new
   local.tee $1
@@ -9867,21 +10044,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $1
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $1
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $1
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $1
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $1
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -9991,7 +10168,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10006,7 +10183,7 @@
   local.get $4
   i32.store offset=4
   local.get $4
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10092,7 +10269,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -10183,7 +10360,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -10203,7 +10380,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -10232,7 +10409,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<i32,i32>#find
   i32.const 0
   i32.ne
@@ -10256,7 +10433,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<i32,i32>#find
   local.tee $0
   i32.eqz
@@ -10291,7 +10468,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<i32,i32>#find
   local.tee $1
   i32.eqz
@@ -10310,20 +10487,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -10332,9 +10510,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -10456,7 +10634,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10560,7 +10738,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10584,11 +10762,11 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $1
-  i32.load offset=16
+  i32.load offset=24
   local.tee $7
   call $~lib/array/Array<i32>#constructor
   local.tee $2
@@ -10740,7 +10918,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10755,7 +10933,7 @@
   local.get $4
   i32.store offset=4
   local.get $4
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10837,7 +11015,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -10924,7 +11102,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -10944,7 +11122,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -10973,7 +11151,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<u32,i32>#find
   i32.const 0
   i32.ne
@@ -10984,7 +11162,7 @@
  )
  (func $~lib/map/Map<u32,i32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -10995,7 +11173,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -11011,9 +11189,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -11021,39 +11199,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u32,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -11067,17 +11246,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -11108,7 +11288,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<u32,i32>#find
   local.tee $0
   i32.eqz
@@ -11145,11 +11325,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -11269,7 +11449,7 @@
  )
  (func $~lib/map/Map<u32,u32>#set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -11280,7 +11460,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -11296,9 +11476,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -11306,39 +11486,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u32,u32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -11352,17 +11533,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -11394,7 +11576,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<u32,i32>#find
   local.tee $1
   i32.eqz
@@ -11413,20 +11595,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -11435,9 +11618,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -11492,7 +11675,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 17
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -11502,21 +11685,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -11595,7 +11778,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -11699,7 +11882,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -11736,7 +11919,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 19
   call $~lib/rt/itcms/__new
   local.tee $1
@@ -11746,21 +11929,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $1
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $1
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $1
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $1
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $1
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -11870,7 +12053,7 @@
   local.get $1
   i32.store offset=4
   local.get $1
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -11885,7 +12068,7 @@
   local.get $4
   i32.store offset=4
   local.get $4
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -11967,7 +12150,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -12054,7 +12237,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -12074,7 +12257,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -12103,7 +12286,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<i64,i32>#find
   i32.const 0
   i32.ne
@@ -12114,7 +12297,7 @@
  )
  (func $~lib/map/Map<i64,i32>#set (param $0 i32) (param $1 i64) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -12125,7 +12308,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -12141,9 +12324,9 @@
    i32.store offset=8
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -12151,39 +12334,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i64,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 4
@@ -12197,17 +12381,18 @@
    i32.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -12238,7 +12423,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<i64,i32>#find
   local.tee $0
   i32.eqz
@@ -12328,11 +12513,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -12465,11 +12650,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $4
   call $~lib/array/Array<i32>#constructor
   local.tee $0
@@ -12525,7 +12710,7 @@
  (func $~lib/map/Map<i64,i64>#set (param $0 i32) (param $1 i64) (param $2 i64)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -12535,7 +12720,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -12544,8 +12729,9 @@
   i32.load
   local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -12586,9 +12772,9 @@
    i64.store offset=8
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -12596,39 +12782,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i64,i64>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $4
    i32.const 24
@@ -12642,17 +12829,18 @@
    i64.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -12685,7 +12873,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<i64,i32>#find
   local.tee $2
   i32.eqz
@@ -12704,20 +12892,21 @@
   i32.store offset=12
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -12726,9 +12915,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -12783,7 +12972,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 20
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12793,21 +12982,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12888,7 +13077,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -12995,7 +13184,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -13032,7 +13221,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 22
   call $~lib/rt/itcms/__new
   local.tee $2
@@ -13042,21 +13231,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $2
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $2
   i32.const 96
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $2
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $2
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $2
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -13167,7 +13356,7 @@
   local.get $2
   i32.store offset=4
   local.get $2
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -13182,7 +13371,7 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -13265,7 +13454,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -13353,7 +13542,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -13373,7 +13562,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -13402,7 +13591,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<u64,i32>#find
   i32.const 0
   i32.ne
@@ -13413,7 +13602,7 @@
  )
  (func $~lib/map/Map<u64,i32>#set (param $0 i32) (param $1 i64) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -13424,7 +13613,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -13440,9 +13629,9 @@
    i32.store offset=8
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -13450,39 +13639,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
-     local.get $0
-     i32.load offset=4
-    else
+    if (result i64)
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+    else
+     local.get $0
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u64,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 4
@@ -13496,17 +13686,18 @@
    i32.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -13537,7 +13728,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<u64,i32>#find
   local.tee $0
   i32.eqz
@@ -13574,11 +13765,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -13699,7 +13890,7 @@
  (func $~lib/map/Map<u64,u64>#set (param $0 i32) (param $1 i64) (param $2 i64)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -13709,7 +13900,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -13718,8 +13909,9 @@
   i32.load
   local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -13760,9 +13952,9 @@
    i64.store offset=8
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -13770,39 +13962,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u64,u64>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $4
    i32.const 24
@@ -13816,17 +14009,18 @@
    i64.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -13859,7 +14053,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<u64,i32>#find
   local.tee $2
   i32.eqz
@@ -13878,20 +14072,21 @@
   i32.store offset=12
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -13900,9 +14095,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -13957,7 +14152,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 23
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -13967,21 +14162,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -14062,7 +14257,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -14169,7 +14364,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -14206,7 +14401,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 25
   call $~lib/rt/itcms/__new
   local.tee $2
@@ -14216,21 +14411,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $2
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $2
   i32.const 96
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $2
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $2
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $2
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -14341,7 +14536,7 @@
   local.get $2
   i32.store offset=4
   local.get $2
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -14356,7 +14551,7 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -14439,7 +14634,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -14527,7 +14722,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -14547,7 +14742,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -14576,8 +14771,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   call $~lib/map/Map<f32,i32>#find
   i32.const 0
   i32.ne
@@ -14588,7 +14782,7 @@
  )
  (func $~lib/map/Map<f32,i32>#set (param $0 i32) (param $1 f32) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -14599,8 +14793,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -14616,9 +14809,9 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -14626,39 +14819,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f32,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -14672,17 +14866,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -14713,8 +14908,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   call $~lib/map/Map<f32,i32>#find
   local.tee $0
   i32.eqz
@@ -14752,11 +14946,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -14924,7 +15118,7 @@
  )
  (func $~lib/map/Map<f32,f32>#set (param $0 i32) (param $1 f32) (param $2 f32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -14935,8 +15129,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -14952,9 +15145,9 @@
    f32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -14962,39 +15155,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f32,f32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 12
@@ -15008,17 +15202,18 @@
    f32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -15051,8 +15246,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   call $~lib/map/Map<f32,i32>#find
   local.tee $2
   i32.eqz
@@ -15071,20 +15265,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -15093,9 +15288,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -15150,7 +15345,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 26
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -15160,21 +15355,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -15255,7 +15450,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -15362,7 +15557,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -15399,7 +15594,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 28
   call $~lib/rt/itcms/__new
   local.tee $2
@@ -15409,21 +15604,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $2
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $2
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $2
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $2
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $2
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -15534,7 +15729,7 @@
   local.get $2
   i32.store offset=4
   local.get $2
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -15549,7 +15744,7 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -15632,7 +15827,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -15720,7 +15915,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -15740,7 +15935,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -15769,8 +15964,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   call $~lib/map/Map<f64,i32>#find
   i32.const 0
   i32.ne
@@ -15781,7 +15975,7 @@
  )
  (func $~lib/map/Map<f64,i32>#set (param $0 i32) (param $1 f64) (param $2 i32)
   (local $3 i32)
-  (local $4 i32)
+  (local $4 i64)
   (local $5 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -15792,8 +15986,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   local.set $4
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -15809,9 +16002,9 @@
    i32.store offset=8
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -15819,39 +16012,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f64,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $5
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $5
    i32.const 4
@@ -15865,17 +16059,18 @@
    i32.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $4
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -15906,8 +16101,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   call $~lib/map/Map<f64,i32>#find
   local.tee $0
   i32.eqz
@@ -15945,11 +16139,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -16118,7 +16312,7 @@
  (func $~lib/map/Map<f64,f64>#set (param $0 i32) (param $1 f64) (param $2 f64)
   (local $3 i32)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -16128,8 +16322,7 @@
   i64.const 0
   i64.store
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -16138,8 +16331,9 @@
   i32.load
   local.get $5
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -16180,9 +16374,9 @@
    f64.store offset=8
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -16190,39 +16384,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f64,f64>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $3
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $3
    local.get $4
    i32.const 24
@@ -16236,17 +16431,18 @@
    f64.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $3
    local.get $0
    i32.load
    local.get $5
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -16279,8 +16475,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   call $~lib/map/Map<f64,i32>#find
   local.tee $2
   i32.eqz
@@ -16299,20 +16494,21 @@
   i32.store offset=12
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -16321,9 +16517,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -16378,7 +16574,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 29
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -16388,21 +16584,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -16483,7 +16679,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -16590,7 +16786,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -16627,7 +16823,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 31
   call $~lib/rt/itcms/__new
   local.tee $2
@@ -16637,21 +16833,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $2
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $2
   i32.const 96
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $2
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $2
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $2
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -16762,7 +16958,7 @@
   local.get $2
   i32.store offset=4
   local.get $2
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -16777,7 +16973,7 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -16860,7 +17056,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -16948,7 +17144,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -16968,7 +17164,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -17100,7 +17296,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 7
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -17110,21 +17306,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 48
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
diff --git a/tests/compiler/std/map.untouched.wat b/tests/compiler/std/map.untouched.wat
index a8ae8ab7df..7c2f82c2ef 100644
--- a/tests/compiler/std/map.untouched.wat
+++ b/tests/compiler/std/map.untouched.wat
@@ -2,29 +2,35 @@
  (type $i32_i32_=>_none (func (param i32 i32)))
  (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
- (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i64_=>_none (func (param i32 i64)))
  (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
  (type $i32_=>_none (func (param i32)))
  (type $none_=>_none (func))
- (type $i32_i64_=>_none (func (param i32 i64)))
+ (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i32_i64_=>_i32 (func (param i32 i32 i64) (result i32)))
  (type $i32_i64_=>_i32 (func (param i32 i64) (result i32)))
- (type $i32_i64_i32_=>_i32 (func (param i32 i64 i32) (result i32)))
+ (type $i32_i64_i64_=>_i32 (func (param i32 i64 i64) (result i32)))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
  (type $i32_i32_i64_=>_none (func (param i32 i32 i64)))
  (type $i32_f32_=>_none (func (param i32 f32)))
  (type $i32_f64_=>_none (func (param i32 f64)))
  (type $i32_f32_=>_i32 (func (param i32 f32) (result i32)))
- (type $i32_f32_i32_=>_i32 (func (param i32 f32 i32) (result i32)))
  (type $i32_f64_=>_i32 (func (param i32 f64) (result i32)))
- (type $i32_f64_i32_=>_i32 (func (param i32 f64 i32) (result i32)))
  (type $i32_i32_f32_=>_none (func (param i32 i32 f32)))
  (type $i32_i32_f64_=>_none (func (param i32 i32 f64)))
- (type $i32_i64_i64_=>_i32 (func (param i32 i64 i64) (result i32)))
+ (type $i32_i64_i32_=>_i32 (func (param i32 i64 i32) (result i32)))
+ (type $i32_f32_i64_=>_i32 (func (param i32 f32 i64) (result i32)))
+ (type $i32_f64_i64_=>_i32 (func (param i32 f64 i64) (result i32)))
+ (type $i64_=>_i64 (func (param i64) (result i64)))
  (type $i32_i32_=>_i64 (func (param i32 i32) (result i64)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
  (type $none_=>_i32 (func (result i32)))
- (type $i64_=>_i32 (func (param i64) (result i32)))
+ (type $i32_f32_i32_=>_i32 (func (param i32 f32 i32) (result i32)))
  (type $i32_f32_f32_=>_i32 (func (param i32 f32 f32) (result i32)))
+ (type $i32_f64_i32_=>_i32 (func (param i32 f64 i32) (result i32)))
  (type $i32_f64_f64_=>_i32 (func (param i32 f64 f64) (result i32)))
+ (type $f32_=>_i64 (func (param f32) (result i64)))
+ (type $f64_=>_i64 (func (param f64) (result i64)))
  (type $i32_i32_=>_f32 (func (param i32 i32) (result f32)))
  (type $i32_i32_=>_f64 (func (param i32 i32) (result f64)))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
@@ -2453,15 +2459,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i8,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i8,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i8,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -2470,26 +2476,91 @@
  (func $~lib/map/Map<i8,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i8,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i8,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash8 (param $0 i32) (result i32)
-  i32.const -2128831035
+ (func $~lib/util/hash/HASH<i8> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i32.const 24
+  i32.shl
+  i32.const 24
+  i32.shr_s
+  local.set $2
+  i64.const 1
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/map/Map<i8,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i8,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -2497,8 +2568,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -2607,11 +2679,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -2645,25 +2717,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<i8,i32>#set:value
-     block $~lib/util/hash/HASH<i8>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      i32.const 1
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash8
-      br $~lib/util/hash/HASH<i8>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i8>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -2695,6 +2754,7 @@
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i8,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -2704,7 +2764,7 @@
   call $~lib/map/Map<i8,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i8,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -2713,7 +2773,7 @@
  )
  (func $~lib/map/Map<i8,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i8>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -4178,15 +4238,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i8,i8>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i8,i8>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i8,i8>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -4195,17 +4255,17 @@
  (func $~lib/map/Map<i8,i8>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i8,i8>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i8,i8>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/map/Map<i32,i32>#set:buckets (param $0 i32) (param $1 i32)
   local.get $0
@@ -4216,15 +4276,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i32,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i32,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i32,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -4233,17 +4293,17 @@
  (func $~lib/map/Map<i32,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i32,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i32,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<i8>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -4301,7 +4361,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<i8,i8>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i8,i8>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -4309,8 +4369,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -4419,11 +4480,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -4457,25 +4518,12 @@
      local.get $10
      i32.load8_s offset=1
      call $~lib/map/MapEntry<i8,i8>#set:value
-     block $~lib/util/hash/HASH<i8>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      i32.const 1
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash8
-      br $~lib/util/hash/HASH<i8>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i8>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -4507,6 +4555,7 @@
   call $~lib/map/Map<i8,i8>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i8,i8>#set:bucketsMask
   local.get $0
   local.get $5
@@ -4516,56 +4565,82 @@
   call $~lib/map/Map<i8,i8>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i8,i8>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  (local $1 i32)
-  i32.const -2128831035
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
+ (func $~lib/util/hash/HASH<i32> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 4
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  local.set $2
+  i64.const 4
   local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
   local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/map/Map<i32,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i32,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -4573,8 +4648,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -4679,11 +4755,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -4717,33 +4793,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<i32,i32>#set:value
-     block $~lib/util/hash/HASH<i32>|inlined.1 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 4
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<i32>|inlined.1
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -4775,6 +4830,7 @@
   call $~lib/map/Map<i32,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i32,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -4784,7 +4840,7 @@
   call $~lib/map/Map<i32,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i32,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4793,11 +4849,11 @@
  )
  (func $~lib/map/Map<i8,i8>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<i32,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<i8,i32>#clear (param $0 i32)
   local.get $0
@@ -4808,9 +4864,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i8,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -4838,15 +4894,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u8,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u8,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u8,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -4855,35 +4911,106 @@
  (func $~lib/map/Map<u8,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u8,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u8,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/map/Map<u8,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
-  (local $4 i32)
-  (local $5 i32)
-  local.get $0
-  i32.load
-  local.get $2
+ (func $~lib/util/hash/HASH<u8> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.load offset=4
+  i32.const 255
   i32.and
-  i32.const 4
-  i32.mul
-  i32.add
-  i32.load
-  local.set $3
-  loop $while-continue|0
-   local.get $3
+  local.set $2
+  i64.const 1
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
+ )
+ (func $~lib/map/Map<u8,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  local.get $0
+  i32.load
+  local.get $2
+  local.get $0
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
+  i32.const 4
+  i32.mul
+  i32.add
+  i32.load
+  local.set $3
+  loop $while-continue|0
+   local.get $3
    local.set $4
    local.get $4
    if
@@ -4983,11 +5110,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -5021,25 +5148,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<u8,i32>#set:value
-     block $~lib/util/hash/HASH<u8>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      i32.const 1
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash8
-      br $~lib/util/hash/HASH<u8>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u8>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -5071,6 +5185,7 @@
   call $~lib/map/Map<u8,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u8,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -5080,7 +5195,7 @@
   call $~lib/map/Map<u8,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u8,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5089,7 +5204,7 @@
  )
  (func $~lib/map/Map<u8,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u8>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -5145,15 +5260,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u8,u8>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u8,u8>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u8,u8>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -5162,17 +5277,17 @@
  (func $~lib/map/Map<u8,u8>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u8,u8>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u8,u8>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<u8>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -5204,7 +5319,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<u8,u8>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u8,u8>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -5212,8 +5327,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -5320,11 +5436,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -5358,25 +5474,12 @@
      local.get $10
      i32.load8_u offset=1
      call $~lib/map/MapEntry<u8,u8>#set:value
-     block $~lib/util/hash/HASH<u8>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      i32.const 1
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash8
-      br $~lib/util/hash/HASH<u8>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u8>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -5408,6 +5511,7 @@
   call $~lib/map/Map<u8,u8>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u8,u8>#set:bucketsMask
   local.get $0
   local.get $5
@@ -5417,7 +5521,7 @@
   call $~lib/map/Map<u8,u8>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u8,u8>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5426,7 +5530,7 @@
  )
  (func $~lib/map/Map<u8,u8>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<u8,i32>#clear (param $0 i32)
   local.get $0
@@ -5437,9 +5541,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u8,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u8,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -5467,15 +5571,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i16,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i16,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i16,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -5484,41 +5588,91 @@
  (func $~lib/map/Map<i16,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i16,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i16,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash16 (param $0 i32) (result i32)
-  (local $1 i32)
-  i32.const -2128831035
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
+ (func $~lib/util/hash/HASH<i16> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 2
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i32.const 16
+  i32.shl
+  i32.const 16
+  i32.shr_s
+  local.set $2
+  i64.const 2
   local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
   local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/map/Map<i16,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i16,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -5526,8 +5680,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -5636,11 +5791,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -5674,29 +5829,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<i16,i32>#set:value
-     block $~lib/util/hash/HASH<i16>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 2
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 2
-      i32.const 2
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash16
-      br $~lib/util/hash/HASH<i16>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -5728,6 +5866,7 @@
   call $~lib/map/Map<i16,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i16,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -5737,7 +5876,7 @@
   call $~lib/map/Map<i16,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i16,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5746,7 +5885,7 @@
  )
  (func $~lib/map/Map<i16,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i16>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -5802,15 +5941,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i16,i16>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i16,i16>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i16,i16>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -5819,17 +5958,17 @@
  (func $~lib/map/Map<i16,i16>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i16,i16>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i16,i16>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<i16>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -5861,7 +6000,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<i16,i16>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i16,i16>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -5869,8 +6008,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -5979,11 +6119,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -6017,29 +6157,12 @@
      local.get $10
      i32.load16_s offset=2
      call $~lib/map/MapEntry<i16,i16>#set:value
-     block $~lib/util/hash/HASH<i16>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 2
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 2
-      i32.const 2
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash16
-      br $~lib/util/hash/HASH<i16>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -6071,6 +6194,7 @@
   call $~lib/map/Map<i16,i16>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i16,i16>#set:bucketsMask
   local.get $0
   local.get $5
@@ -6080,7 +6204,7 @@
   call $~lib/map/Map<i16,i16>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i16,i16>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6089,7 +6213,7 @@
  )
  (func $~lib/map/Map<i16,i16>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<i16,i32>#clear (param $0 i32)
   local.get $0
@@ -6100,9 +6224,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i16,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i16,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6130,15 +6254,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u16,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u16,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u16,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -6147,45 +6271,116 @@
  (func $~lib/map/Map<u16,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u16,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u16,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/map/Map<u16,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
-  (local $4 i32)
-  (local $5 i32)
-  local.get $0
-  i32.load
-  local.get $2
+ (func $~lib/util/hash/HASH<u16> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 2
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.load offset=4
+  i32.const 65535
   i32.and
-  i32.const 4
-  i32.mul
-  i32.add
-  i32.load
+  local.set $2
+  i64.const 2
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
   local.set $3
-  loop $while-continue|0
-   local.get $3
-   local.set $4
-   local.get $4
-   if
-    local.get $3
-    i32.load offset=8
-    local.set $5
-    local.get $5
-    i32.const 1
-    i32.and
-    i32.eqz
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
+ )
+ (func $~lib/map/Map<u16,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  local.get $0
+  i32.load
+  local.get $2
+  local.get $0
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
+  i32.const 4
+  i32.mul
+  i32.add
+  i32.load
+  local.set $3
+  loop $while-continue|0
+   local.get $3
+   local.set $4
+   local.get $4
+   if
+    local.get $3
+    i32.load offset=8
+    local.set $5
+    local.get $5
+    i32.const 1
+    i32.and
+    i32.eqz
     if (result i32)
      local.get $3
      i32.load16_u
@@ -6275,11 +6470,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -6313,29 +6508,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<u16,i32>#set:value
-     block $~lib/util/hash/HASH<u16>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 2
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 2
-      i32.const 2
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash16
-      br $~lib/util/hash/HASH<u16>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -6367,6 +6545,7 @@
   call $~lib/map/Map<u16,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u16,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -6376,7 +6555,7 @@
   call $~lib/map/Map<u16,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u16,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6385,7 +6564,7 @@
  )
  (func $~lib/map/Map<u16,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u16>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -6441,15 +6620,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u16,u16>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u16,u16>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u16,u16>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -6458,17 +6637,17 @@
  (func $~lib/map/Map<u16,u16>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u16,u16>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u16,u16>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<u16>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -6500,7 +6679,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<u16,u16>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u16,u16>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -6508,8 +6687,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -6616,11 +6796,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -6654,29 +6834,12 @@
      local.get $10
      i32.load16_u offset=2
      call $~lib/map/MapEntry<u16,u16>#set:value
-     block $~lib/util/hash/HASH<u16>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 2
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 2
-      i32.const 2
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash16
-      br $~lib/util/hash/HASH<u16>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -6708,6 +6871,7 @@
   call $~lib/map/Map<u16,u16>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u16,u16>#set:bucketsMask
   local.get $0
   local.get $5
@@ -6717,7 +6881,7 @@
   call $~lib/map/Map<u16,u16>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u16,u16>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6726,7 +6890,7 @@
  )
  (func $~lib/map/Map<u16,u16>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<u16,i32>#clear (param $0 i32)
   local.get $0
@@ -6737,9 +6901,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u16,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u16,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6771,9 +6935,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i32,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i32,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6801,15 +6965,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u32,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u32,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u32,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -6818,19 +6982,87 @@
  (func $~lib/map/Map<u32,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u32,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u32,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u32> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 4
+  i32.const 4
+  i32.le_u
+  drop
+  local.get $0
+  local.set $2
+  i64.const 4
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/map/Map<u32,i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u32,i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -6838,8 +7070,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -6944,11 +7177,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -6982,33 +7215,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<u32,i32>#set:value
-     block $~lib/util/hash/HASH<u32>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 4
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<u32>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -7040,6 +7252,7 @@
   call $~lib/map/Map<u32,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u32,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -7049,7 +7262,7 @@
   call $~lib/map/Map<u32,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u32,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -7058,7 +7271,7 @@
  )
  (func $~lib/map/Map<u32,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u32>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -7114,15 +7327,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u32,u32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u32,u32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u32,u32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -7131,17 +7344,17 @@
  (func $~lib/map/Map<u32,u32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u32,u32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u32,u32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<u32>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -7173,7 +7386,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<u32,u32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u32,u32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -7181,8 +7394,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -7287,11 +7501,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -7325,33 +7539,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<u32,u32>#set:value
-     block $~lib/util/hash/HASH<u32>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 4
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<u32>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -7383,6 +7576,7 @@
   call $~lib/map/Map<u32,u32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u32,u32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -7392,7 +7586,7 @@
   call $~lib/map/Map<u32,u32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u32,u32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -7401,7 +7595,7 @@
  )
  (func $~lib/map/Map<u32,u32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<u32,i32>#clear (param $0 i32)
   local.get $0
@@ -7412,9 +7606,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u32,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u32,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -7442,15 +7636,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i64,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i64,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i64,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -7459,107 +7653,91 @@
  (func $~lib/map/Map<i64,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i64,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i64,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash64 (param $0 i64) (result i32)
-  (local $1 i32)
-  (local $2 i32)
-  (local $3 i32)
+ (func $~lib/util/hash/HASH<i64> (param $0 i64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 8
+  i32.const 4
+  i32.le_u
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
   local.get $0
-  i32.wrap_i64
   local.set $1
-  local.get $0
-  i64.const 32
-  i64.shr_u
-  i32.wrap_i64
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
   local.set $2
-  i32.const -2128831035
-  local.set $3
-  local.get $3
+  local.get $2
   local.get $1
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
-  local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
   local.get $2
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
   local.get $2
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
   local.get $2
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
   local.get $2
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
  )
- (func $~lib/map/Map<i64,i32>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i64,i32>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -7567,8 +7745,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -7636,9 +7815,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i64)
-  (local $13 i64)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -7674,11 +7852,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 16
   i32.mul
   i32.add
@@ -7712,49 +7890,24 @@
      local.get $10
      i32.load offset=8
      call $~lib/map/MapEntry<i64,i32>#set:value
-     block $~lib/util/hash/HASH<i64>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 8
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<i64>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<i64,i32>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -7774,6 +7927,7 @@
   call $~lib/map/Map<i64,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i64,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -7783,7 +7937,7 @@
   call $~lib/map/Map<i64,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i64,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -7792,7 +7946,7 @@
  )
  (func $~lib/map/Map<i64,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i64>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -7848,15 +8002,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<i64,i64>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<i64,i64>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<i64,i64>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -7865,17 +8019,17 @@
  (func $~lib/map/Map<i64,i64>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<i64,i64>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<i64,i64>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<i64>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -7907,7 +8061,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<i64,i64>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<i64,i64>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -7915,8 +8069,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -7984,9 +8139,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i64)
-  (local $13 i64)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -8022,11 +8176,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 24
   i32.mul
   i32.add
@@ -8060,49 +8214,24 @@
      local.get $10
      i64.load offset=8
      call $~lib/map/MapEntry<i64,i64>#set:value
-     block $~lib/util/hash/HASH<i64>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 8
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<i64>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<i64,i64>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -8122,6 +8251,7 @@
   call $~lib/map/Map<i64,i64>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<i64,i64>#set:bucketsMask
   local.get $0
   local.get $5
@@ -8131,7 +8261,7 @@
   call $~lib/map/Map<i64,i64>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<i64,i64>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -8140,7 +8270,7 @@
  )
  (func $~lib/map/Map<i64,i64>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<i64,i32>#clear (param $0 i32)
   local.get $0
@@ -8151,9 +8281,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i64,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i64,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -8181,15 +8311,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u64,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u64,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u64,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -8198,19 +8328,91 @@
  (func $~lib/map/Map<u64,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u64,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u64,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u64> (param $0 i64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 8
+  i32.const 4
+  i32.le_u
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
+  local.get $0
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $1
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
  )
- (func $~lib/map/Map<u64,i32>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u64,i32>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -8218,8 +8420,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -8287,9 +8490,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i64)
-  (local $13 i64)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -8325,11 +8527,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 16
   i32.mul
   i32.add
@@ -8363,49 +8565,24 @@
      local.get $10
      i32.load offset=8
      call $~lib/map/MapEntry<u64,i32>#set:value
-     block $~lib/util/hash/HASH<u64>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 8
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<u64>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<u64,i32>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -8425,6 +8602,7 @@
   call $~lib/map/Map<u64,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u64,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -8434,7 +8612,7 @@
   call $~lib/map/Map<u64,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u64,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -8443,7 +8621,7 @@
  )
  (func $~lib/map/Map<u64,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u64>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -8499,15 +8677,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<u64,u64>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<u64,u64>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<u64,u64>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -8516,17 +8694,17 @@
  (func $~lib/map/Map<u64,u64>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<u64,u64>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<u64,u64>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<u64>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -8558,7 +8736,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<u64,u64>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<u64,u64>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -8566,8 +8744,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -8635,9 +8814,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i64)
-  (local $13 i64)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -8673,11 +8851,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 24
   i32.mul
   i32.add
@@ -8711,49 +8889,24 @@
      local.get $10
      i64.load offset=8
      call $~lib/map/MapEntry<u64,u64>#set:value
-     block $~lib/util/hash/HASH<u64>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 8
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<u64>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<u64,u64>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -8773,6 +8926,7 @@
   call $~lib/map/Map<u64,u64>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<u64,u64>#set:bucketsMask
   local.get $0
   local.get $5
@@ -8782,7 +8936,7 @@
   call $~lib/map/Map<u64,u64>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<u64,u64>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -8791,7 +8945,7 @@
  )
  (func $~lib/map/Map<u64,u64>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<u64,i32>#clear (param $0 i32)
   local.get $0
@@ -8802,9 +8956,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u64,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u64,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -8832,15 +8986,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<f32,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<f32,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<f32,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -8849,19 +9003,88 @@
  (func $~lib/map/Map<f32,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<f32,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<f32,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<f32> (param $0 f32) (result i64)
+  (local $1 i32)
+  (local $2 i64)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  drop
+  i32.const 4
+  i32.const 4
+  i32.eq
+  drop
+  local.get $0
+  i32.reinterpret_f32
+  local.set $1
+  i64.const 4
+  local.set $2
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $2
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $1
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/map/Map<f32,i32>#find (param $0 i32) (param $1 f32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<f32,i32>#find (param $0 i32) (param $1 f32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -8869,8 +9092,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -8938,9 +9162,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 f32)
-  (local $13 f32)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -8976,11 +9199,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -9014,38 +9237,24 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<f32,i32>#set:value
-     block $~lib/util/hash/HASH<f32>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      i32.reinterpret_f32
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<f32>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<f32>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<f32,i32>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -9065,6 +9274,7 @@
   call $~lib/map/Map<f32,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<f32,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -9074,7 +9284,7 @@
   call $~lib/map/Map<f32,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<f32,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -9083,7 +9293,7 @@
  )
  (func $~lib/map/Map<f32,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<f32>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -9139,15 +9349,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<f32,f32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<f32,f32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<f32,f32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -9156,17 +9366,17 @@
  (func $~lib/map/Map<f32,f32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<f32,f32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<f32,f32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<f32>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -9198,7 +9408,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<f32,f32>#find (param $0 i32) (param $1 f32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<f32,f32>#find (param $0 i32) (param $1 f32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -9206,8 +9416,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -9275,9 +9486,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 f32)
-  (local $13 f32)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -9313,11 +9523,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -9351,38 +9561,24 @@
      local.get $10
      f32.load offset=4
      call $~lib/map/MapEntry<f32,f32>#set:value
-     block $~lib/util/hash/HASH<f32>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      i32.reinterpret_f32
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<f32>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<f32>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<f32,f32>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -9402,6 +9598,7 @@
   call $~lib/map/Map<f32,f32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<f32,f32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -9411,7 +9608,7 @@
   call $~lib/map/Map<f32,f32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<f32,f32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -9420,7 +9617,7 @@
  )
  (func $~lib/map/Map<f32,f32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<f32,i32>#clear (param $0 i32)
   local.get $0
@@ -9431,9 +9628,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<f32,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<f32,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -9461,15 +9658,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<f64,i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<f64,i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<f64,i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -9478,19 +9675,92 @@
  (func $~lib/map/Map<f64,i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<f64,i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<f64,i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<f64> (param $0 f64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  drop
+  i32.const 8
+  i32.const 4
+  i32.eq
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
+  local.get $0
+  i64.reinterpret_f64
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $1
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
  )
- (func $~lib/map/Map<f64,i32>#find (param $0 i32) (param $1 f64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<f64,i32>#find (param $0 i32) (param $1 f64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -9498,8 +9768,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -9567,9 +9838,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 f64)
-  (local $13 f64)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -9605,11 +9875,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 16
   i32.mul
   i32.add
@@ -9643,42 +9913,24 @@
      local.get $10
      i32.load offset=8
      call $~lib/map/MapEntry<f64,i32>#set:value
-     block $~lib/util/hash/HASH<f64>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      i64.reinterpret_f64
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<f64>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<f64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<f64,i32>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -9698,6 +9950,7 @@
   call $~lib/map/Map<f64,i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<f64,i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -9707,7 +9960,7 @@
   call $~lib/map/Map<f64,i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<f64,i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -9716,7 +9969,7 @@
  )
  (func $~lib/map/Map<f64,i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<f64>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -9772,15 +10025,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<f64,f64>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<f64,f64>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<f64,f64>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -9789,17 +10042,17 @@
  (func $~lib/map/Map<f64,f64>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<f64,f64>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<f64,f64>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/array/Array<f64>#get:length (param $0 i32) (result i32)
   local.get $0
@@ -9831,7 +10084,7 @@
   drop
   local.get $2
  )
- (func $~lib/map/Map<f64,f64>#find (param $0 i32) (param $1 f64) (param $2 i32) (result i32)
+ (func $~lib/map/Map<f64,f64>#find (param $0 i32) (param $1 f64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -9839,8 +10092,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -9908,9 +10162,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 f64)
-  (local $13 f64)
+  (local $13 i32)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -9946,11 +10199,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 24
   i32.mul
   i32.add
@@ -9984,42 +10237,24 @@
      local.get $10
      f64.load offset=8
      call $~lib/map/MapEntry<f64,f64>#set:value
-     block $~lib/util/hash/HASH<f64>|inlined.5 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      i64.reinterpret_f64
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<f64>|inlined.5
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<f64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/map/MapEntry<f64,f64>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -10039,6 +10274,7 @@
   call $~lib/map/Map<f64,f64>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<f64,f64>#set:bucketsMask
   local.get $0
   local.get $5
@@ -10048,7 +10284,7 @@
   call $~lib/map/Map<f64,f64>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<f64,f64>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -10057,7 +10293,7 @@
  )
  (func $~lib/map/Map<f64,f64>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/map/Map<f64,i32>#clear (param $0 i32)
   local.get $0
@@ -10068,9 +10304,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<f64,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<f64,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -10199,7 +10435,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10250,7 +10486,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10275,7 +10511,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10300,7 +10536,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10338,7 +10574,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10363,7 +10599,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10401,7 +10637,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10426,7 +10662,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10464,7 +10700,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10489,7 +10725,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10527,7 +10763,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10552,7 +10788,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10590,7 +10826,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10615,7 +10851,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10653,7 +10889,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10678,7 +10914,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10716,7 +10952,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10741,7 +10977,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -10779,7 +11015,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -11011,7 +11247,6 @@
  )
  (func $~lib/map/Map<i8,i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -11021,45 +11256,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i8>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
   call $~lib/map/Map<i8,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<i8,i32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -11072,28 +11288,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i8>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $3
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -11101,21 +11298,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i8,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i8,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -11125,36 +11322,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i8,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -11163,39 +11361,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i8,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i8,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i8,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<i8,i32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -11209,7 +11408,6 @@
  (func $~lib/map/Map<i8,i32>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -11219,36 +11417,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<i8>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
   call $~lib/map/Map<i8,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -11258,14 +11437,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<i8>#__set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
@@ -11338,10 +11517,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -11482,10 +11661,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -11556,7 +11735,7 @@
   local.get $9
  )
  (func $~lib/map/Map<i8,i8>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -11569,28 +11748,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i8>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $3
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -11598,21 +11758,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i8,i8>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i8,i8>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -11622,36 +11782,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i8,i8>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -11660,39 +11821,40 @@
    i32.const 8
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i8,i8>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i8,i8>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i8,i8>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<i8,i8>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -11704,7 +11866,7 @@
   local.get $7
  )
  (func $~lib/map/Map<i32,i32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -11717,32 +11879,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i32>|inlined.0 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.0
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -11750,21 +11889,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i32,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i32,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -11774,36 +11913,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i32,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -11812,39 +11952,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i32,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i32,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i32,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<i32,i32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -11876,30 +12017,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i8>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
   call $~lib/map/Map<i8,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -11911,41 +12033,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<i8,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<i8,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -11961,7 +12084,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/map/Map<i8,i32>#rehash
   end
   i32.const 1
@@ -12677,7 +12800,6 @@
  )
  (func $~lib/map/Map<u8,i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -12687,43 +12809,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u8>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
   call $~lib/map/Map<u8,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<u8,i32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -12736,26 +12841,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u8>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $3
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -12763,21 +12851,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u8,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u8,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -12787,36 +12875,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u8,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -12825,39 +12914,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u8,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u8,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u8,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<u8,i32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -12871,7 +12961,6 @@
  (func $~lib/map/Map<u8,i32>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -12881,34 +12970,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<u8>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
   call $~lib/map/Map<u8,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -12918,14 +12990,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<u8>#__set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
@@ -12998,10 +13070,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -13090,10 +13162,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -13164,7 +13236,7 @@
   local.get $9
  )
  (func $~lib/map/Map<u8,u8>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -13177,26 +13249,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u8>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $3
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -13204,21 +13259,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u8,u8>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u8,u8>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -13228,36 +13283,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u8,u8>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -13266,39 +13322,40 @@
    i32.const 8
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u8,u8>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u8,u8>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u8,u8>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<u8,u8>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -13330,28 +13387,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u8>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
   call $~lib/map/Map<u8,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -13363,41 +13403,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<u8,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<u8,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -13413,7 +13454,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/map/Map<u8,i32>#rehash
   end
   i32.const 1
@@ -14107,7 +14148,6 @@
  )
  (func $~lib/map/Map<i16,i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -14117,49 +14157,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i16>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
   call $~lib/map/Map<i16,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<i16,i32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -14172,32 +14189,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i16>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $3
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -14205,21 +14199,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i16,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i16,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -14229,36 +14223,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i16,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -14267,39 +14262,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i16,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i16,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i16,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<i16,i32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -14313,7 +14309,6 @@
  (func $~lib/map/Map<i16,i32>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -14323,40 +14318,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<i16>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
   call $~lib/map/Map<i16,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -14366,14 +14338,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<i16>#__set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
@@ -14446,10 +14418,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -14538,10 +14510,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -14612,7 +14584,7 @@
   local.get $9
  )
  (func $~lib/map/Map<i16,i16>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -14625,32 +14597,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i16>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $3
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -14658,21 +14607,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i16,i16>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i16,i16>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -14682,36 +14631,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i16,i16>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -14720,39 +14670,40 @@
    i32.const 8
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i16,i16>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i16,i16>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i16,i16>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<i16,i16>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -14784,34 +14735,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i16>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
   call $~lib/map/Map<i16,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -14823,41 +14751,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<i16,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<i16,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -14873,7 +14802,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/map/Map<i16,i32>#rehash
   end
   i32.const 1
@@ -15589,7 +15518,6 @@
  )
  (func $~lib/map/Map<u16,i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -15599,47 +15527,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u16>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
   call $~lib/map/Map<u16,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<u16,i32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -15652,30 +15559,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u16>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $3
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -15683,21 +15569,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u16,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u16,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -15707,36 +15593,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u16,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -15745,39 +15632,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u16,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u16,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u16,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<u16,i32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -15791,7 +15679,6 @@
  (func $~lib/map/Map<u16,i32>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -15801,38 +15688,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<u16>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
   call $~lib/map/Map<u16,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -15842,14 +15708,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<u16>#__set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
@@ -15922,10 +15788,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -16014,10 +15880,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -16088,7 +15954,7 @@
   local.get $9
  )
  (func $~lib/map/Map<u16,u16>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -16101,30 +15967,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u16>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $3
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -16132,21 +15977,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u16,u16>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u16,u16>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -16156,36 +16001,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u16,u16>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -16194,39 +16040,40 @@
    i32.const 8
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u16,u16>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u16,u16>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u16,u16>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<u16,u16>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -16258,32 +16105,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u16>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
   call $~lib/map/Map<u16,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -16295,41 +16121,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<u16,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<u16,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -16345,7 +16172,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/map/Map<u16,i32>#rehash
   end
   i32.const 1
@@ -17039,7 +16866,6 @@
  )
  (func $~lib/map/Map<i32,i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -17049,51 +16875,27 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i32>|inlined.2 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.2
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<i32,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<i32,i32>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -17103,40 +16905,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<i32>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<i32,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -17146,14 +16925,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/map/Map<i32,i32>#keys (param $0 i32) (result i32)
   (local $1 i32)
@@ -17174,10 +16953,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -17266,10 +17045,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -17360,34 +17139,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i32>|inlined.4 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.4
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
   call $~lib/map/Map<i32,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -17399,41 +17155,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<i32,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<i32,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -17449,7 +17206,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/map/Map<i32,i32>#rehash
   end
   i32.const 1
@@ -18119,7 +17876,6 @@
  )
  (func $~lib/map/Map<u32,i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -18129,49 +17885,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u32>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
   call $~lib/map/Map<u32,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<u32,i32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -18184,32 +17917,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u32>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -18217,21 +17927,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u32,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u32,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -18241,36 +17951,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u32,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -18279,39 +17990,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u32,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u32,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u32,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<u32,i32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -18325,7 +18037,6 @@
  (func $~lib/map/Map<u32,i32>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -18335,40 +18046,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<u32>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
   call $~lib/map/Map<u32,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -18378,14 +18066,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<u32>#__set (param $0 i32) (param $1 i32) (param $2 i32)
   (local $3 i32)
@@ -18458,10 +18146,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -18550,10 +18238,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -18624,7 +18312,7 @@
   local.get $9
  )
  (func $~lib/map/Map<u32,u32>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -18637,32 +18325,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u32>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -18670,21 +18335,21 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u32,u32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u32,u32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -18694,36 +18359,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u32,u32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -18732,39 +18398,40 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u32,u32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u32,u32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u32,u32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<u32,u32>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -18796,34 +18463,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u32>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
   call $~lib/map/Map<u32,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -18835,41 +18479,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<u32,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<u32,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -18885,7 +18530,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/map/Map<u32,i32>#rehash
   end
   i32.const 1
@@ -19554,8 +19199,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/map/Map<i64,i32>#has (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -19565,50 +19209,23 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i64>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<i64,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<i64,i32>#set (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
   (local $3 i64)
@@ -19616,7 +19233,6 @@
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -19625,152 +19241,126 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i64>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i64,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i64,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i64,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<i64,i32>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 16
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i64,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i64,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i64,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<i64,i32>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<i64,i32>#get (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
+  (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -19780,44 +19370,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<i64>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<i64,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -19827,14 +19390,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=8
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<i64>#__set (param $0 i32) (param $1 i32) (param $2 i64)
   (local $3 i32)
@@ -19907,10 +19470,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -19999,10 +19562,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -20078,7 +19641,6 @@
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -20087,155 +19649,129 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<i64>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<i64,i64>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i64,i64>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<i64,i64>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<i64,i64>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 24
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<i64,i64>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<i64,i64>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<i64,i64>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<i64,i64>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<i64,i32>#delete (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -20245,90 +19781,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i64>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
   call $~lib/map/Map<i64,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=12
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<i64,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<i64,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -20339,21 +19849,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/map/Map<i64,i32>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/map/testNumeric<i64,i32>
   (local $0 i32)
@@ -21021,8 +20531,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/map/Map<u64,i32>#has (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -21032,50 +20541,23 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u64>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
   call $~lib/map/Map<u64,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<u64,i32>#set (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
   (local $3 i64)
@@ -21083,7 +20565,6 @@
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -21092,152 +20573,126 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u64>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u64,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u64,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u64,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<u64,i32>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 16
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u64,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u64,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u64,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<u64,i32>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<u64,i32>#get (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
+  (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -21247,44 +20702,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<u64>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
   call $~lib/map/Map<u64,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -21294,14 +20722,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=8
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<u64>#__set (param $0 i32) (param $1 i32) (param $2 i64)
   (local $3 i32)
@@ -21374,10 +20802,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -21466,10 +20894,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -21545,7 +20973,6 @@
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -21554,155 +20981,129 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<u64>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<u64,u64>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u64,u64>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<u64,u64>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<u64,u64>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 24
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<u64,u64>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<u64,u64>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<u64,u64>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<u64,u64>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<u64,i32>#delete (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -21712,90 +21113,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u64>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
   call $~lib/map/Map<u64,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=12
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<u64,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<u64,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -21806,21 +21181,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/map/Map<u64,i32>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/map/testNumeric<u64,i32>
   (local $0 i32)
@@ -22488,8 +21863,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/map/Map<f32,i32>#has (param $0 i32) (param $1 f32) (result i32)
-  (local $2 f32)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -22499,47 +21873,30 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<f32>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
   call $~lib/map/Map<f32,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<f32,i32>#set (param $0 i32) (param $1 f32) (param $2 i32) (result i32)
-  (local $3 f32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -22548,141 +21905,126 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<f32>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $3
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<f32,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f32,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f32,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<f32,i32>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<f32,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f32,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<f32,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<f32,i32>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<f32,i32>#get (param $0 i32) (param $1 f32) (result i32)
-  (local $2 f32)
+  (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -22692,33 +22034,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<f32>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
   call $~lib/map/Map<f32,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -22728,14 +22054,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<f32>#__set (param $0 i32) (param $1 i32) (param $2 f32)
   (local $3 i32)
@@ -22808,10 +22134,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -22900,10 +22226,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -22974,12 +22300,11 @@
   local.get $9
  )
  (func $~lib/map/Map<f32,f32>#set (param $0 i32) (param $1 f32) (param $2 f32) (result i32)
-  (local $3 f32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -22988,144 +22313,129 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<f32>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $3
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<f32,f32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f32,f32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f32,f32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<f32,f32>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<f32,f32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f32,f32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<f32,f32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<f32,f32>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<f32,i32>#delete (param $0 i32) (param $1 f32) (result i32)
-  (local $2 f32)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -23135,79 +22445,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<f32>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
   call $~lib/map/Map<f32,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<f32,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<f32,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -23218,21 +22513,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/map/Map<f32,i32>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/map/testNumeric<f32,i32>
   (local $0 i32)
@@ -23900,8 +23195,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/map/Map<f64,i32>#has (param $0 i32) (param $1 f64) (result i32)
-  (local $2 f64)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -23911,51 +23205,30 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<f64>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
   call $~lib/map/Map<f64,i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<f64,i32>#set (param $0 i32) (param $1 f64) (param $2 i32) (result i32)
-  (local $3 f64)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -23964,145 +23237,126 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<f64>|inlined.1 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $3
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.1
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<f64,i32>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f64,i32>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f64,i32>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<f64,i32>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 16
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<f64,i32>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f64,i32>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<f64,i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<f64,i32>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<f64,i32>#get (param $0 i32) (param $1 f64) (result i32)
-  (local $2 f64)
+  (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -24112,37 +23366,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<f64>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
   call $~lib/map/Map<f64,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 592
@@ -24152,14 +23386,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=8
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/array/Array<f64>#__set (param $0 i32) (param $1 i32) (param $2 f64)
   (local $3 i32)
@@ -24232,10 +23466,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -24324,10 +23558,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -24398,12 +23632,11 @@
   local.get $9
  )
  (func $~lib/map/Map<f64,f64>#set (param $0 i32) (param $1 f64) (param $2 f64) (result i32)
-  (local $3 f64)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
   (local $7 i32)
-  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -24412,148 +23645,129 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<f64>|inlined.4 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $3
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.4
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
+  local.set $3
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
   i32.store
-  local.get $8
+  local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<f64,f64>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f64,f64>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $8
+    local.set $7
     global.get $~lib/memory/__stack_pointer
-    local.get $8
+    local.get $7
     i32.store
-    local.get $8
+    local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<f64,f64>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $6
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $6
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $7
+   i32.load offset=24
+   local.tee $6
    i32.const 1
    i32.add
    call $~lib/map/Map<f64,f64>#set:entriesOffset
-   local.get $7
+   local.get $6
    i32.const 24
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<f64,f64>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<f64,f64>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<f64,f64>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $7
-   local.get $5
-   local.get $7
+   local.set $6
+   local.get $4
+   local.get $6
    i32.load
    call $~lib/map/MapEntry<f64,f64>#set:taggedNext
-   local.get $7
-   local.get $5
+   local.get $6
+   local.get $4
    i32.store
   end
   local.get $0
-  local.set $8
+  local.set $7
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $8
+  local.get $7
  )
  (func $~lib/map/Map<f64,i32>#delete (param $0 i32) (param $1 f64) (result i32)
-  (local $2 f64)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -24563,83 +23777,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<f64>|inlined.6 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.6
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
   call $~lib/map/Map<f64,i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=12
   i32.const 1
   i32.or
   call $~lib/map/MapEntry<f64,i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/map/Map<f64,i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -24650,21 +23845,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/map/Map<f64,i32>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/map/testNumeric<f64,i32>
   (local $0 i32)
@@ -25385,7 +24580,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 3
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -25399,9 +24594,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i8,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -25603,7 +24798,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 6
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -25617,9 +24812,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i8,i8>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i8,i8>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -25659,7 +24854,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 7
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -25673,9 +24868,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i32,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i32,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -25715,7 +24910,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 8
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -25729,9 +24924,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u8,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u8,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -25852,7 +25047,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 10
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -25866,9 +25061,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u8,u8>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u8,u8>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -25908,7 +25103,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 11
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -25922,9 +25117,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i16,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i16,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26045,7 +25240,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 13
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26059,9 +25254,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i16,i16>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i16,i16>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26101,7 +25296,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 14
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26115,9 +25310,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u16,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u16,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26238,7 +25433,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 16
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26252,9 +25447,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u16,u16>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u16,u16>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26294,7 +25489,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 17
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26308,9 +25503,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u32,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u32,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26431,7 +25626,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 19
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26445,9 +25640,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u32,u32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u32,u32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26487,7 +25682,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 20
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26501,9 +25696,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i64,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i64,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26624,7 +25819,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 22
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26638,9 +25833,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<i64,i64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<i64,i64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26680,7 +25875,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 23
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26694,9 +25889,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u64,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u64,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26817,7 +26012,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 25
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26831,9 +26026,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<u64,u64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<u64,u64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -26873,7 +26068,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 26
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -26887,9 +26082,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<f32,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<f32,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -27010,7 +26205,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 28
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -27024,9 +26219,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<f32,f32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<f32,f32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -27066,7 +26261,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 29
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -27080,9 +26275,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<f64,i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<f64,i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -27203,7 +26398,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 31
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -27217,9 +26412,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<f64,f64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<f64,f64>#set:bucketsMask
   local.get $0
   i32.const 0
diff --git a/tests/compiler/std/set.optimized.wat b/tests/compiler/std/set.optimized.wat
index fc350bf5c1..910c0adedb 100644
--- a/tests/compiler/std/set.optimized.wat
+++ b/tests/compiler/std/set.optimized.wat
@@ -6,20 +6,23 @@
  (type $none_=>_i32 (func (result i32)))
  (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
  (type $i32_=>_none (func (param i32)))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
  (type $i32_i64_=>_none (func (param i32 i64)))
- (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i32_i64_=>_i32 (func (param i32 i32 i64) (result i32)))
  (type $i32_f32_=>_none (func (param i32 f32)))
  (type $i32_f64_=>_none (func (param i32 f64)))
  (type $i32_i64_=>_i32 (func (param i32 i64) (result i32)))
- (type $i32_i64_i32_=>_i32 (func (param i32 i64 i32) (result i32)))
+ (type $i32_i64_i64_=>_i32 (func (param i32 i64 i64) (result i32)))
  (type $i32_i32_=>_i64 (func (param i32 i32) (result i64)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
  (type $i32_i32_i64_=>_none (func (param i32 i32 i64)))
- (type $i64_=>_i32 (func (param i64) (result i32)))
  (type $i32_f32_=>_i32 (func (param i32 f32) (result i32)))
- (type $i32_f32_i32_=>_i32 (func (param i32 f32 i32) (result i32)))
+ (type $i32_f32_i64_=>_i32 (func (param i32 f32 i64) (result i32)))
  (type $i32_f64_=>_i32 (func (param i32 f64) (result i32)))
- (type $i32_f64_i32_=>_i32 (func (param i32 f64 i32) (result i32)))
+ (type $i32_f64_i64_=>_i32 (func (param i32 f64 i64) (result i32)))
+ (type $i64_=>_i64 (func (param i64) (result i64)))
+ (type $f32_=>_i64 (func (param f32) (result i64)))
+ (type $f64_=>_i64 (func (param f64) (result i64)))
  (type $i32_i32_=>_f32 (func (param i32 i32) (result f32)))
  (type $i32_i32_=>_f64 (func (param i32 i32) (result f64)))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
@@ -1814,18 +1817,58 @@
  (func $~lib/set/Set<i8>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<i8>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<i8> (param $0 i32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.const 24
+  i32.shl
+  i32.const 24
+  i32.shr_s
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600262
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
+ (func $~lib/set/Set<i8>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -1836,7 +1879,7 @@
    if
     local.get $0
     i32.load offset=4
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -1853,7 +1896,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -1901,10 +1944,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -1929,13 +1972,12 @@
      i32.store8
      local.get $2
      local.get $6
-     local.get $1
      local.get $7
-     i32.const -2128831035
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     i32.and
+     call $~lib/util/hash/HASH<i8>
+     local.get $1
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -1962,17 +2004,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2282,21 +2325,57 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u8> (param $0 i32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.const 255
+  i32.and
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600262
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
  (func $~lib/set/Set<u8>#rehash (param $0 i32) (param $1 i32)
   (local $2 i32)
@@ -2337,10 +2416,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -2365,13 +2444,12 @@
      i32.store8
      local.get $2
      local.get $6
-     local.get $1
      local.get $7
-     i32.const -2128831035
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     i32.and
+     call $~lib/util/hash/HASH<u8>
+     local.get $1
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2398,17 +2476,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2433,28 +2512,53 @@
   i32.add
   i32.load8_u
  )
- (func $~lib/util/hash/hash16 (param $0 i32) (result i32)
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+ (func $~lib/util/hash/HASH<i16> (param $0 i32) (result i64)
+  (local $1 i64)
   local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i32.const 16
+  i32.shl
+  i32.const 16
+  i32.shr_s
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600263
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
- (func $~lib/set/Set<i16>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i16>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -2465,7 +2569,7 @@
    if
     local.get $0
     i32.load offset=4
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -2482,7 +2586,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -2530,10 +2634,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -2559,9 +2663,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash16
+     call $~lib/util/hash/HASH<i16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2588,17 +2694,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2634,6 +2741,42 @@
   i32.add
   i32.load16_s
  )
+ (func $~lib/util/hash/HASH<u16> (param $0 i32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.const 65535
+  i32.and
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600263
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
  (func $~lib/set/Set<u16>#rehash (param $0 i32) (param $1 i32)
   (local $2 i32)
   (local $3 i32)
@@ -2673,10 +2816,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -2702,9 +2845,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash16
+     call $~lib/util/hash/HASH<u16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2731,17 +2876,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2768,44 +2914,49 @@
   i32.add
   i32.load16_u
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+ (func $~lib/util/hash/HASH<i32> (param $0 i32) (result i64)
+  (local $1 i64)
   local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600265
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
- (func $~lib/set/Set<i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -2816,7 +2967,7 @@
    if
     local.get $0
     i32.load offset=4
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -2831,7 +2982,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -2879,10 +3030,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -2908,9 +3059,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2937,17 +3090,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2983,13 +3137,15 @@
   i32.add
   i32.load
  )
- (func $~lib/set/Set<u32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<u32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3000,7 +3156,7 @@
    if
     local.get $0
     i32.load offset=4
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3015,7 +3171,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3063,10 +3219,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -3092,9 +3248,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3121,17 +3279,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3158,79 +3317,51 @@
   i32.add
   i32.load
  )
- (func $~lib/util/hash/hash64 (param $0 i64) (result i32)
-  (local $1 i32)
+ (func $~lib/util/hash/HASH<i64> (param $0 i64) (result i64)
   local.get $0
-  i32.wrap_i64
-  local.tee $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600269
+  i64.xor
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 8796714831421723037
+  i64.sub
+  local.tee $0
+  local.get $0
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $0
+  local.get $0
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $0
   local.get $0
   i64.const 32
   i64.shr_u
-  i32.wrap_i64
-  local.tee $1
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.xor
  )
- (func $~lib/set/Set<i64>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i64>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3241,7 +3372,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3256,7 +3387,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3305,10 +3436,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 4
   i32.shl
   i32.add
@@ -3334,9 +3465,11 @@
      local.get $2
      local.get $8
      local.get $5
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3363,17 +3496,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3415,29 +3549,31 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/set/Set<u64>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/set/Set<u64>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3448,7 +3584,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3463,7 +3599,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3512,10 +3648,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 4
   i32.shl
   i32.add
@@ -3541,9 +3677,11 @@
      local.get $2
      local.get $8
      local.get $5
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3570,17 +3708,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3607,13 +3746,50 @@
   i32.add
   i64.load
  )
- (func $~lib/set/Set<f32>#find (param $0 i32) (param $1 f32) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<f32> (param $0 f32) (result i64)
+  (local $1 i64)
+  local.get $0
+  i32.reinterpret_f32
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600265
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
+ (func $~lib/set/Set<f32>#find (param $0 i32) (param $1 f32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3624,7 +3800,7 @@
    if
     local.get $0
     i32.load offset=4
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3639,7 +3815,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3688,10 +3864,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 3
   i32.shl
   i32.add
@@ -3717,10 +3893,11 @@
      local.get $2
      local.get $8
      local.get $5
-     i32.reinterpret_f32
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<f32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3747,17 +3924,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3784,13 +3962,53 @@
   i32.add
   f32.load
  )
- (func $~lib/set/Set<f64>#find (param $0 i32) (param $1 f64) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<f64> (param $0 f64) (result i64)
+  (local $1 i64)
+  local.get $0
+  i64.reinterpret_f64
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600269
+  i64.xor
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 8796714831421723037
+  i64.sub
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
+ )
+ (func $~lib/set/Set<f64>#find (param $0 i32) (param $1 f64) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -3801,7 +4019,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -3816,7 +4034,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -3865,10 +4083,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $9
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 4
   i32.shl
   i32.add
@@ -3894,10 +4112,11 @@
      local.get $2
      local.get $8
      local.get $5
-     i64.reinterpret_f64
-     call $~lib/util/hash/hash64
+     call $~lib/util/hash/HASH<f64>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -3924,17 +4143,18 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   local.get $7
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -3993,7 +4213,7 @@
    i32.load
    call $~lib/rt/itcms/__visit
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    call $~lib/rt/itcms/__visit
    return
   end
@@ -4083,14 +4303,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<i8>
   call $~lib/set/Set<i8>#find
   i32.const 0
   i32.ne
@@ -4101,7 +4314,7 @@
  )
  (func $~lib/set/Set<i8>#add (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -4111,30 +4324,22 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store
-  local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.tee $2
-  local.set $3
   local.get $0
   local.get $1
-  local.get $2
+  local.get $3
   call $~lib/set/Set<i8>#find
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -4142,36 +4347,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i8>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -4181,17 +4387,18 @@
    i32.store8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -4274,11 +4481,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $0
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4408,14 +4615,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 24
-  i32.shl
-  i32.const 24
-  i32.shr_s
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<i8>
   call $~lib/set/Set<i8>#find
   local.tee $1
   i32.eqz
@@ -4434,20 +4634,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -4456,9 +4657,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -4558,7 +4759,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -4627,7 +4828,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -4701,12 +4902,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -4773,7 +4974,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -4861,7 +5062,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -4881,7 +5082,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -4910,12 +5111,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<u8>
   call $~lib/set/Set<i8>#find
   i32.const 0
   i32.ne
@@ -4926,7 +5122,7 @@
  )
  (func $~lib/set/Set<u8>#add (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -4936,28 +5132,22 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store
-  local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.tee $2
-  local.set $3
   local.get $0
   local.get $1
-  local.get $2
+  local.get $3
   call $~lib/set/Set<i8>#find
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -4965,36 +5155,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u8>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -5004,17 +5195,18 @@
    i32.store8
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -5046,11 +5238,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $5
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $0
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5180,12 +5372,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  call $~lib/util/hash/HASH<u8>
   call $~lib/set/Set<i8>#find
   local.tee $1
   i32.eqz
@@ -5204,20 +5391,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -5226,9 +5414,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -5326,7 +5514,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -5393,7 +5581,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -5467,12 +5655,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -5537,7 +5725,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -5623,7 +5811,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -5643,7 +5831,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -5672,11 +5860,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   call $~lib/set/Set<i16>#find
   i32.const 0
   i32.ne
@@ -5687,7 +5871,7 @@
  )
  (func $~lib/set/Set<i16>#add (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -5698,11 +5882,7 @@
   i32.const 0
   i32.store
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -5714,9 +5894,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -5724,36 +5904,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i16>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -5763,17 +5944,18 @@
    i32.store16
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -5860,11 +6042,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -5998,11 +6180,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 16
-  i32.shl
-  i32.const 16
-  i32.shr_s
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<i16>
   call $~lib/set/Set<i16>#find
   local.tee $1
   i32.eqz
@@ -6021,20 +6199,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -6043,9 +6222,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -6145,7 +6324,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6214,7 +6393,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6288,12 +6467,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -6360,7 +6539,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -6448,7 +6627,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -6468,7 +6647,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -6497,9 +6676,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   call $~lib/set/Set<i16>#find
   i32.const 0
   i32.ne
@@ -6510,7 +6687,7 @@
  )
  (func $~lib/set/Set<u16>#add (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -6521,9 +6698,7 @@
   i32.const 0
   i32.store
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -6535,9 +6710,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -6545,36 +6720,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u16>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -6584,17 +6760,18 @@
    i32.store16
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -6628,11 +6805,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -6766,9 +6943,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.const 65535
-  i32.and
-  call $~lib/util/hash/hash16
+  call $~lib/util/hash/HASH<u16>
   call $~lib/set/Set<i16>#find
   local.tee $1
   i32.eqz
@@ -6787,20 +6962,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -6809,9 +6985,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -6909,7 +7085,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -6976,7 +7152,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7050,12 +7226,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -7120,7 +7296,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -7206,7 +7382,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -7226,7 +7402,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -7255,7 +7431,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/set/Set<i32>#find
   i32.const 0
   i32.ne
@@ -7266,7 +7442,7 @@
  )
  (func $~lib/set/Set<i32>#add (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -7277,7 +7453,7 @@
   i32.const 0
   i32.store
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -7289,9 +7465,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -7299,36 +7475,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i32>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -7338,17 +7515,18 @@
    i32.store
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -7435,11 +7613,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -7573,7 +7751,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/set/Set<i32>#find
   local.tee $1
   i32.eqz
@@ -7592,20 +7770,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -7614,9 +7793,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -7712,7 +7891,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7777,7 +7956,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -7851,12 +8030,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -7919,7 +8098,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -8003,7 +8182,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -8023,7 +8202,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -8052,7 +8231,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/set/Set<u32>#find
   i32.const 0
   i32.ne
@@ -8063,7 +8242,7 @@
  )
  (func $~lib/set/Set<u32>#add (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -8074,7 +8253,7 @@
   i32.const 0
   i32.store
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -8086,9 +8265,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -8096,36 +8275,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
-     local.get $0
-     i32.load offset=4
-    else
-     local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+    if (result i64)
+     local.get $0
+     i64.load offset=8
+    else
+     local.get $0
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u32>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -8135,17 +8315,18 @@
    i32.store
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -8179,11 +8360,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -8317,7 +8498,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<i32>
   call $~lib/set/Set<u32>#find
   local.tee $1
   i32.eqz
@@ -8336,20 +8517,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $2
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $1
   local.get $1
   i32.const 4
@@ -8358,9 +8540,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -8456,7 +8638,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -8521,7 +8703,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -8595,12 +8777,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -8663,7 +8845,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -8747,7 +8929,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -8767,7 +8949,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -8796,7 +8978,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/set/Set<i64>#find
   i32.const 0
   i32.ne
@@ -8807,7 +8989,7 @@
  )
  (func $~lib/set/Set<i64>#add (param $0 i32) (param $1 i64)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -8818,7 +9000,7 @@
   i32.const 0
   i32.store
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -8830,9 +9012,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -8840,36 +9022,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i64>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 4
    i32.shl
@@ -8879,17 +9062,18 @@
    i64.store
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -8976,11 +9160,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -9115,7 +9299,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/set/Set<i64>#find
   local.tee $2
   i32.eqz
@@ -9134,20 +9318,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -9156,9 +9341,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -9255,7 +9440,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -9320,7 +9505,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -9394,12 +9579,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -9462,7 +9647,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -9546,7 +9731,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -9566,7 +9751,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -9595,7 +9780,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/set/Set<u64>#find
   i32.const 0
   i32.ne
@@ -9606,7 +9791,7 @@
  )
  (func $~lib/set/Set<u64>#add (param $0 i32) (param $1 i64)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -9617,7 +9802,7 @@
   i32.const 0
   i32.store
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -9629,9 +9814,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -9639,36 +9824,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u64>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 4
    i32.shl
@@ -9678,17 +9864,18 @@
    i64.store
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -9722,11 +9909,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -9861,7 +10048,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<i64>
   call $~lib/set/Set<u64>#find
   local.tee $2
   i32.eqz
@@ -9880,20 +10067,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -9902,9 +10090,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -10001,7 +10189,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10066,7 +10254,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10140,12 +10328,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -10208,7 +10396,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -10292,7 +10480,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -10312,7 +10500,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -10341,8 +10529,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   call $~lib/set/Set<f32>#find
   i32.const 0
   i32.ne
@@ -10353,7 +10540,7 @@
  )
  (func $~lib/set/Set<f32>#add (param $0 i32) (param $1 f32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -10364,8 +10551,7 @@
   i32.const 0
   i32.store
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -10377,9 +10563,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -10387,36 +10573,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<f32>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 3
    i32.shl
@@ -10426,17 +10613,18 @@
    f32.store
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -10471,11 +10659,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -10658,8 +10846,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i32.reinterpret_f32
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<f32>
   call $~lib/set/Set<f32>#find
   local.tee $2
   i32.eqz
@@ -10678,20 +10865,21 @@
   i32.store offset=4
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -10700,9 +10888,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -10799,7 +10987,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10864,7 +11052,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -10938,12 +11126,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -11006,7 +11194,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -11090,7 +11278,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -11110,7 +11298,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -11139,8 +11327,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   call $~lib/set/Set<f64>#find
   i32.const 0
   i32.ne
@@ -11151,7 +11338,7 @@
  )
  (func $~lib/set/Set<f64>#add (param $0 i32) (param $1 f64)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
@@ -11162,8 +11349,7 @@
   i32.const 0
   i32.store
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -11175,9 +11361,9 @@
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -11185,36 +11371,37 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<f64>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $4
    i32.const 4
    i32.shl
@@ -11224,17 +11411,18 @@
    f64.store
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -11269,11 +11457,11 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.tee $8
   local.set $2
   global.get $~lib/memory/__stack_pointer
@@ -11456,8 +11644,7 @@
   local.get $0
   local.get $1
   local.get $1
-  i64.reinterpret_f64
-  call $~lib/util/hash/hash64
+  call $~lib/util/hash/HASH<f64>
   call $~lib/set/Set<f64>#find
   local.tee $2
   i32.eqz
@@ -11476,20 +11663,21 @@
   i32.store offset=8
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
-  i32.store offset=20
+  i32.store offset=28
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
   local.tee $3
   i32.const 1
   i32.add
   i32.const 4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $2
   local.get $2
   i32.const 4
@@ -11498,9 +11686,9 @@
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -11597,7 +11785,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -11662,7 +11850,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 100
   i32.ne
   if
@@ -11736,12 +11924,12 @@
   local.get $3
   i32.store offset=4
   local.get $3
-  i32.load offset=20
+  i32.load offset=28
   global.get $~lib/memory/__stack_pointer
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.ne
   if
    i32.const 0
@@ -11804,7 +11992,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -11888,7 +12076,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 50
   i32.ne
   if
@@ -11908,7 +12096,7 @@
   local.get $0
   i32.store offset=4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   if
    i32.const 0
    i32.const 1568
@@ -11969,7 +12157,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 3
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -11979,21 +12167,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12011,7 +12199,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 5
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12021,21 +12209,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12053,7 +12241,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 7
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12063,21 +12251,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12095,7 +12283,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 9
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12105,21 +12293,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12137,7 +12325,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 11
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12147,21 +12335,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12179,7 +12367,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 13
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12189,21 +12377,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12221,7 +12409,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 15
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12231,21 +12419,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12263,7 +12451,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 17
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12273,21 +12461,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12305,7 +12493,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 19
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12315,21 +12503,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 32
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
@@ -12347,7 +12535,7 @@
   i32.const 0
   i32.store
   global.get $~lib/memory/__stack_pointer
-  i32.const 24
+  i32.const 32
   i32.const 21
   call $~lib/rt/itcms/__new
   local.tee $0
@@ -12357,21 +12545,21 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 3
-  i32.store offset=4
+  i64.const 3
+  i64.store offset=8
   local.get $0
   i32.const 64
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:entries
   local.get $0
   i32.const 4
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   i32.const 0
-  i32.store offset=16
+  i32.store offset=24
   local.get $0
   i32.const 0
-  i32.store offset=20
+  i32.store offset=28
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
diff --git a/tests/compiler/std/set.untouched.wat b/tests/compiler/std/set.untouched.wat
index b8021d9ff5..50dc5bffe8 100644
--- a/tests/compiler/std/set.untouched.wat
+++ b/tests/compiler/std/set.untouched.wat
@@ -5,23 +5,27 @@
  (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
  (type $i32_=>_none (func (param i32)))
  (type $none_=>_none (func))
- (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i64_=>_none (func (param i32 i64)))
+ (type $i32_i32_i64_=>_i32 (func (param i32 i32 i64) (result i32)))
  (type $i32_i64_=>_i32 (func (param i32 i64) (result i32)))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
  (type $i32_i32_i64_=>_none (func (param i32 i32 i64)))
  (type $i32_f32_=>_i32 (func (param i32 f32) (result i32)))
  (type $i32_f64_=>_i32 (func (param i32 f64) (result i32)))
  (type $i32_i32_f32_=>_none (func (param i32 i32 f32)))
  (type $i32_i32_f64_=>_none (func (param i32 i32 f64)))
- (type $i32_i64_=>_none (func (param i32 i64)))
- (type $i32_i64_i32_=>_i32 (func (param i32 i64 i32) (result i32)))
+ (type $i32_i64_i64_=>_i32 (func (param i32 i64 i64) (result i32)))
+ (type $i64_=>_i64 (func (param i64) (result i64)))
  (type $i32_i32_=>_i64 (func (param i32 i32) (result i64)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
  (type $i32_f32_=>_none (func (param i32 f32)))
  (type $i32_f64_=>_none (func (param i32 f64)))
  (type $none_=>_i32 (func (result i32)))
- (type $i64_=>_i32 (func (param i64) (result i32)))
- (type $i32_f32_i32_=>_i32 (func (param i32 f32 i32) (result i32)))
- (type $i32_f64_i32_=>_i32 (func (param i32 f64 i32) (result i32)))
+ (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_f32_i64_=>_i32 (func (param i32 f32 i64) (result i32)))
+ (type $i32_f64_i64_=>_i32 (func (param i32 f64 i64) (result i32)))
+ (type $f32_=>_i64 (func (param f32) (result i64)))
+ (type $f64_=>_i64 (func (param f64) (result i64)))
  (type $i32_i32_=>_f32 (func (param i32 i32) (result f32)))
  (type $i32_i32_=>_f64 (func (param i32 i32) (result f64)))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
@@ -2448,15 +2452,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<i8>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<i8>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<i8>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -2465,26 +2469,91 @@
  (func $~lib/set/Set<i8>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<i8>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<i8>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash8 (param $0 i32) (result i32)
-  i32.const -2128831035
+ (func $~lib/util/hash/HASH<i8> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i32.const 24
+  i32.shl
+  i32.const 24
+  i32.shr_s
+  local.set $2
+  i64.const 1
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<i8>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i8>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -2492,8 +2561,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -2560,7 +2630,7 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i32)
-  (local $13 i32)
+  (local $13 i64)
   (local $14 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -2597,11 +2667,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -2631,28 +2701,15 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<i8>#set:key
-     block $~lib/util/hash/HASH<i8>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      i32.const 1
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash8
-      br $~lib/util/hash/HASH<i8>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i8>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
      local.set $13
      local.get $3
      local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
@@ -2681,6 +2738,7 @@
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<i8>#set:bucketsMask
   local.get $0
   local.get $5
@@ -2690,7 +2748,7 @@
   call $~lib/set/Set<i8>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<i8>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -2699,7 +2757,7 @@
  )
  (func $~lib/set/Set<i8>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i8>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -4149,9 +4207,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i8>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -4179,15 +4237,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<u8>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<u8>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<u8>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -4196,19 +4254,89 @@
  (func $~lib/set/Set<u8>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<u8>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<u8>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u8> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  i32.const 4
+  i32.le_u
+  drop
+  local.get $0
+  i32.const 255
+  i32.and
+  local.set $2
+  i64.const 1
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<u8>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<u8>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -4216,8 +4344,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -4282,7 +4411,7 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i32)
-  (local $13 i32)
+  (local $13 i64)
   (local $14 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4319,11 +4448,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -4353,28 +4482,15 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<u8>#set:key
-     block $~lib/util/hash/HASH<u8>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      i32.const 1
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash8
-      br $~lib/util/hash/HASH<u8>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u8>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
      local.set $13
      local.get $3
      local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
@@ -4403,6 +4519,7 @@
   call $~lib/set/Set<u8>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<u8>#set:bucketsMask
   local.get $0
   local.get $5
@@ -4412,7 +4529,7 @@
   call $~lib/set/Set<u8>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<u8>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4421,7 +4538,7 @@
  )
  (func $~lib/set/Set<u8>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u8>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -4507,9 +4624,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u8>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u8>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -4537,15 +4654,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<i16>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<i16>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<i16>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -4554,41 +4671,91 @@
  (func $~lib/set/Set<i16>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<i16>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<i16>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash16 (param $0 i32) (result i32)
-  (local $1 i32)
-  i32.const -2128831035
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
+ (func $~lib/util/hash/HASH<i16> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 2
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i32.const 16
+  i32.shl
+  i32.const 16
+  i32.shr_s
+  local.set $2
+  i64.const 2
   local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
   local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<i16>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i16>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -4596,8 +4763,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -4664,7 +4832,7 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i32)
-  (local $13 i32)
+  (local $13 i64)
   (local $14 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4701,11 +4869,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -4735,32 +4903,15 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<i16>#set:key
-     block $~lib/util/hash/HASH<i16>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 2
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 2
-      i32.const 2
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash16
-      br $~lib/util/hash/HASH<i16>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
      local.set $13
      local.get $3
      local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
@@ -4789,6 +4940,7 @@
   call $~lib/set/Set<i16>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<i16>#set:bucketsMask
   local.get $0
   local.get $5
@@ -4798,7 +4950,7 @@
   call $~lib/set/Set<i16>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<i16>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4807,7 +4959,7 @@
  )
  (func $~lib/set/Set<i16>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i16>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -4893,9 +5045,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i16>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i16>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -4923,15 +5075,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<u16>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<u16>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<u16>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -4940,19 +5092,89 @@
  (func $~lib/set/Set<u16>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<u16>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<u16>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u16> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 2
+  i32.const 4
+  i32.le_u
+  drop
+  local.get $0
+  i32.const 65535
+  i32.and
+  local.set $2
+  i64.const 2
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<u16>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<u16>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -4960,8 +5182,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -5026,7 +5249,7 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i32)
-  (local $13 i32)
+  (local $13 i64)
   (local $14 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5063,11 +5286,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -5097,32 +5320,15 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<u16>#set:key
-     block $~lib/util/hash/HASH<u16>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 2
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 2
-      i32.const 2
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash16
-      br $~lib/util/hash/HASH<u16>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u16>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
      local.set $13
      local.get $3
      local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
@@ -5151,6 +5357,7 @@
   call $~lib/set/Set<u16>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<u16>#set:bucketsMask
   local.get $0
   local.get $5
@@ -5160,7 +5367,7 @@
   call $~lib/set/Set<u16>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<u16>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5169,7 +5376,7 @@
  )
  (func $~lib/set/Set<u16>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u16>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -5255,9 +5462,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u16>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u16>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -5285,15 +5492,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<i32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<i32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<i32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -5302,61 +5509,87 @@
  (func $~lib/set/Set<i32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<i32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<i32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  (local $1 i32)
-  i32.const -2128831035
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
+ (func $~lib/util/hash/HASH<i32> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 4
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  local.set $2
+  i64.const 4
   local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
   local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<i32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -5364,8 +5597,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -5428,7 +5662,7 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i32)
-  (local $13 i32)
+  (local $13 i64)
   (local $14 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5465,11 +5699,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -5499,36 +5733,15 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<i32>#set:key
-     block $~lib/util/hash/HASH<i32>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 4
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<i32>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
      local.set $13
      local.get $3
      local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
@@ -5557,6 +5770,7 @@
   call $~lib/set/Set<i32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<i32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -5566,7 +5780,7 @@
   call $~lib/set/Set<i32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<i32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5575,7 +5789,7 @@
  )
  (func $~lib/set/Set<i32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i32>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -5661,9 +5875,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -5691,15 +5905,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<u32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<u32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<u32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -5708,19 +5922,87 @@
  (func $~lib/set/Set<u32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<u32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<u32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<u32> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 4
+  i32.const 4
+  i32.le_u
+  drop
+  local.get $0
+  local.set $2
+  i64.const 4
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<u32>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<u32>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -5728,8 +6010,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -5792,7 +6075,7 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 i32)
-  (local $13 i32)
+  (local $13 i64)
   (local $14 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5829,11 +6112,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -5863,36 +6146,15 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<u32>#set:key
-     block $~lib/util/hash/HASH<u32>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 4
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<u32>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u32>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
      local.set $13
      local.get $3
      local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
@@ -5921,6 +6183,7 @@
   call $~lib/set/Set<u32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<u32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -5930,7 +6193,7 @@
   call $~lib/set/Set<u32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<u32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -5939,7 +6202,7 @@
  )
  (func $~lib/set/Set<u32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u32>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -6025,9 +6288,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6055,15 +6318,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<i64>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<i64>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<i64>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -6072,107 +6335,91 @@
  (func $~lib/set/Set<i64>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<i64>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<i64>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/util/hash/hash64 (param $0 i64) (result i32)
-  (local $1 i32)
-  (local $2 i32)
-  (local $3 i32)
+ (func $~lib/util/hash/HASH<i64> (param $0 i64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 8
+  i32.const 4
+  i32.le_u
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
   local.get $0
-  i32.wrap_i64
   local.set $1
-  local.get $0
-  i64.const 32
-  i64.shr_u
-  i32.wrap_i64
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
   local.set $2
-  i32.const -2128831035
-  local.set $3
-  local.get $3
-  local.get $1
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
-  local.get $1
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
-  local.get $1
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  local.get $2
   local.get $1
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
   local.get $2
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
   local.get $2
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
   local.get $2
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
   local.get $2
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $3
-  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
  )
- (func $~lib/set/Set<i64>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/set/Set<i64>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -6180,8 +6427,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -6246,7 +6494,6 @@
   (local $12 i64)
   (local $13 i64)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -6282,11 +6529,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 16
   i32.mul
   i32.add
@@ -6316,49 +6563,24 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<i64>#set:key
-     block $~lib/util/hash/HASH<i64>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 8
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<i64>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<i64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/set/SetEntry<i64>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -6378,6 +6600,7 @@
   call $~lib/set/Set<i64>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<i64>#set:bucketsMask
   local.get $0
   local.get $5
@@ -6387,7 +6610,7 @@
   call $~lib/set/Set<i64>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<i64>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6396,7 +6619,7 @@
  )
  (func $~lib/set/Set<i64>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<i64>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -6482,9 +6705,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6512,15 +6735,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<u64>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<u64>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<u64>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -6529,19 +6752,91 @@
  (func $~lib/set/Set<u64>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<u64>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<u64>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
- (func $~lib/set/Set<u64>#find (param $0 i32) (param $1 i64) (param $2 i32) (result i32)
+ (func $~lib/util/hash/HASH<u64> (param $0 i64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 8
+  i32.const 4
+  i32.le_u
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
+  local.get $0
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $1
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
+ )
+ (func $~lib/set/Set<u64>#find (param $0 i32) (param $1 i64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -6549,8 +6844,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -6615,7 +6911,6 @@
   (local $12 i64)
   (local $13 i64)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -6651,11 +6946,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 16
   i32.mul
   i32.add
@@ -6685,49 +6980,24 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<u64>#set:key
-     block $~lib/util/hash/HASH<u64>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 8
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<u64>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<u64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/set/SetEntry<u64>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -6747,6 +7017,7 @@
   call $~lib/set/Set<u64>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<u64>#set:bucketsMask
   local.get $0
   local.get $5
@@ -6756,7 +7027,7 @@
   call $~lib/set/Set<u64>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<u64>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -6765,7 +7036,7 @@
  )
  (func $~lib/set/Set<u64>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<u64>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -6851,9 +7122,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6881,15 +7152,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<f32>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<f32>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<f32>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -6898,19 +7169,88 @@
  (func $~lib/set/Set<f32>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<f32>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<f32>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<f32> (param $0 f32) (result i64)
+  (local $1 i32)
+  (local $2 i64)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  drop
+  i32.const 4
+  i32.const 4
+  i32.eq
+  drop
+  local.get $0
+  i32.reinterpret_f32
+  local.set $1
+  i64.const 4
+  local.set $2
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  local.get $2
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $1
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/set/Set<f32>#find (param $0 i32) (param $1 f32) (param $2 i32) (result i32)
+ (func $~lib/set/Set<f32>#find (param $0 i32) (param $1 f32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -6918,8 +7258,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -6982,9 +7323,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 f32)
-  (local $13 f32)
+  (local $13 i64)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -7020,11 +7360,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 8
   i32.mul
   i32.add
@@ -7054,38 +7394,24 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<f32>#set:key
-     block $~lib/util/hash/HASH<f32>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      i32.reinterpret_f32
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<f32>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<f32>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/set/SetEntry<f32>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -7105,6 +7431,7 @@
   call $~lib/set/Set<f32>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<f32>#set:bucketsMask
   local.get $0
   local.get $5
@@ -7114,7 +7441,7 @@
   call $~lib/set/Set<f32>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<f32>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -7123,7 +7450,7 @@
  )
  (func $~lib/set/Set<f32>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<f32>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -7209,9 +7536,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<f32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<f32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -7239,15 +7566,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/set/Set<f64>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/set/Set<f64>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/set/Set<f64>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -7256,19 +7583,92 @@
  (func $~lib/set/Set<f64>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/set/Set<f64>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/set/Set<f64>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
+ )
+ (func $~lib/util/hash/HASH<f64> (param $0 f64) (result i64)
+  (local $1 i64)
+  (local $2 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 1
+  drop
+  i32.const 8
+  i32.const 4
+  i32.eq
+  drop
+  i32.const 8
+  i32.const 8
+  i32.eq
+  drop
+  local.get $0
+  i64.reinterpret_f64
+  local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
+  i64.const 8
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $1
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 31
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 27
+  i64.rotl
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const -8796714831421723037
+  i64.add
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $2
+  local.get $2
+  local.get $2
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $2
+  local.get $2
+  return
  )
- (func $~lib/set/Set<f64>#find (param $0 i32) (param $1 f64) (param $2 i32) (result i32)
+ (func $~lib/set/Set<f64>#find (param $0 i32) (param $1 f64) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -7276,8 +7676,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -7340,9 +7741,8 @@
   (local $10 i32)
   (local $11 i32)
   (local $12 f64)
-  (local $13 f64)
+  (local $13 i64)
   (local $14 i32)
-  (local $15 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -7378,11 +7778,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 16
   i32.mul
   i32.add
@@ -7412,42 +7812,24 @@
      local.get $11
      local.get $12
      call $~lib/set/SetEntry<f64>#set:key
-     block $~lib/util/hash/HASH<f64>|inlined.2 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 1
-      drop
-      i32.const 8
-      i32.const 4
-      i32.eq
-      drop
-      i32.const 8
-      i32.const 8
-      i32.eq
-      drop
-      local.get $13
-      i64.reinterpret_f64
-      call $~lib/util/hash/hash64
-      br $~lib/util/hash/HASH<f64>|inlined.2
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<f64>
      local.get $1
-     i32.and
-     local.set $14
+     i64.extend_i32_u
+     i64.and
+     local.set $13
      local.get $3
-     local.get $14
+     local.get $13
+     i32.wrap_i64
      i32.const 4
      i32.mul
      i32.add
-     local.set $15
+     local.set $14
      local.get $11
-     local.get $15
+     local.get $14
      i32.load
      call $~lib/set/SetEntry<f64>#set:taggedNext
-     local.get $15
+     local.get $14
      local.get $8
      i32.store
      local.get $8
@@ -7467,6 +7849,7 @@
   call $~lib/set/Set<f64>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/set/Set<f64>#set:bucketsMask
   local.get $0
   local.get $5
@@ -7476,7 +7859,7 @@
   call $~lib/set/Set<f64>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/set/Set<f64>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -7485,7 +7868,7 @@
  )
  (func $~lib/set/Set<f64>#get:size (param $0 i32) (result i32)
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
  )
  (func $~lib/array/Array<f64>#set:buffer (param $0 i32) (param $1 i32)
   local.get $0
@@ -7571,9 +7954,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<f64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<f64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -7699,7 +8082,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7732,7 +8115,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7765,7 +8148,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7798,7 +8181,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7831,7 +8214,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7864,7 +8247,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7897,7 +8280,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7930,7 +8313,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7963,7 +8346,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -7996,7 +8379,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   drop
@@ -8182,7 +8565,6 @@
  )
  (func $~lib/set/Set<i8>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -8192,45 +8574,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i8>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
   call $~lib/set/Set<i8>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<i8>#add (param $0 i32) (param $1 i32) (result i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -8242,28 +8605,9 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<i8>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
+  local.set $2
   local.get $0
   local.set $5
   global.get $~lib/memory/__stack_pointer
@@ -8271,16 +8615,16 @@
   i32.store
   local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<i8>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -8290,68 +8634,70 @@
     i32.store
     local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i8>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $2
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<i8>#set:entriesOffset
-   local.get $2
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<i8>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<i8>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $2
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $2
    i32.load
    call $~lib/set/SetEntry<i8>#set:taggedNext
-   local.get $2
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
@@ -8433,10 +8779,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -8527,30 +8873,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i8>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 24
-   i32.shl
-   i32.const 24
-   i32.shr_s
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<i8>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i8>
   call $~lib/set/Set<i8>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -8562,41 +8889,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<i8>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<i8>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -8612,7 +8940,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/set/Set<i8>#rehash
   end
   i32.const 1
@@ -9140,7 +9468,6 @@
  )
  (func $~lib/set/Set<u8>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -9150,43 +9477,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u8>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
   call $~lib/set/Set<u8>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<u8>#add (param $0 i32) (param $1 i32) (result i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -9198,26 +9508,9 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<u8>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
+  local.set $2
   local.get $0
   local.set $5
   global.get $~lib/memory/__stack_pointer
@@ -9225,16 +9518,16 @@
   i32.store
   local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<u8>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -9244,68 +9537,70 @@
     i32.store
     local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u8>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $2
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<u8>#set:entriesOffset
-   local.get $2
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<u8>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<u8>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $2
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $2
    i32.load
    call $~lib/set/SetEntry<u8>#set:taggedNext
-   local.get $2
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
@@ -9387,10 +9682,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -9481,28 +9776,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u8>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   i32.const 1
-   i32.eq
-   drop
-   local.get $2
-   i32.const 255
-   i32.and
-   call $~lib/util/hash/hash8
-   br $~lib/util/hash/HASH<u8>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u8>
   call $~lib/set/Set<u8>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -9514,41 +9792,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<u8>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<u8>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -9564,7 +9843,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/set/Set<u8>#rehash
   end
   i32.const 1
@@ -10084,7 +10363,6 @@
  )
  (func $~lib/set/Set<i16>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -10094,49 +10372,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i16>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
   call $~lib/set/Set<i16>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<i16>#add (param $0 i32) (param $1 i32) (result i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -10148,32 +10403,9 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<i16>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
+  local.set $2
   local.get $0
   local.set $5
   global.get $~lib/memory/__stack_pointer
@@ -10181,16 +10413,16 @@
   i32.store
   local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<i16>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -10200,68 +10432,70 @@
     i32.store
     local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i16>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $2
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<i16>#set:entriesOffset
-   local.get $2
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<i16>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<i16>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $2
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $2
    i32.load
    call $~lib/set/SetEntry<i16>#set:taggedNext
-   local.get $2
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
@@ -10343,10 +10577,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -10423,48 +10657,25 @@
   (local $5 i32)
   (local $6 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
-  i32.sub
-  global.set $~lib/memory/__stack_pointer
-  call $~stack_check
-  global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store
-  local.get $0
-  local.set $6
-  global.get $~lib/memory/__stack_pointer
-  local.get $6
-  i32.store
-  local.get $6
-  local.get $1
-  block $~lib/util/hash/HASH<i16>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 16
-   i32.shl
-   i32.const 16
-   i32.shr_s
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<i16>|inlined.3
-  end
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  local.get $0
+  local.set $6
+  global.get $~lib/memory/__stack_pointer
+  local.get $6
+  i32.store
+  local.get $6
+  local.get $1
+  local.get $1
+  call $~lib/util/hash/HASH<i16>
   call $~lib/set/Set<i16>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -10476,41 +10687,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<i16>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<i16>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -10526,7 +10738,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/set/Set<i16>#rehash
   end
   i32.const 1
@@ -11054,7 +11266,6 @@
  )
  (func $~lib/set/Set<u16>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -11064,47 +11275,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u16>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
   call $~lib/set/Set<u16>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<u16>#add (param $0 i32) (param $1 i32) (result i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -11116,30 +11306,9 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<u16>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
+  local.set $2
   local.get $0
   local.set $5
   global.get $~lib/memory/__stack_pointer
@@ -11147,16 +11316,16 @@
   i32.store
   local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<u16>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -11166,68 +11335,70 @@
     i32.store
     local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u16>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $2
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<u16>#set:entriesOffset
-   local.get $2
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<u16>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<u16>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $2
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $2
    i32.load
    call $~lib/set/SetEntry<u16>#set:taggedNext
-   local.get $2
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
@@ -11309,10 +11480,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -11403,32 +11574,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u16>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 2
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 2
-   i32.const 2
-   i32.eq
-   drop
-   local.get $2
-   i32.const 65535
-   i32.and
-   call $~lib/util/hash/hash16
-   br $~lib/util/hash/HASH<u16>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u16>
   call $~lib/set/Set<u16>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -11440,41 +11590,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<u16>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<u16>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -11490,7 +11641,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/set/Set<u16>#rehash
   end
   i32.const 1
@@ -12010,7 +12161,6 @@
  )
  (func $~lib/set/Set<i32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -12020,49 +12170,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<i32>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
   call $~lib/set/Set<i32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<i32>#add (param $0 i32) (param $1 i32) (result i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -12074,32 +12201,9 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<i32>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
+  local.set $2
   local.get $0
   local.set $5
   global.get $~lib/memory/__stack_pointer
@@ -12107,16 +12211,16 @@
   i32.store
   local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<i32>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -12126,68 +12230,70 @@
     i32.store
     local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
-     local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     local.get $0
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i32>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $2
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<i32>#set:entriesOffset
-   local.get $2
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<i32>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<i32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $2
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $2
    i32.load
    call $~lib/set/SetEntry<i32>#set:taggedNext
-   local.get $2
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
@@ -12269,10 +12375,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -12363,34 +12469,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i32>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<i32>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i32>
   call $~lib/set/Set<i32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -12402,41 +12485,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<i32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<i32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -12452,7 +12536,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/set/Set<i32>#rehash
   end
   i32.const 1
@@ -12960,7 +13044,6 @@
  )
  (func $~lib/set/Set<u32>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -12970,49 +13053,26 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u32>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
   call $~lib/set/Set<u32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<u32>#add (param $0 i32) (param $1 i32) (result i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -13024,32 +13084,9 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<u32>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
+  local.set $2
   local.get $0
   local.set $5
   global.get $~lib/memory/__stack_pointer
@@ -13057,16 +13094,16 @@
   i32.store
   local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<u32>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -13076,68 +13113,70 @@
     i32.store
     local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u32>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $2
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<u32>#set:entriesOffset
-   local.get $2
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<u32>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<u32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $2
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $2
    i32.load
    call $~lib/set/SetEntry<u32>#set:taggedNext
-   local.get $2
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
@@ -13219,10 +13258,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -13313,34 +13352,11 @@
   i32.store
   local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u32>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<u32>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u32>
   call $~lib/set/Set<u32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
@@ -13352,41 +13368,42 @@
    local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<u32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<u32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $2
+  local.tee $4
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   local.tee $5
-  local.get $2
+  local.get $4
   local.get $5
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -13402,7 +13419,7 @@
    local.get $6
    i32.store
    local.get $6
-   local.get $4
+   local.get $3
    call $~lib/set/Set<u32>#rehash
   end
   i32.const 1
@@ -13909,68 +13926,39 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/set/Set<i64>#has (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
   global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store
-  local.get $0
-  local.set $3
-  global.get $~lib/memory/__stack_pointer
-  local.get $3
-  i32.store
-  local.get $3
-  local.get $1
-  block $~lib/util/hash/HASH<i64>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.0
-  end
+  i32.const 0
+  i32.store
+  local.get $0
+  local.set $2
+  global.get $~lib/memory/__stack_pointer
+  local.get $2
+  i32.store
+  local.get $2
+  local.get $1
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
   call $~lib/set/Set<i64>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<i64>#add (param $0 i32) (param $1 i64) (result i32)
   (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
-  (local $6 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -13979,133 +13967,108 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<i64>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
+  local.set $2
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
   i32.store
-  local.get $6
+  local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<i64>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $6
+    local.set $5
     global.get $~lib/memory/__stack_pointer
-    local.get $6
+    local.get $5
     i32.store
-    local.get $6
+    local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<i64>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $5
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<i64>#set:entriesOffset
-   local.get $5
+   local.get $4
    i32.const 16
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<i64>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<i64>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $5
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $5
    i32.load
    call $~lib/set/SetEntry<i64>#set:taggedNext
-   local.get $5
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
  )
  (func $~lib/array/Array<i64>#__set (param $0 i32) (param $1 i32) (param $2 i64)
   (local $3 i32)
@@ -14178,10 +14141,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -14252,12 +14215,11 @@
   local.get $9
  )
  (func $~lib/set/Set<i64>#delete (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -14267,90 +14229,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<i64>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<i64>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<i64>
   call $~lib/set/Set<i64>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<i64>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<i64>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -14361,21 +14297,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/set/Set<i64>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/set/testNumeric<i64>
   (local $0 i32)
@@ -14874,8 +14810,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/set/Set<u64>#has (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -14885,57 +14820,29 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<u64>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
   call $~lib/set/Set<u64>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<u64>#add (param $0 i32) (param $1 i64) (result i32)
   (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
-  (local $6 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -14944,133 +14851,108 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<u64>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
+  local.set $2
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
   i32.store
-  local.get $6
+  local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<u64>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $6
+    local.set $5
     global.get $~lib/memory/__stack_pointer
-    local.get $6
+    local.get $5
     i32.store
-    local.get $6
+    local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<u64>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $5
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<u64>#set:entriesOffset
-   local.get $5
+   local.get $4
    i32.const 16
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<u64>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<u64>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $5
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $5
    i32.load
    call $~lib/set/SetEntry<u64>#set:taggedNext
-   local.get $5
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
  )
  (func $~lib/array/Array<u64>#__set (param $0 i32) (param $1 i32) (param $2 i64)
   (local $3 i32)
@@ -15143,10 +15025,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -15217,12 +15099,11 @@
   local.get $9
  )
  (func $~lib/set/Set<u64>#delete (param $0 i32) (param $1 i64) (result i32)
-  (local $2 i64)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -15232,90 +15113,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<u64>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 8
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<u64>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<u64>
   call $~lib/set/Set<u64>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<u64>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<u64>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -15326,21 +15181,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/set/Set<u64>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/set/testNumeric<u64>
   (local $0 i32)
@@ -15839,8 +15694,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/set/Set<f32>#has (param $0 i32) (param $1 f32) (result i32)
-  (local $2 f32)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -15850,46 +15704,29 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<f32>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
   call $~lib/set/Set<f32>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<f32>#add (param $0 i32) (param $1 f32) (result i32)
-  (local $2 f32)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
-  (local $6 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -15898,122 +15735,108 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<f32>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
+  local.set $2
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
   i32.store
-  local.get $6
+  local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<f32>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $6
+    local.set $5
     global.get $~lib/memory/__stack_pointer
-    local.get $6
+    local.get $5
     i32.store
-    local.get $6
+    local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<f32>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $5
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<f32>#set:entriesOffset
-   local.get $5
+   local.get $4
    i32.const 8
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<f32>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<f32>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $5
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $5
    i32.load
    call $~lib/set/SetEntry<f32>#set:taggedNext
-   local.get $5
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
  )
  (func $~lib/array/Array<f32>#__set (param $0 i32) (param $1 i32) (param $2 f32)
   (local $3 i32)
@@ -16086,10 +15909,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -16160,12 +15983,11 @@
   local.get $9
  )
  (func $~lib/set/Set<f32>#delete (param $0 i32) (param $1 f32) (result i32)
-  (local $2 f32)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -16175,79 +15997,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<f32>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   i32.reinterpret_f32
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<f32>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f32>
   call $~lib/set/Set<f32>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=4
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<f32>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<f32>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -16258,21 +16065,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/set/Set<f32>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/set/testNumeric<f32>
   (local $0 i32)
@@ -16771,8 +16578,7 @@
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/set/Set<f64>#has (param $0 i32) (param $1 f64) (result i32)
-  (local $2 f64)
-  (local $3 i32)
+  (local $2 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -16782,50 +16588,29 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<f64>|inlined.0 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.0
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
   call $~lib/set/Set<f64>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/set/Set<f64>#add (param $0 i32) (param $1 f64) (result i32)
-  (local $2 f64)
+  (local $2 i64)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
-  (local $6 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -16834,126 +16619,108 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store
-  block $~lib/util/hash/HASH<f64>|inlined.1 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.1
-  end
-  local.set $3
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
+  local.set $2
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
   i32.store
-  local.get $6
+  local.get $5
   local.get $1
-  local.get $3
+  local.get $2
   call $~lib/set/Set<f64>#find
-  local.set $4
-  local.get $4
+  local.set $3
+  local.get $3
   i32.eqz
   if
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
-    local.set $6
+    local.set $5
     global.get $~lib/memory/__stack_pointer
-    local.get $6
+    local.get $5
     i32.store
-    local.get $6
+    local.get $5
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/set/Set<f64>#rehash
    end
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.get $0
    local.get $0
-   i32.load offset=16
-   local.tee $5
+   i32.load offset=24
+   local.tee $4
    i32.const 1
    i32.add
    call $~lib/set/Set<f64>#set:entriesOffset
-   local.get $5
+   local.get $4
    i32.const 16
    i32.mul
    i32.add
-   local.set $4
-   local.get $4
+   local.set $3
+   local.get $3
    local.get $1
    call $~lib/set/SetEntry<f64>#set:key
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/set/Set<f64>#set:entriesCount
    local.get $0
    i32.load
-   local.get $3
+   local.get $2
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
-   local.set $5
+   local.set $4
+   local.get $3
    local.get $4
-   local.get $5
    i32.load
    call $~lib/set/SetEntry<f64>#set:taggedNext
-   local.get $5
    local.get $4
+   local.get $3
    i32.store
   end
   local.get $0
-  local.set $6
+  local.set $5
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $6
+  local.get $5
  )
  (func $~lib/array/Array<f64>#__set (param $0 i32) (param $1 i32) (param $2 f64)
   (local $3 i32)
@@ -17026,10 +16793,10 @@
   i64.const 0
   i64.store
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $1
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 0
@@ -17100,12 +16867,11 @@
   local.get $9
  )
  (func $~lib/set/Set<f64>#delete (param $0 i32) (param $1 f64) (result i32)
-  (local $2 f64)
+  (local $2 i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
-  (local $7 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -17115,83 +16881,64 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
   i32.store
-  local.get $7
+  local.get $6
   local.get $1
-  block $~lib/util/hash/HASH<f64>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 1
-   drop
-   i32.const 8
-   i32.const 4
-   i32.eq
-   drop
-   i32.const 8
-   i32.const 8
-   i32.eq
-   drop
-   local.get $2
-   i64.reinterpret_f64
-   call $~lib/util/hash/hash64
-   br $~lib/util/hash/HASH<f64>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<f64>
   call $~lib/set/Set<f64>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
    global.set $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    return
   end
-  local.get $3
-  local.get $3
+  local.get $2
+  local.get $2
   i32.load offset=8
   i32.const 1
   i32.or
   call $~lib/set/SetEntry<f64>#set:taggedNext
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   i32.const 1
   i32.sub
   call $~lib/set/Set<f64>#set:entriesCount
   local.get $0
-  i32.load offset=4
-  i32.const 1
-  i32.shr_u
-  local.set $4
-  local.get $4
+  i64.load offset=8
+  i64.const 1
+  i64.shr_u
+  i32.wrap_i64
+  local.set $3
+  local.get $3
   i32.const 1
   i32.add
   i32.const 4
-  local.tee $5
+  local.tee $4
   local.get $0
-  i32.load offset=20
-  local.tee $6
+  i32.load offset=28
+  local.tee $5
+  local.get $4
   local.get $5
-  local.get $6
   i32.gt_u
   select
   i32.ge_u
   if (result i32)
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.const 3
    i32.mul
    i32.const 4
@@ -17202,21 +16949,21 @@
   end
   if
    local.get $0
-   local.set $7
+   local.set $6
    global.get $~lib/memory/__stack_pointer
-   local.get $7
+   local.get $6
    i32.store
-   local.get $7
-   local.get $4
+   local.get $6
+   local.get $3
    call $~lib/set/Set<f64>#rehash
   end
   i32.const 1
-  local.set $7
+  local.set $6
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $7
+  local.get $6
  )
  (func $std/set/testNumeric<f64>
   (local $0 i32)
@@ -17768,7 +17515,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 3
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -17782,9 +17529,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i8>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i8>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -17905,7 +17652,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 5
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -17919,9 +17666,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u8>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u8>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18042,7 +17789,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 7
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18056,9 +17803,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i16>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i16>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18179,7 +17926,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 9
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18193,9 +17940,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u16>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u16>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18316,7 +18063,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 11
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18330,9 +18077,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18453,7 +18200,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 13
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18467,9 +18214,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18590,7 +18337,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 15
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18604,9 +18351,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<i64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<i64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18727,7 +18474,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 17
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18741,9 +18488,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<u64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<u64>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -18864,7 +18611,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 19
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -18878,9 +18625,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<f32>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<f32>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -19001,7 +18748,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 21
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -19015,9 +18762,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/set/Set<f64>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/set/Set<f64>#set:bucketsMask
   local.get $0
   i32.const 0
diff --git a/tests/compiler/std/symbol.optimized.wat b/tests/compiler/std/symbol.optimized.wat
index 01056c78d2..54e741cfab 100644
--- a/tests/compiler/std/symbol.optimized.wat
+++ b/tests/compiler/std/symbol.optimized.wat
@@ -1,13 +1,15 @@
 (module
  (type $i32_i32_=>_none (func (param i32 i32)))
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
- (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $none_=>_none (func))
  (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
+ (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $i32_=>_none (func (param i32)))
  (type $none_=>_i32 (func (result i32)))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
- (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i32_i64_=>_i32 (func (param i32 i32 i64) (result i32)))
+ (type $i32_i64_=>_i32 (func (param i32 i64) (result i32)))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
  (memory $0 1)
  (data (i32.const 1036) "\1c")
@@ -1918,50 +1920,55 @@
  (func $~lib/map/Map<~lib/string/String,usize>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.const -2128831035
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
+ (func $~lib/util/hash/HASH<usize> (param $0 i32) (result i64)
+  (local $1 i64)
   local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.const 2870177450012600265
+  i64.xor
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.tee $1
+  local.get $1
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  i64.const -4417276706812531889
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  i64.const 1609587929392839161
+  i64.mul
+  local.tee $1
+  local.get $1
+  i64.const 32
+  i64.shr_u
+  i64.xor
  )
- (func $~lib/map/Map<usize,~lib/string/String>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<usize,~lib/string/String>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
+  (local $3 i32)
   local.get $0
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -1972,7 +1979,7 @@
    if
     local.get $0
     i32.load offset=8
-    local.tee $2
+    local.tee $3
     i32.const 1
     i32.and
     if (result i32)
@@ -1987,7 +1994,7 @@
      local.get $0
      return
     end
-    local.get $2
+    local.get $3
     i32.const -2
     i32.and
     local.set $0
@@ -2035,10 +2042,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -2068,9 +2075,11 @@
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hash32
+     call $~lib/util/hash/HASH<usize>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2097,17 +2106,18 @@
   call $~lib/map/Map<~lib/string/String,usize>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<~lib/string/String,usize>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.add
@@ -2318,11 +2328,11 @@
     i32.load
     call $~lib/rt/itcms/__visit
     local.get $0
-    i32.load offset=8
+    i32.load offset=16
     local.tee $2
     local.tee $1
     local.get $0
-    i32.load offset=16
+    i32.load offset=24
     i32.const 12
     i32.mul
     i32.add
@@ -2357,11 +2367,11 @@
    i32.load
    call $~lib/rt/itcms/__visit
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $2
    local.tee $1
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    i32.const 12
    i32.mul
    i32.add
@@ -2416,25 +2426,35 @@
    unreachable
   end
  )
- (func $~lib/util/hash/hashStr (param $0 i32) (result i32)
+ (func $~lib/util/hash/HASH<~lib/string/String> (param $0 i32) (result i64)
   (local $1 i32)
-  (local $2 i32)
+  (local $2 i64)
   (local $3 i32)
+  (local $4 i32)
+  (local $5 i64)
+  (local $6 i64)
+  (local $7 i64)
+  (local $8 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
   global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store
-  i32.const -2128831035
-  local.set $1
-  local.get $0
-  if
+  i64.const 0
+  i64.store
+  block $~lib/util/hash/hashStr|inlined.0 (result i64)
    global.get $~lib/memory/__stack_pointer
    local.get $0
    i32.store
+   i64.const 0
+   local.get $0
+   i32.eqz
+   br_if $~lib/util/hash/hashStr|inlined.0
+   drop
+   global.get $~lib/memory/__stack_pointer
+   local.get $0
+   i32.store offset=4
    local.get $0
    i32.const 20
    i32.sub
@@ -2443,34 +2463,262 @@
    i32.shr_u
    i32.const 1
    i32.shl
-   local.set $3
-   loop $for-loop|0
+   local.tee $3
+   i32.const 32
+   i32.ge_s
+   if (result i64)
+    i64.const 6983438078262162902
+    local.set $2
+    i64.const -4417276706812531889
+    local.set $5
+    i64.const 7046029288634856825
+    local.set $6
+    local.get $3
+    i32.const 32
+    i32.sub
+    local.set $8
+    loop $while-continue|0
+     local.get $1
+     local.get $8
+     i32.le_s
+     if
+      local.get $2
+      local.get $0
+      local.get $1
+      i32.add
+      local.tee $4
+      i64.load
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $2
+      local.get $5
+      local.get $4
+      i64.load offset=8
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $5
+      local.get $7
+      local.get $4
+      i64.load offset=16
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $7
+      local.get $6
+      local.get $4
+      i64.load offset=24
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $6
+      local.get $1
+      i32.const 32
+      i32.add
+      local.set $1
+      br $while-continue|0
+     end
+    end
+    local.get $3
+    i64.extend_i32_s
+    local.get $2
+    i64.const 1
+    i64.rotl
+    local.get $5
+    i64.const 7
+    i64.rotl
+    i64.add
+    local.get $7
+    i64.const 12
+    i64.rotl
+    i64.add
+    local.get $6
+    i64.const 18
+    i64.rotl
+    i64.add
     local.get $2
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    local.get $5
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    local.get $7
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    local.get $6
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const 8796714831421723037
+    i64.sub
+    i64.add
+   else
     local.get $3
-    i32.lt_u
+    i64.extend_i32_s
+    i64.const 2870177450012600261
+    i64.add
+   end
+   local.set $2
+   local.get $3
+   i32.const 8
+   i32.sub
+   local.set $4
+   loop $while-continue|1
+    local.get $1
+    local.get $4
+    i32.le_s
     if
-     local.get $1
-     local.get $0
      local.get $2
+     local.get $0
+     local.get $1
+     i32.add
+     i64.load
+     i64.const -4417276706812531889
+     i64.mul
+     i64.const 31
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.xor
+     i64.const 27
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.const 8796714831421723037
+     i64.sub
+     local.set $2
+     local.get $1
+     i32.const 8
      i32.add
-     i32.load8_u
-     i32.xor
-     i32.const 16777619
-     i32.mul
      local.set $1
+     br $while-continue|1
+    end
+   end
+   local.get $3
+   local.get $1
+   i32.const 4
+   i32.add
+   i32.ge_s
+   if
+    local.get $2
+    local.get $0
+    local.get $1
+    i32.add
+    i64.load32_u
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const 23
+    i64.rotl
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 1609587929392839161
+    i64.add
+    local.set $2
+    local.get $1
+    i32.const 4
+    i32.add
+    local.set $1
+   end
+   loop $while-continue|2
+    local.get $1
+    local.get $3
+    i32.lt_s
+    if
      local.get $2
-     i32.const 1
+     local.get $0
+     local.get $1
      i32.add
+     i64.load8_u
+     i64.const 2870177450012600261
+     i64.mul
+     i64.add
+     i64.const 11
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
      local.set $2
-     br $for-loop|0
+     local.get $1
+     i32.const 1
+     i32.add
+     local.set $1
+     br $while-continue|2
     end
    end
+   local.get $2
+   local.get $2
+   i64.const 33
+   i64.shr_u
+   i64.xor
+   i64.const -4417276706812531889
+   i64.mul
+   local.tee $2
+   local.get $2
+   i64.const 29
+   i64.shr_u
+   i64.xor
+   i64.const 1609587929392839161
+   i64.mul
+   local.tee $2
+   local.get $2
+   i64.const 32
+   i64.shr_u
+   i64.xor
   end
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $1
  )
  (func $~lib/string/String.__eq (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
@@ -2618,8 +2866,9 @@
   global.set $~lib/memory/__stack_pointer
   i32.const 0
  )
- (func $~lib/map/Map<~lib/string/String,usize>#find (param $0 i32) (param $1 i32) (result i32)
+ (func $~lib/map/Map<~lib/string/String,usize>#find (param $0 i32) (param $1 i64) (result i32)
   (local $2 i32)
+  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
   i32.sub
@@ -2632,8 +2881,9 @@
   i32.load
   local.get $1
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 2
   i32.shl
   i32.add
@@ -2653,12 +2903,12 @@
      global.get $~lib/memory/__stack_pointer
      local.get $0
      i32.load
-     local.tee $1
+     local.tee $3
      i32.store
      global.get $~lib/memory/__stack_pointer
      i32.const 1056
      i32.store offset=4
-     local.get $1
+     local.get $3
      i32.const 1056
      call $~lib/string/String.__eq
     end
@@ -2692,7 +2942,7 @@
   (local $7 i32)
   (local $8 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 20
+  i32.const 16
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
@@ -2703,9 +2953,6 @@
   i64.const 0
   i64.store offset=8
   global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store offset=16
-  global.get $~lib/memory/__stack_pointer
   local.get $1
   i32.const 1
   i32.add
@@ -2728,10 +2975,10 @@
   local.tee $3
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.tee $8
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -2764,15 +3011,14 @@
      global.get $~lib/memory/__stack_pointer
      local.get $7
      i32.store offset=12
-     global.get $~lib/memory/__stack_pointer
-     local.get $7
-     i32.store offset=16
      local.get $2
      local.get $6
      local.get $7
-     call $~lib/util/hash/hashStr
+     call $~lib/util/hash/HASH<~lib/string/String>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      i32.const 2
      i32.shl
      i32.add
@@ -2799,25 +3045,26 @@
   call $~lib/map/Map<~lib/string/String,usize>#set:buckets
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.extend_i32_u
+  i64.store offset=8
   local.get $0
   local.get $3
   call $~lib/map/Map<~lib/string/String,usize>#set:entries
   local.get $0
   local.get $5
-  i32.store offset=12
+  i32.store offset=20
   local.get $0
   local.get $0
-  i32.load offset=20
-  i32.store offset=16
+  i32.load offset=28
+  i32.store offset=24
   global.get $~lib/memory/__stack_pointer
-  i32.const 20
+  i32.const 16
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/map/Map<~lib/string/String,usize>#set (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 12
@@ -2833,18 +3080,15 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 1056
   i32.store
-  global.get $~lib/memory/__stack_pointer
   i32.const 1056
-  i32.store offset=4
-  i32.const 1056
-  call $~lib/util/hash/hashStr
+  call $~lib/util/hash/HASH<~lib/string/String>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
-  i32.store offset=4
+  i32.store
   global.get $~lib/memory/__stack_pointer
   i32.const 1056
-  i32.store offset=8
+  i32.store offset=4
   local.get $0
   local.get $3
   call $~lib/map/Map<~lib/string/String,usize>#find
@@ -2855,49 +3099,50 @@
    i32.store offset=4
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
     local.get $0
-    i32.store offset=4
+    i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<~lib/string/String,usize>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $2
-   i32.store
+   i32.store offset=8
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $2
    local.get $4
    i32.const 12
@@ -2915,17 +3160,18 @@
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -2943,7 +3189,7 @@
  )
  (func $~lib/map/Map<usize,~lib/string/String>#set (param $0 i32) (param $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -2954,7 +3200,7 @@
   i64.const 0
   i64.store
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<usize>
   local.set $3
   global.get $~lib/memory/__stack_pointer
   local.get $0
@@ -2974,9 +3220,9 @@
    call $~lib/rt/itcms/__link
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     global.get $~lib/memory/__stack_pointer
@@ -2984,39 +3230,40 @@
     i32.store
     local.get $0
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<usize,~lib/string/String>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
+   i32.load offset=16
    local.tee $2
    i32.store offset=4
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $4
    i32.const 1
    i32.add
-   i32.store offset=16
+   i32.store offset=24
    local.get $2
    local.get $4
    i32.const 12
@@ -3034,17 +3281,18 @@
    call $~lib/rt/itcms/__link
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
-   i32.store offset=20
+   i32.store offset=28
    local.get $2
    local.get $0
    i32.load
    local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 2
    i32.shl
    i32.add
@@ -3084,7 +3332,7 @@
    i32.const 1056
    i32.store offset=4
    global.get $~lib/memory/__stack_pointer
-   i32.const 16
+   i32.const 12
    i32.sub
    global.set $~lib/memory/__stack_pointer
    call $~stack_check
@@ -3092,8 +3340,8 @@
    i64.const 0
    i64.store
    global.get $~lib/memory/__stack_pointer
-   i64.const 0
-   i64.store offset=8
+   i32.const 0
+   i32.store offset=8
    global.get $~lib/memory/__stack_pointer
    local.get $0
    i32.store
@@ -3103,17 +3351,14 @@
    global.get $~lib/memory/__stack_pointer
    i32.const 1056
    i32.store offset=8
-   global.get $~lib/memory/__stack_pointer
-   i32.const 1056
-   i32.store offset=12
    local.get $0
    i32.const 1056
-   call $~lib/util/hash/hashStr
+   call $~lib/util/hash/HASH<~lib/string/String>
    call $~lib/map/Map<~lib/string/String,usize>#find
    i32.const 0
    i32.ne
    global.get $~lib/memory/__stack_pointer
-   i32.const 16
+   i32.const 12
    i32.add
    global.set $~lib/memory/__stack_pointer
    if
@@ -3125,7 +3370,7 @@
     i32.const 1056
     i32.store offset=4
     global.get $~lib/memory/__stack_pointer
-    i32.const 16
+    i32.const 12
     i32.sub
     global.set $~lib/memory/__stack_pointer
     call $~stack_check
@@ -3133,8 +3378,8 @@
     i64.const 0
     i64.store
     global.get $~lib/memory/__stack_pointer
-    i64.const 0
-    i64.store offset=8
+    i32.const 0
+    i32.store offset=8
     global.get $~lib/memory/__stack_pointer
     local.get $0
     i32.store
@@ -3144,12 +3389,9 @@
     global.get $~lib/memory/__stack_pointer
     i32.const 1056
     i32.store offset=8
-    global.get $~lib/memory/__stack_pointer
-    i32.const 1056
-    i32.store offset=12
     local.get $0
     i32.const 1056
-    call $~lib/util/hash/hashStr
+    call $~lib/util/hash/HASH<~lib/string/String>
     call $~lib/map/Map<~lib/string/String,usize>#find
     local.tee $0
     i32.eqz
@@ -3164,7 +3406,7 @@
     local.get $0
     i32.load offset=4
     global.get $~lib/memory/__stack_pointer
-    i32.const 16
+    i32.const 12
     i32.add
     global.set $~lib/memory/__stack_pointer
     global.get $~lib/memory/__stack_pointer
@@ -3183,7 +3425,7 @@
    i32.const 0
    i32.store
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 3
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -3193,21 +3435,21 @@
    call $~lib/arraybuffer/ArrayBuffer#constructor
    call $~lib/map/Map<~lib/string/String,usize>#set:buckets
    local.get $0
-   i32.const 3
-   i32.store offset=4
+   i64.const 3
+   i64.store offset=8
    local.get $0
    i32.const 48
    call $~lib/arraybuffer/ArrayBuffer#constructor
    call $~lib/map/Map<~lib/string/String,usize>#set:entries
    local.get $0
    i32.const 4
-   i32.store offset=12
+   i32.store offset=20
    local.get $0
    i32.const 0
-   i32.store offset=16
+   i32.store offset=24
    local.get $0
    i32.const 0
-   i32.store offset=20
+   i32.store offset=28
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
@@ -3223,7 +3465,7 @@
    i32.const 0
    i32.store
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 4
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -3233,21 +3475,21 @@
    call $~lib/arraybuffer/ArrayBuffer#constructor
    call $~lib/map/Map<~lib/string/String,usize>#set:buckets
    local.get $0
-   i32.const 3
-   i32.store offset=4
+   i64.const 3
+   i64.store offset=8
    local.get $0
    i32.const 48
    call $~lib/arraybuffer/ArrayBuffer#constructor
    call $~lib/map/Map<~lib/string/String,usize>#set:entries
    local.get $0
    i32.const 4
-   i32.store offset=12
+   i32.store offset=20
    local.get $0
    i32.const 0
-   i32.store offset=16
+   i32.store offset=24
    local.get $0
    i32.const 0
-   i32.store offset=20
+   i32.store offset=28
    global.get $~lib/memory/__stack_pointer
    i32.const 4
    i32.add
@@ -3306,7 +3548,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<usize>
   call $~lib/map/Map<usize,~lib/string/String>#find
   i32.const 0
   i32.ne
@@ -3330,7 +3572,7 @@
   local.get $0
   local.get $1
   local.get $1
-  call $~lib/util/hash/hash32
+  call $~lib/util/hash/HASH<usize>
   call $~lib/map/Map<usize,~lib/string/String>#find
   local.tee $0
   i32.eqz
diff --git a/tests/compiler/std/symbol.untouched.wat b/tests/compiler/std/symbol.untouched.wat
index c840db0621..c0cafd691c 100644
--- a/tests/compiler/std/symbol.untouched.wat
+++ b/tests/compiler/std/symbol.untouched.wat
@@ -6,6 +6,9 @@
  (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
  (type $none_=>_none (func))
  (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i64_=>_none (func (param i32 i64)))
+ (type $i32_i32_i64_=>_i32 (func (param i32 i32 i64) (result i32)))
+ (type $i32_=>_i64 (func (param i32) (result i64)))
  (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
  (type $none_=>_i32 (func (result i32)))
  (type $i32_i32_i32_i32_i32_=>_i32 (func (param i32 i32 i32 i32 i32) (result i32)))
@@ -2488,15 +2491,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<~lib/string/String,usize>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<~lib/string/String,usize>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<~lib/string/String,usize>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -2505,17 +2508,17 @@
  (func $~lib/map/Map<~lib/string/String,usize>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<~lib/string/String,usize>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<~lib/string/String,usize>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/map/Map<usize,~lib/string/String>#set:buckets (param $0 i32) (param $1 i32)
   local.get $0
@@ -2526,15 +2529,15 @@
   i32.const 0
   call $~lib/rt/itcms/__link
  )
- (func $~lib/map/Map<usize,~lib/string/String>#set:bucketsMask (param $0 i32) (param $1 i32)
+ (func $~lib/map/Map<usize,~lib/string/String>#set:bucketsMask (param $0 i32) (param $1 i64)
   local.get $0
   local.get $1
-  i32.store offset=4
+  i64.store offset=8
  )
  (func $~lib/map/Map<usize,~lib/string/String>#set:entries (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=8
+  i32.store offset=16
   local.get $0
   local.get $1
   i32.const 0
@@ -2543,17 +2546,17 @@
  (func $~lib/map/Map<usize,~lib/string/String>#set:entriesCapacity (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=12
+  i32.store offset=20
  )
  (func $~lib/map/Map<usize,~lib/string/String>#set:entriesOffset (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=16
+  i32.store offset=24
  )
  (func $~lib/map/Map<usize,~lib/string/String>#set:entriesCount (param $0 i32) (param $1 i32)
   local.get $0
   local.get $1
-  i32.store offset=20
+  i32.store offset=28
  )
  (func $~lib/string/String#get:length (param $0 i32) (result i32)
   local.get $0
@@ -2685,49 +2688,75 @@
   local.get $1
   i32.store offset=8
  )
- (func $~lib/util/hash/hash32 (param $0 i32) (result i32)
-  (local $1 i32)
-  i32.const -2128831035
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 8
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
-  local.get $0
-  i32.const 16
-  i32.shr_u
-  i32.const 255
-  i32.and
-  i32.xor
-  i32.const 16777619
-  i32.mul
-  local.set $1
-  local.get $1
+ (func $~lib/util/hash/HASH<usize> (param $0 i32) (result i64)
+  (local $1 i64)
+  (local $2 i32)
+  (local $3 i64)
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 0
+  drop
+  i32.const 4
+  i32.const 4
+  i32.le_u
+  drop
   local.get $0
-  i32.const 24
-  i32.shr_u
-  i32.xor
-  i32.const 16777619
-  i32.mul
+  local.set $2
+  i64.const 4
   local.set $1
+  i64.const 0
+  i64.const 2870177450012600261
+  i64.add
   local.get $1
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $2
+  i64.extend_i32_u
+  i64.const -7046029288634856825
+  i64.mul
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 23
+  i64.rotl
+  i64.const -4417276706812531889
+  i64.mul
+  i64.const 1609587929392839161
+  i64.add
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 33
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const -4417276706812531889
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 29
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  i64.const 1609587929392839161
+  i64.mul
+  local.set $3
+  local.get $3
+  local.get $3
+  i64.const 32
+  i64.shr_u
+  i64.xor
+  local.set $3
+  local.get $3
+  return
  )
- (func $~lib/map/Map<usize,~lib/string/String>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<usize,~lib/string/String>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -2735,8 +2764,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -2841,11 +2871,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -2879,33 +2909,12 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<usize,~lib/string/String>#set:value
-     block $~lib/util/hash/HASH<usize>|inlined.1 (result i32)
-      local.get $12
-      local.set $13
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 0
-      drop
-      i32.const 4
-      i32.const 1
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 2
-      i32.eq
-      drop
-      i32.const 4
-      i32.const 4
-      i32.eq
-      drop
-      local.get $13
-      call $~lib/util/hash/hash32
-      br $~lib/util/hash/HASH<usize>|inlined.1
-     end
+     local.get $12
+     call $~lib/util/hash/HASH<usize>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -2937,6 +2946,7 @@
   call $~lib/map/Map<usize,~lib/string/String>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<usize,~lib/string/String>#set:bucketsMask
   local.get $0
   local.get $5
@@ -2946,7 +2956,7 @@
   call $~lib/map/Map<usize,~lib/string/String>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<usize,~lib/string/String>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
   i32.const 8
@@ -4286,7 +4296,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 1
   if (result i32)
@@ -4299,7 +4309,7 @@
   local.set $3
   local.get $3
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -4360,7 +4370,7 @@
   local.get $1
   call $~lib/rt/itcms/__visit
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $2
   i32.const 0
   if (result i32)
@@ -4373,7 +4383,7 @@
   local.set $3
   local.get $3
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -4478,69 +4488,407 @@
    unreachable
   end
  )
- (func $~lib/util/hash/hashStr (param $0 i32) (result i32)
+ (func $~lib/util/hash/HASH<~lib/string/String> (param $0 i32) (result i64)
   (local $1 i32)
   (local $2 i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
-  (local $5 i32)
+  (local $5 i64)
+  (local $6 i64)
+  (local $7 i64)
+  (local $8 i64)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  (local $12 i64)
+  (local $13 i64)
+  (local $14 i32)
+  (local $15 i64)
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
   global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store
-  i32.const -2128831035
-  local.set $1
-  local.get $0
-  i32.const 0
-  i32.ne
-  if
-   i32.const 0
-   local.set $2
-   local.get $0
-   local.set $5
+  i64.const 0
+  i64.store
+  i32.const 1
+  drop
+  block $~lib/util/hash/hashStr|inlined.0 (result i64)
    global.get $~lib/memory/__stack_pointer
-   local.get $5
+   local.get $0
+   local.tee $1
    i32.store
-   local.get $5
+   local.get $1
+   i32.const 0
+   i32.eq
+   if
+    i64.const 0
+    br $~lib/util/hash/hashStr|inlined.0
+   end
+   local.get $1
+   local.set $14
+   global.get $~lib/memory/__stack_pointer
+   local.get $14
+   i32.store offset=4
+   local.get $14
    call $~lib/string/String#get:length
    i32.const 1
    i32.shl
+   local.set $2
+   i64.const 0
    local.set $3
-   loop $for-loop|0
+   i32.const 0
+   local.set $4
+   local.get $2
+   i32.const 32
+   i32.ge_s
+   if
+    i64.const 0
+    i64.const -7046029288634856825
+    i64.add
+    i64.const -4417276706812531889
+    i64.add
+    local.set $5
+    i64.const 0
+    i64.const -4417276706812531889
+    i64.add
+    local.set $6
+    i64.const 0
+    local.set $7
+    i64.const 0
+    i64.const -7046029288634856825
+    i64.sub
+    local.set $8
+    local.get $2
+    local.set $9
     local.get $2
+    i32.const 32
+    i32.sub
+    local.set $10
+    loop $while-continue|0
+     local.get $4
+     local.get $10
+     i32.le_s
+     local.set $11
+     local.get $11
+     if
+      local.get $5
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $5
+      local.get $6
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=8
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $6
+      local.get $7
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=16
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $7
+      local.get $8
+      local.set $13
+      local.get $1
+      local.get $4
+      i32.add
+      i64.load offset=24
+      local.set $12
+      local.get $13
+      local.get $12
+      i64.const -4417276706812531889
+      i64.mul
+      i64.add
+      i64.const 31
+      i64.rotl
+      i64.const -7046029288634856825
+      i64.mul
+      local.set $8
+      local.get $4
+      i32.const 32
+      i32.add
+      local.set $4
+      br $while-continue|0
+     end
+    end
+    local.get $5
+    i64.const 1
+    i64.rotl
+    local.get $6
+    i64.const 7
+    i64.rotl
+    i64.add
+    local.get $7
+    i64.const 12
+    i64.rotl
+    i64.add
+    local.get $8
+    i64.const 18
+    i64.rotl
+    i64.add
+    local.set $3
+    local.get $5
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $5
+    local.get $6
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $6
+    local.get $7
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $7
+    local.get $8
+    i64.const -4417276706812531889
+    i64.mul
+    local.set $8
     local.get $3
-    i32.lt_u
-    local.set $4
+    local.set $13
+    local.get $5
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $6
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $7
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.set $13
+    local.get $8
+    local.set $12
+    local.get $13
+    local.get $12
+    i64.const 31
+    i64.rotl
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    i64.const -7046029288634856825
+    i64.mul
+    i64.const -8796714831421723037
+    i64.add
+    local.set $3
+    local.get $3
+    local.get $9
+    i64.extend_i32_s
+    i64.add
+    local.set $3
+   else
+    local.get $2
+    i64.extend_i32_s
+    i64.const 0
+    i64.add
+    i64.const 2870177450012600261
+    i64.add
+    local.set $3
+   end
+   local.get $2
+   i32.const 8
+   i32.sub
+   local.set $10
+   loop $while-continue|1
     local.get $4
+    local.get $10
+    i32.le_s
+    local.set $9
+    local.get $9
     if
+     local.get $3
      local.get $1
-     local.get $0
-     local.get $2
+     local.get $4
      i32.add
-     i32.load8_u
-     i32.xor
-     i32.const 16777619
-     i32.mul
-     local.set $1
-     local.get $2
+     i64.load
+     i64.const -4417276706812531889
+     i64.mul
+     i64.const 31
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.xor
+     local.set $3
+     local.get $3
+     i64.const 27
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     i64.const -8796714831421723037
+     i64.add
+     local.set $3
+     local.get $4
+     i32.const 8
+     i32.add
+     local.set $4
+     br $while-continue|1
+    end
+   end
+   local.get $4
+   i32.const 4
+   i32.add
+   local.get $2
+   i32.le_s
+   if
+    local.get $3
+    local.get $1
+    local.get $4
+    i32.add
+    i64.load32_u
+    i64.const -7046029288634856825
+    i64.mul
+    i64.xor
+    local.set $3
+    local.get $3
+    i64.const 23
+    i64.rotl
+    i64.const -4417276706812531889
+    i64.mul
+    i64.const 1609587929392839161
+    i64.add
+    local.set $3
+    local.get $4
+    i32.const 4
+    i32.add
+    local.set $4
+   end
+   loop $while-continue|2
+    local.get $4
+    local.get $2
+    i32.lt_s
+    local.set $9
+    local.get $9
+    if
+     local.get $3
+     local.get $1
+     local.get $4
+     i32.add
+     i64.load8_u
+     i64.const 2870177450012600261
+     i64.mul
+     i64.add
+     local.set $3
+     local.get $3
+     i64.const 11
+     i64.rotl
+     i64.const -7046029288634856825
+     i64.mul
+     local.set $3
+     local.get $4
      i32.const 1
      i32.add
-     local.set $2
-     br $for-loop|0
+     local.set $4
+     br $while-continue|2
     end
    end
+   local.get $3
+   local.get $3
+   i64.const 33
+   i64.shr_u
+   i64.xor
+   local.set $3
+   local.get $3
+   i64.const -4417276706812531889
+   i64.mul
+   local.set $3
+   local.get $3
+   local.get $3
+   i64.const 29
+   i64.shr_u
+   i64.xor
+   local.set $3
+   local.get $3
+   i64.const 1609587929392839161
+   i64.mul
+   local.set $3
+   local.get $3
+   local.get $3
+   i64.const 32
+   i64.shr_u
+   i64.xor
+   local.set $3
+   local.get $3
   end
-  local.get $1
-  local.set $5
+  local.set $15
   global.get $~lib/memory/__stack_pointer
-  i32.const 4
+  i32.const 8
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $5
+  local.get $15
+  return
  )
  (func $~lib/string/String.__eq (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
@@ -4637,7 +4985,7 @@
   global.set $~lib/memory/__stack_pointer
   local.get $3
  )
- (func $~lib/map/Map<~lib/string/String,usize>#find (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+ (func $~lib/map/Map<~lib/string/String,usize>#find (param $0 i32) (param $1 i32) (param $2 i64) (result i32)
   (local $3 i32)
   (local $4 i32)
   (local $5 i32)
@@ -4654,8 +5002,9 @@
   i32.load
   local.get $2
   local.get $0
-  i32.load offset=4
-  i32.and
+  i64.load offset=8
+  i64.and
+  i32.wrap_i64
   i32.const 4
   i32.mul
   i32.add
@@ -4720,9 +5069,8 @@
  )
  (func $~lib/map/Map<~lib/string/String,usize>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 16
+  i32.const 12
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
@@ -4730,52 +5078,42 @@
   i64.const 0
   i64.store
   global.get $~lib/memory/__stack_pointer
-  i64.const 0
-  i64.store offset=8
+  i32.const 0
+  i32.store offset=8
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store offset=4
-  local.get $3
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.0 (result i32)
-   global.get $~lib/memory/__stack_pointer
-   local.get $1
-   local.tee $2
-   i32.store offset=8
-   i32.const 1
-   drop
-   local.get $2
-   local.set $3
-   global.get $~lib/memory/__stack_pointer
-   local.get $3
-   i32.store offset=12
-   local.get $3
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.0
-  end
+  local.get $2
+  local.get $1
+  local.set $2
+  global.get $~lib/memory/__stack_pointer
+  local.get $2
+  i32.store offset=8
+  local.get $2
+  call $~lib/util/hash/HASH<~lib/string/String>
   call $~lib/map/Map<~lib/string/String,usize>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  i32.const 16
+  i32.const 12
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<~lib/string/String,usize>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 16
+  i32.const 12
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
@@ -4783,39 +5121,30 @@
   i64.const 0
   i64.store
   global.get $~lib/memory/__stack_pointer
-  i64.const 0
-  i64.store offset=8
+  i32.const 0
+  i32.store offset=8
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store offset=4
-  local.get $4
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.1 (result i32)
-   global.get $~lib/memory/__stack_pointer
-   local.get $1
-   local.tee $2
-   i32.store offset=8
-   i32.const 1
-   drop
-   local.get $2
-   local.set $4
-   global.get $~lib/memory/__stack_pointer
-   local.get $4
-   i32.store offset=12
-   local.get $4
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.1
-  end
-  call $~lib/map/Map<~lib/string/String,usize>#find
+  local.get $3
+  local.get $1
   local.set $3
+  global.get $~lib/memory/__stack_pointer
+  local.get $3
+  i32.store offset=8
   local.get $3
+  call $~lib/util/hash/HASH<~lib/string/String>
+  call $~lib/map/Map<~lib/string/String,usize>#find
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 624
@@ -4825,14 +5154,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  i32.const 16
+  i32.const 12
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/map/Map<~lib/string/String,usize>#rehash (param $0 i32) (param $1 i32)
   (local $2 i32)
@@ -4850,7 +5179,7 @@
   (local $14 i32)
   (local $15 i32)
   global.get $~lib/memory/__stack_pointer
-  i32.const 20
+  i32.const 16
   i32.sub
   global.set $~lib/memory/__stack_pointer
   call $~stack_check
@@ -4860,9 +5189,6 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store offset=8
-  global.get $~lib/memory/__stack_pointer
-  i32.const 0
-  i32.store offset=16
   local.get $1
   i32.const 1
   i32.add
@@ -4890,11 +5216,11 @@
   local.tee $5
   i32.store offset=4
   local.get $0
-  i32.load offset=8
+  i32.load offset=16
   local.set $6
   local.get $6
   local.get $0
-  i32.load offset=16
+  i32.load offset=24
   i32.const 12
   i32.mul
   i32.add
@@ -4930,24 +5256,17 @@
      local.get $10
      i32.load offset=4
      call $~lib/map/MapEntry<~lib/string/String,usize>#set:value
-     block $~lib/util/hash/HASH<~lib/string/String>|inlined.3 (result i32)
-      global.get $~lib/memory/__stack_pointer
-      local.get $12
-      local.tee $13
-      i32.store offset=12
-      i32.const 1
-      drop
-      local.get $13
-      local.set $15
-      global.get $~lib/memory/__stack_pointer
-      local.get $15
-      i32.store offset=16
-      local.get $15
-      call $~lib/util/hash/hashStr
-      br $~lib/util/hash/HASH<~lib/string/String>|inlined.3
-     end
+     local.get $12
+     local.set $15
+     global.get $~lib/memory/__stack_pointer
+     local.get $15
+     i32.store offset=12
+     local.get $15
+     call $~lib/util/hash/HASH<~lib/string/String>
      local.get $1
-     i32.and
+     i64.extend_i32_u
+     i64.and
+     i32.wrap_i64
      local.set $13
      local.get $3
      local.get $13
@@ -4979,6 +5298,7 @@
   call $~lib/map/Map<~lib/string/String,usize>#set:buckets
   local.get $0
   local.get $1
+  i64.extend_i32_u
   call $~lib/map/Map<~lib/string/String,usize>#set:bucketsMask
   local.get $0
   local.get $5
@@ -4988,15 +5308,15 @@
   call $~lib/map/Map<~lib/string/String,usize>#set:entriesCapacity
   local.get $0
   local.get $0
-  i32.load offset=20
+  i32.load offset=28
   call $~lib/map/Map<~lib/string/String,usize>#set:entriesOffset
   global.get $~lib/memory/__stack_pointer
-  i32.const 20
+  i32.const 16
   i32.add
   global.set $~lib/memory/__stack_pointer
  )
  (func $~lib/map/Map<~lib/string/String,usize>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -5012,89 +5332,81 @@
   global.get $~lib/memory/__stack_pointer
   i32.const 0
   i32.store offset=8
-  block $~lib/util/hash/HASH<~lib/string/String>|inlined.2 (result i32)
-   global.get $~lib/memory/__stack_pointer
-   local.get $1
-   local.tee $3
-   i32.store
-   i32.const 1
-   drop
-   local.get $3
-   local.set $7
-   global.get $~lib/memory/__stack_pointer
-   local.get $7
-   i32.store offset=4
-   local.get $7
-   call $~lib/util/hash/hashStr
-   br $~lib/util/hash/HASH<~lib/string/String>|inlined.2
-  end
-  local.set $4
+  local.get $1
+  local.set $7
+  global.get $~lib/memory/__stack_pointer
+  local.get $7
+  i32.store
+  local.get $7
+  call $~lib/util/hash/HASH<~lib/string/String>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
   local.get $7
-  i32.store offset=4
+  i32.store
   local.get $7
   local.get $1
   local.set $7
   global.get $~lib/memory/__stack_pointer
   local.get $7
-  i32.store offset=8
+  i32.store offset=4
   local.get $7
-  local.get $4
+  local.get $3
   call $~lib/map/Map<~lib/string/String,usize>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<~lib/string/String,usize>#set:value
    i32.const 0
    drop
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
     local.set $7
     global.get $~lib/memory/__stack_pointer
     local.get $7
-    i32.store offset=4
+    i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<~lib/string/String,usize>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
-   i32.store
-   local.get $3
+   i32.load offset=16
+   local.tee $5
+   i32.store offset=8
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -5103,8 +5415,8 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<~lib/string/String,usize>#set:key
    i32.const 1
@@ -5113,33 +5425,34 @@
    local.get $1
    i32.const 1
    call $~lib/rt/itcms/__link
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<~lib/string/String,usize>#set:value
    i32.const 0
    drop
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<~lib/string/String,usize>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<~lib/string/String,usize>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -5151,7 +5464,7 @@
   local.get $7
  )
  (func $~lib/map/Map<usize,~lib/string/String>#set (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-  (local $3 i32)
+  (local $3 i64)
   (local $4 i32)
   (local $5 i32)
   (local $6 i32)
@@ -5164,32 +5477,9 @@
   global.get $~lib/memory/__stack_pointer
   i64.const 0
   i64.store
-  block $~lib/util/hash/HASH<usize>|inlined.0 (result i32)
-   local.get $1
-   local.set $3
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $3
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<usize>|inlined.0
-  end
-  local.set $4
+  local.get $1
+  call $~lib/util/hash/HASH<usize>
+  local.set $3
   local.get $0
   local.set $7
   global.get $~lib/memory/__stack_pointer
@@ -5197,12 +5487,12 @@
   i32.store
   local.get $7
   local.get $1
-  local.get $4
+  local.get $3
   call $~lib/map/Map<usize,~lib/string/String>#find
-  local.set $5
-  local.get $5
+  local.set $4
+  local.get $4
   if
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<usize,~lib/string/String>#set:value
    i32.const 1
@@ -5213,9 +5503,9 @@
    call $~lib/rt/itcms/__link
   else
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.get $0
-   i32.load offset=12
+   i32.load offset=20
    i32.eq
    if
     local.get $0
@@ -5225,36 +5515,37 @@
     i32.store
     local.get $7
     local.get $0
-    i32.load offset=20
+    i32.load offset=28
     local.get $0
-    i32.load offset=12
+    i32.load offset=20
     i32.const 3
     i32.mul
     i32.const 4
     i32.div_s
     i32.lt_s
-    if (result i32)
+    if (result i64)
      local.get $0
-     i32.load offset=4
+     i64.load offset=8
     else
      local.get $0
-     i32.load offset=4
-     i32.const 1
-     i32.shl
-     i32.const 1
-     i32.or
+     i64.load offset=8
+     i64.const 1
+     i64.shl
+     i64.const 1
+     i64.or
     end
+    i32.wrap_i64
     call $~lib/map/Map<usize,~lib/string/String>#rehash
    end
    global.get $~lib/memory/__stack_pointer
    local.get $0
-   i32.load offset=8
-   local.tee $3
+   i32.load offset=16
+   local.tee $5
    i32.store offset=4
-   local.get $3
+   local.get $5
    local.get $0
    local.get $0
-   i32.load offset=16
+   i32.load offset=24
    local.tee $6
    i32.const 1
    i32.add
@@ -5263,13 +5554,13 @@
    i32.const 12
    i32.mul
    i32.add
-   local.set $5
-   local.get $5
+   local.set $4
+   local.get $4
    local.get $1
    call $~lib/map/MapEntry<usize,~lib/string/String>#set:key
    i32.const 0
    drop
-   local.get $5
+   local.get $4
    local.get $2
    call $~lib/map/MapEntry<usize,~lib/string/String>#set:value
    i32.const 1
@@ -5280,26 +5571,27 @@
    call $~lib/rt/itcms/__link
    local.get $0
    local.get $0
-   i32.load offset=20
+   i32.load offset=28
    i32.const 1
    i32.add
    call $~lib/map/Map<usize,~lib/string/String>#set:entriesCount
    local.get $0
    i32.load
-   local.get $4
+   local.get $3
    local.get $0
-   i32.load offset=4
-   i32.and
+   i64.load offset=8
+   i64.and
+   i32.wrap_i64
    i32.const 4
    i32.mul
    i32.add
    local.set $6
-   local.get $5
+   local.get $4
    local.get $6
    i32.load
    call $~lib/map/MapEntry<usize,~lib/string/String>#set:taggedNext
    local.get $6
-   local.get $5
+   local.get $4
    i32.store
   end
   local.get $0
@@ -5423,7 +5715,6 @@
  )
  (func $~lib/map/Map<usize,~lib/string/String>#has (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
-  (local $3 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -5433,51 +5724,27 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
   i32.store
-  local.get $3
+  local.get $2
   local.get $1
-  block $~lib/util/hash/HASH<usize>|inlined.2 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<usize>|inlined.2
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<usize>
   call $~lib/map/Map<usize,~lib/string/String>#find
   i32.const 0
   i32.ne
-  local.set $3
+  local.set $2
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $3
+  local.get $2
  )
  (func $~lib/map/Map<usize,~lib/string/String>#get (param $0 i32) (param $1 i32) (result i32)
   (local $2 i32)
   (local $3 i32)
-  (local $4 i32)
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.sub
@@ -5487,40 +5754,17 @@
   i32.const 0
   i32.store
   local.get $0
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
   i32.store
-  local.get $4
+  local.get $3
   local.get $1
-  block $~lib/util/hash/HASH<usize>|inlined.3 (result i32)
-   local.get $1
-   local.set $2
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 0
-   drop
-   i32.const 4
-   i32.const 1
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 2
-   i32.eq
-   drop
-   i32.const 4
-   i32.const 4
-   i32.eq
-   drop
-   local.get $2
-   call $~lib/util/hash/hash32
-   br $~lib/util/hash/HASH<usize>|inlined.3
-  end
+  local.get $1
+  call $~lib/util/hash/HASH<usize>
   call $~lib/map/Map<usize,~lib/string/String>#find
-  local.set $3
-  local.get $3
+  local.set $2
+  local.get $2
   i32.eqz
   if
    i32.const 624
@@ -5530,14 +5774,14 @@
    call $~lib/builtins/abort
    unreachable
   end
-  local.get $3
+  local.get $2
   i32.load offset=4
-  local.set $4
+  local.set $3
   global.get $~lib/memory/__stack_pointer
   i32.const 4
   i32.add
   global.set $~lib/memory/__stack_pointer
-  local.get $4
+  local.get $3
  )
  (func $~lib/symbol/_Symbol.keyFor (param $0 i32) (result i32)
   (local $1 i32)
@@ -6266,7 +6510,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 3
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -6280,9 +6524,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<~lib/string/String,usize>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<~lib/string/String,usize>#set:bucketsMask
   local.get $0
   i32.const 0
@@ -6322,7 +6566,7 @@
   i32.eqz
   if
    global.get $~lib/memory/__stack_pointer
-   i32.const 24
+   i32.const 32
    i32.const 4
    call $~lib/rt/itcms/__new
    local.tee $0
@@ -6336,9 +6580,9 @@
   call $~lib/arraybuffer/ArrayBuffer#constructor
   call $~lib/map/Map<usize,~lib/string/String>#set:buckets
   local.get $0
-  i32.const 4
-  i32.const 1
-  i32.sub
+  i64.const 4
+  i64.const 1
+  i64.sub
   call $~lib/map/Map<usize,~lib/string/String>#set:bucketsMask
   local.get $0
   i32.const 0