diff --git a/changelog.md b/changelog.md
index 1fc6d19c2..d75e8d17b 100644
--- a/changelog.md
+++ b/changelog.md
@@ -7,6 +7,9 @@
 - `uri` adds Data URI Base64, implements RFC-2397.
 - Add [DOM Parser](https://developer.mozilla.org/en-US/docs/Web/API/DOMParser)
   to the `dom` module for the JavaScript target.
+- The default hash for `Ordinal` has changed to something more bit-scrambling.
+  `import hashes; proc hash(x: myInt): Hash = hashIdentity(x)` recovers the old
+  one in an instantiation context while `-d:nimIntHash1` recovers it globally.
 
 ## Language changes
 
diff --git a/lib/pure/collections/sets.nim b/lib/pure/collections/sets.nim
index 8c04a05e3..11639df3b 100644
--- a/lib/pure/collections/sets.nim
+++ b/lib/pure/collections/sets.nim
@@ -334,8 +334,7 @@ proc pop*[A](s: var HashSet[A]): A =
   ## * `clear proc <#clear,HashSet[A]>`_
   runnableExamples:
     var s = toHashSet([2, 1])
-    assert s.pop == 1
-    assert s.pop == 2
+    assert [s.pop, s.pop] in [[1, 2], [2,1]] # order unspecified
     doAssertRaises(KeyError, echo s.pop)
 
   for h in 0 .. high(s.data):
@@ -1008,7 +1007,7 @@ when isMainModule and not defined(release):
 
     block toSeqAndString:
       var a = toHashSet([2, 7, 5])
-      var b = initHashSet[int]()
+      var b = initHashSet[int](rightSize(a.len))
       for x in [2, 7, 5]: b.incl(x)
       assert($a == $b)
       #echo a
diff --git a/lib/pure/hashes.nim b/lib/pure/hashes.nim
index d799fb062..d6a7c7e41 100644
--- a/lib/pure/hashes.nim
+++ b/lib/pure/hashes.nim
@@ -70,6 +70,66 @@ proc `!$`*(h: Hash): Hash {.inline.} =
   res = res + res shl 15
   result = cast[Hash](res)
 
+proc hiXorLoFallback64(a, b: uint64): uint64 {.inline.} =
+  let # Fall back in 64-bit arithmetic
+    aH = a shr 32
+    aL = a and 0xFFFFFFFF'u64
+    bH = b shr 32
+    bL = b and 0xFFFFFFFF'u64
+    rHH = aH * bH
+    rHL = aH * bL
+    rLH = aL * bH
+    rLL = aL * bL
+    t = rLL + (rHL shl 32)
+  var c = if t < rLL: 1'u64 else: 0'u64
+  let lo = t + (rLH shl 32)
+  c += (if lo < t: 1'u64 else: 0'u64)
+  let hi = rHH + (rHL shr 32) + (rLH shr 32) + c
+  return hi xor lo
+
+proc hiXorLo(a, b: uint64): uint64 {.inline.} =
+  # Xor of high & low 8B of full 16B product
+  when nimvm:
+    result = hiXorLoFallback64(a, b) # `result =` is necessary here.
+  else:
+    when Hash.sizeof < 8:
+      result = hiXorLoFallback64(a, b)
+    elif defined(gcc) or defined(llvm_gcc) or defined(clang):
+      {.emit: """__uint128_t r = a; r *= b; `result` = (r >> 64) ^ r;""".}
+    elif defined(windows) and not defined(tcc):
+      {.emit: """a = _umul128(a, b, &b); `result` = a ^ b;""".}
+    else:
+      result = hiXorLoFallback64(a, b)
+
+proc hashWangYi1*(x: int64|uint64|Hash): Hash {.inline.} =
+  ## Wang Yi's hash_v1 for 8B int.  https://github.com/rurban/smhasher has more
+  ## details.  This passed all scrambling tests in Spring 2019 and is simple.
+  ## NOTE: It's ok to define ``proc(x: int16): Hash = hashWangYi1(Hash(x))``.
+  const P0  = 0xa0761d6478bd642f'u64
+  const P1  = 0xe7037ed1a0b428db'u64
+  const P58 = 0xeb44accab455d165'u64 xor 8'u64
+  when nimvm:
+    cast[Hash](hiXorLo(hiXorLo(P0, uint64(x) xor P1), P58))
+  else:
+    when defined(js):
+      asm """
+        if (typeof BigInt == 'undefined') {
+          `result` = `x`; // For Node < 10.4, etc. we do the old identity hash
+        } else {          // Otherwise we match the low 32-bits of C/C++ hash
+          function hi_xor_lo_js(a, b) {
+            const prod = BigInt(a) * BigInt(b);
+            const mask = (BigInt(1) << BigInt(64)) - BigInt(1);
+            return (prod >> BigInt(64)) ^ (prod & mask);
+          }
+          const P0  = BigInt(0xa0761d64)<<BigInt(32)|BigInt(0x78bd642f);
+          const P1  = BigInt(0xe7037ed1)<<BigInt(32)|BigInt(0xa0b428db);
+          const P58 = BigInt(0xeb44acca)<<BigInt(32)|BigInt(0xb455d165)^BigInt(8);
+          var res   = hi_xor_lo_js(hi_xor_lo_js(P0, BigInt(`x`) ^ P1), P58);
+          `result`  = Number(res & ((BigInt(1) << BigInt(53)) - BigInt(1)));
+        }"""
+    else:
+      cast[Hash](hiXorLo(hiXorLo(P0, uint64(x) xor P1), P58))
+
 proc hashData*(data: pointer, size: int): Hash =
   ## Hashes an array of bytes of size `size`.
   var h: Hash = 0
@@ -112,10 +172,19 @@ proc hash*[T: proc](x: T): Hash {.inline.} =
   else:
     result = hash(pointer(x))
 
-proc hash*[T: Ordinal](x: T): Hash {.inline.} =
-  ## Efficient hashing of integers.
+proc hashIdentity*[T: Ordinal](x: T): Hash {.inline.} =
+  ## The identity hash.  I.e. ``hashIdentity(x) = x``.
   cast[Hash](ord(x))
 
+when defined(nimIntHash1):
+  proc hash*[T: Ordinal](x: T): Hash {.inline.} =
+    ## Efficient hashing of integers.
+    hashIdentity(x)
+else:
+  proc hash*[T: Ordinal](x: T): Hash {.inline.} =
+    ## Efficient hashing of integers.
+    hashWangYi1(uint64(ord(x)))
+
 proc hash*(x: float): Hash {.inline.} =
   ## Efficient hashing of floats.
   var y = x + 0.0 # for denormalization
diff --git a/lib/pure/sugar.nim b/lib/pure/sugar.nim
index e9e7eb455..4b3db6782 100644
--- a/lib/pure/sugar.nim
+++ b/lib/pure/sugar.nim
@@ -291,7 +291,7 @@ macro collect*(init, body: untyped): untyped {.since: (1, 1).} =
     let z = collect(initTable(2)):
       for i, d in data.pairs: {i: d}
 
-    assert z == {1: "word", 0: "bird"}.toTable
+    assert z == {0: "bird", 1: "word"}.toTable
   # analyse the body, find the deepest expression 'it' and replace it via
   # 'result.add it'
   let res = genSym(nskVar, "collectResult")
@@ -334,8 +334,8 @@ when isMainModule:
 
     let data = @["bird", "word"] # if this gets stuck in your head, its not my fault
     assert collect(newSeq, for (i, d) in data.pairs: (if i mod 2 == 0: d)) == @["bird"]
-    assert collect(initTable(2), for (i, d) in data.pairs: {i: d}) == {1: "word",
-          0: "bird"}.toTable
+    assert collect(initTable(2), for (i, d) in data.pairs: {i: d}) == {0: "bird",
+          1: "word"}.toTable
     assert initHashSet.collect(for d in data.items: {d}) == data.toHashSet
 
     let x = collect(newSeqOfCap(4)):
diff --git a/tests/collections/tcollections.nim b/tests/collections/tcollections.nim
index 5c95cee28..1e2858fb4 100644
--- a/tests/collections/tcollections.nim
+++ b/tests/collections/tcollections.nim
@@ -76,8 +76,12 @@ doAssert $(toOrderedSet(["1", "2", "3"])) == """{"1", "2", "3"}"""
 doAssert $(toOrderedSet(['1', '2', '3'])) == """{'1', '2', '3'}"""
 
 # Tests for tables
-doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
-doAssert $({"1": 1, "2": 2}.toTable) == """{"1": 1, "2": 2}"""
+when defined(nimIntHash1):
+  doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
+else:
+  doAssert $({1: "1", 2: "2"}.toTable) == """{2: "2", 1: "1"}"""
+let tabStr = $({"1": 1, "2": 2}.toTable)
+doAssert (tabStr == """{"2": 2, "1": 1}""" or tabStr == """{"1": 1, "2": 2}""")
 
 # Tests for deques
 block:
diff --git a/tests/collections/tcollections_to_string.nim b/tests/collections/tcollections_to_string.nim
index 8915e9fea..62ba87334 100644
--- a/tests/collections/tcollections_to_string.nim
+++ b/tests/collections/tcollections_to_string.nim
@@ -27,7 +27,10 @@ doAssert $(toOrderedSet(["1", "2", "3"])) == """{"1", "2", "3"}"""
 doAssert $(toOrderedSet(['1', '2', '3'])) == """{'1', '2', '3'}"""
 
 # Tests for tables
-doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
+when defined(nimIntHash1):
+  doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
+else:
+  doAssert $({1: "1", 2: "2"}.toTable) == """{2: "2", 1: "1"}"""
 doAssert $({"1": 1, "2": 2}.toTable) == """{"1": 1, "2": 2}"""
 
 # Tests for deques
diff --git a/tests/stdlib/thashes.nim b/tests/stdlib/thashes.nim
index 2cd1e4e47..259ced2aa 100644
--- a/tests/stdlib/thashes.nim
+++ b/tests/stdlib/thashes.nim
@@ -15,3 +15,20 @@ suite "hashes":
     test "0.0 and -0.0 should have the same hash value":
       var dummy = 0.0
       check hash(dummy) == hash(-dummy)
+
+    test "VM and runtime should make the same hash value (hashIdentity)":
+      const hi123 = hashIdentity(123)
+      check hashIdentity(123) == hi123
+
+    test "VM and runtime should make the same hash value (hashWangYi1)":
+      const wy123 = hashWangYi1(123)
+      check hashWangYi1(123) == wy123
+
+    test "hashIdentity value incorrect at 456":
+      check hashIdentity(456) == 456
+
+    test "hashWangYi1 value incorrect at 456":
+      when Hash.sizeof < 8:
+        check hashWangYi1(456) == 1293320666
+      else:
+        check hashWangYi1(456) == -6421749900419628582
diff --git a/tests/vm/tslow_tables.nim b/tests/vm/tslow_tables.nim
index f726c6323..a933021e0 100644
--- a/tests/vm/tslow_tables.nim
+++ b/tests/vm/tslow_tables.nim
@@ -1,5 +1,5 @@
 discard """
-  timeout: "4"
+  timeout: "5"
   action: "compile"
   nimout: '''create
 search