diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0c52ea01..ce490a59 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -220,10 +220,13 @@ ENDIF()
 
 if(NOT MSVC)
   set_source_files_properties(HashMapTest.cpp PROPERTIES COMPILE_FLAGS "-std=c++11")
-  set_source_files_properties(SpeedTest.cpp PROPERTIES COMPILE_FLAGS "-std=c++0x")
+  set_source_files_properties(SpeedTest.cpp PROPERTIES COMPILE_FLAGS "-std=c++0x -I${CMAKE_SOURCE_DIR}/parallel-hashmap")
   set_source_files_properties(main.cpp PROPERTIES COMPILE_FLAGS "-std=c++0x")
   # https://github.com/dgryski/trifles/tree/master/tsip
   set(TSIP_SRC tsip.c)
+else()
+  set_source_files_properties(SpeedTest.cpp PROPERTIES COMPILE_FLAGS
+                              "-I${CMAKE_SOURCE_DIR}/parallel-hashmap")
 endif()
 
 find_library(HIGHWAY highwayhash)
diff --git a/SpeedTest.cpp b/SpeedTest.cpp
index bcbaba67..76574482 100644
--- a/SpeedTest.cpp
+++ b/SpeedTest.cpp
@@ -8,10 +8,13 @@
 #include <string>
 
 #include <unordered_map>
+#include <parallel_hashmap/phmap.h>
 #include <functional>
 
 typedef std::unordered_map<std::string, int,
-  std::function<size_t (const std::string &key)>> string_hashmap;
+  std::function<size_t (const std::string &key)>> std_hashmap;
+typedef phmap::flat_hash_map<std::string, int,
+  std::function<size_t (const std::string &key)>> fast_hashmap;
 
 //-----------------------------------------------------------------------------
 // We view our timing values as a series of random variables V that has been
@@ -280,6 +283,7 @@ void BulkSpeedTest ( pfHash hash, uint32_t seed )
   }
   sumbpc = sumbpc / 8.0;
   printf("Average      - %6.3f bytes/cycle - %7.2f MiB/sec @ 3 ghz\n",sumbpc,(sumbpc * 3000000000.0 / 1048576.0));
+  fflush(NULL);
 }
 
 //-----------------------------------------------------------------------------
@@ -300,9 +304,18 @@ double HashMapSpeedTest ( pfHash pfhash, const int hashbits,
                           std::vector<std::string> words,
                           const int trials, bool verbose )
 {
+  //using phmap::flat_node_hash_map;
   Rand r(82762);
   const uint32_t seed = r.rand_u32();
-  string_hashmap hashmap(words.size(), [=](const std::string &key)
+  std_hashmap hashmap(words.size(), [=](const std::string &key)
+                  {
+                    char out[256]; // hasshe2
+                    size_t result;
+                    pfhash(key.c_str(), key.length(), seed, &out);
+                    memcpy(&result, &out, hashbits/8);
+                    return result;
+                  });
+  fast_hashmap phashmap(words.size(), [=](const std::string &key)
                   {
                     static char out[256]; // 256 for hasshe2, but stripped to 64/32
                     size_t result = 0;
@@ -315,7 +328,9 @@ double HashMapSpeedTest ( pfHash pfhash, const int hashbits,
   std::vector<double> times;
   double t1;
 
-  printf("std::unordered_map:\n");
+  printf("std::unordered_map\n");
+  printf("Init std HashMapTest:     ");
+  fflush(NULL);
   times.reserve(trials);
   { // hash inserts and 1% deletes
     volatile int64_t begin, end;
@@ -330,13 +345,15 @@ double HashMapSpeedTest ( pfHash pfhash, const int hashbits,
     end = timer_end();
     t1 = (double)(end - begin) / (double)words.size();
   }
-  printf("Init HashMapTest:    %0.3f cycles/op (%lu inserts, 1%% deletions)\n",
+  fflush(NULL);
+  printf("%0.3f cycles/op (%lu inserts, 1%% deletions)\n",
          t1, words.size());
-  printf("Running HashMapTest: ");
+  printf("Running std HashMapTest:  ");
   if (t1 > 10000.) { // e.g. multiply_shift 459271.700
     printf("SKIP");
     return 0.;
   }
+  fflush(NULL);
 
   for(int itrial = 0; itrial < trials; itrial++)
     { // hash query
@@ -361,7 +378,62 @@ double HashMapSpeedTest ( pfHash pfhash, const int hashbits,
   double mean = CalcMean(times);
   double stdv = CalcStdv(times);
   printf("%0.3f cycles/op", mean);
-  printf(" (%0.1f stdv) ", stdv);
+  printf(" (%0.1f stdv)\n", stdv);
+
+  times.clear();
+
+  printf("\ngreg7mdp/parallel-hashmap\n");
+  printf("Init fast HashMapTest:    ");
+  fflush(NULL);
+  times.reserve(trials);
+  { // hash inserts and 1% deletes
+    volatile int64_t begin, end;
+    int i = 0;
+    begin = timer_start();
+    for (it = words.begin(); it != words.end(); it++, i++) {
+      std::string line = *it;
+      phashmap[line] = 1;
+      if (i % 100 == 0)
+        phashmap.erase(line);
+    }
+    end = timer_end();
+    t1 = (double)(end - begin) / (double)words.size();
+  }
+  fflush(NULL);
+  printf("%0.3f cycles/op (%lu inserts, 1%% deletions)\n",
+         t1, words.size());
+  printf("Running fast HashMapTest: ");
+  if (t1 > 10000.) { // e.g. multiply_shift 459271.700
+    printf("SKIP");
+    return 0.;
+  }
+  fflush(NULL);  
+  for(int itrial = 0; itrial < trials; itrial++)
+    { // hash query
+      volatile int64_t begin, end;
+      int i = 0, found = 0;
+      double t;
+      begin = timer_start();
+      for ( it = words.begin(); it != words.end(); it++, i++ )
+        {
+          std::string line = *it;
+          if (phashmap[line])
+            found++;
+        }
+      end = timer_end();
+      t = (double)(end - begin) / (double)words.size();
+      if(found > 0 && t > 0) times.push_back(t);
+    }
+  phashmap.clear();
+  fflush(NULL);
+
+  std::sort(times.begin(),times.end());
+  FilterOutliers(times);
+  double mean1 = CalcMean(times);
+  double stdv1 = CalcStdv(times);
+  printf("%0.3f cycles/op", mean1);
+  printf(" (%0.1f stdv) ", stdv1);
+  fflush(NULL);
 
   return mean;
 }
diff --git a/log.hashmap b/log.hashmap
new file mode 100644
index 00000000..2f0403ab
--- /dev/null
+++ b/log.hashmap
@@ -0,0 +1,1354 @@
+-------------------------------------------------------------------------------
+--- Testing crc32_hw1 "Faster Adler SSE4.2 crc32 in HW" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     801.814 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  618.793 cycles/op (29.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing crc64_hw "SSE4.2 crc64 in HW" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     798.979 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  540.778 cycles/op (30.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    634.719 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 379.089 cycles/op (15.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.953154 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing fibonacci "wordwise Fibonacci" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     2000.219 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  2073.358 cycles/op (298.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    1596.747 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 834.730 cycles/op (79.1 stdv)  ....... FAIL
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 16.192124 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing FNV1a "Fowler-Noll-Vo hash, 32-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     768.832 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  652.255 cycles/op (58.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing FNV1A_Totenschiff "FNV1A_Totenschiff_v1 64-bit sanmayce" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     846.284 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  646.152 cycles/op (57.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing FNV1A_Pippip_Yurii "FNV1A-Pippip_Yurii 32-bit sanmayce" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     838.011 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  623.262 cycles/op (43.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing FNV1a_YT "FNV1a-YoshimitsuTRIAD 32-bit sanmayce" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     800.138 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  617.181 cycles/op (58.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing FNV64 "Fowler-Noll-Vo hash, 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     811.965 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  535.873 cycles/op (37.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    706.669 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 397.272 cycles/op (26.7 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.029285 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing FNV2 "wordwise FNV" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     814.929 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  527.059 cycles/op (33.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    748.234 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 388.698 cycles/op (28.8 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.948728 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing fletcher2 "fletcher2 ZFS" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     1096.045 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  812.068 cycles/op (63.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    966.261 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 479.837 cycles/op (50.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 6.942009 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing fletcher4 "fletcher4 ZFS" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     918.984 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  540.549 cycles/op (37.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    670.969 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 391.747 cycles/op (16.8 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.035429 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing bernstein "Bernstein, 32-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     894.248 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  633.270 cycles/op (38.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing sdbm "sdbm as in perl5" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     766.115 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  618.523 cycles/op (30.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing x17 "x17" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     772.704 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  602.574 cycles/op (72.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing JenkinsOOAT "Bob Jenkins' OOAT as in perl 5.18" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     833.725 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  661.698 cycles/op (61.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing JenkinsOOAT_perl "Bob Jenkins' OOAT as in old perl5" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     833.534 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  639.907 cycles/op (24.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing MicroOAAT "Small non-multiplicative OAAT that passes all collision checks (by funny-falcon)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     824.217 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  628.276 cycles/op (28.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing jodyhash32 "jodyhash, 32-bit (v5)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     812.823 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  624.303 cycles/op (57.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing jodyhash64 "jodyhash, 64-bit (v5)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     808.301 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  535.903 cycles/op (35.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    688.502 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 391.541 cycles/op (22.7 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.992414 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing lookup3 "Bob Jenkins' lookup3" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     783.150 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  605.205 cycles/op (38.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing superfast "Paul Hsieh's SuperFastHash" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     849.722 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  625.468 cycles/op (34.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing MurmurOAAT "Murmur one-at-a-time" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     867.843 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  625.288 cycles/op (33.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Crap8 "Crap8" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     758.317 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  621.934 cycles/op (43.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing xxHash32 "xxHash, 32-bit for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     783.003 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  607.036 cycles/op (15.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Murmur2 "MurmurHash2 for x86, 32-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     789.146 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  643.156 cycles/op (60.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Murmur2A "MurmurHash2A for x86, 32-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     831.922 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  622.520 cycles/op (28.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Murmur2B "MurmurHash64A for x64, 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     773.774 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  532.104 cycles/op (30.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    709.698 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 389.918 cycles/op (24.7 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.982553 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing Murmur2C "MurmurHash64B for x86, 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     790.107 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  521.057 cycles/op (36.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    710.425 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 394.075 cycles/op (17.6 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.981443 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing Murmur3C "MurmurHash3 for x86, 128-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     790.172 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  552.075 cycles/op (33.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    776.269 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 406.065 cycles/op (15.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.180374 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash64_1 "MetroHash64_1 for 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     797.944 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  521.644 cycles/op (34.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    735.723 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 404.394 cycles/op (20.5 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.992970 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash64_2 "MetroHash64_2 for 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     818.863 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  541.389 cycles/op (44.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    715.185 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 395.573 cycles/op (21.8 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.039681 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash128_1 "MetroHash128_1 for 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     873.823 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  575.483 cycles/op (13.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    749.933 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 399.910 cycles/op (28.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.280801 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash128_2 "MetroHash128_2 for 64-bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     813.986 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  531.828 cycles/op (31.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    724.427 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 387.460 cycles/op (20.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.963057 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash64crc_1 "MetroHash64crc_1 for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     875.211 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  536.671 cycles/op (39.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    714.507 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 397.166 cycles/op (27.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.061285 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash64crc_2 "MetroHash64crc_2 for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     783.062 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  531.087 cycles/op (30.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    724.751 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 391.378 cycles/op (19.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.985698 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing cmetrohash64_1o "cmetrohash64_1 (shorter key optimized) , 64-bit for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     742.162 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  530.619 cycles/op (24.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    707.585 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 399.195 cycles/op (36.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.995862 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing cmetrohash64_1 "cmetrohash64_1, 64-bit for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     855.201 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  521.685 cycles/op (26.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    681.939 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 389.612 cycles/op (20.1 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.951556 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing cmetrohash64_2 "cmetrohash64_2, 64-bit for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     762.453 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  528.339 cycles/op (30.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    772.859 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 399.130 cycles/op (20.4 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.994560 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing City64noSeed "Google CityHash64 without seed (default version, misses one final avalanche)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     796.180 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  546.061 cycles/op (35.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    710.396 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 396.008 cycles/op (19.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.088310 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing City64 "Google CityHash64WithSeed (old)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     793.499 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  551.935 cycles/op (44.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    714.818 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 416.405 cycles/op (25.4 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.207836 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing falkhash "falkhash.asm with aesenc, 64-bit for x64" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     886.444 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  625.423 cycles/op (34.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    995.075 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 473.875 cycles/op (28.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.919482 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha2_atonce128 "Fast Positive Hash (portable, aims 64-bit, little-endian)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     761.911 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  559.579 cycles/op (43.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    752.178 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 417.107 cycles/op (25.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.248204 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha2_stream128 "Fast Positive Hash (portable, aims 64-bit, little-endian)" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     860.537 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  610.651 cycles/op (35.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    1014.640 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 468.180 cycles/op (24.5 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.807357 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing HalfSipHash "HalfSipHash 2-4, 32bit" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     833.572 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  675.204 cycles/op (61.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing SipHash13 "SipHash 1-3 - SSSE3 optimized" POOR
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     861.626 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  588.097 cycles/op (36.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    898.190 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 434.033 cycles/op (16.2 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.538097 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing SipHash "SipHash 2-4 - SSSE3 optimized" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     936.683 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  616.794 cycles/op (37.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    1067.205 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 480.554 cycles/op (29.4 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.905838 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing HighwayHash64 "Google HighwayHash (portable with overhead from the lib)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     830.160 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  608.409 cycles/op (26.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    1011.447 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 488.039 cycles/op (26.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.884600 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing TSip "Damian Gryski's Tiny SipHash variant" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     868.177 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  546.802 cycles/op (38.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    758.621 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 400.270 cycles/op (19.1 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.140113 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing seahash "seahash (portable, 64-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     793.740 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  542.390 cycles/op (26.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    795.193 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 405.789 cycles/op (22.2 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.128128 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing seahash32low "seahash - lower 32bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     846.317 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  646.727 cycles/op (62.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing GoodOAAT "Small non-multiplicative OAAT" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     770.549 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  620.295 cycles/op (24.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing PMurHash32 "Shane Day's portable-ized MurmurHash3 for x86, 32-bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     812.719 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  668.964 cycles/op (24.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Murmur3A "MurmurHash3 for x86, 32-bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     919.927 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  606.573 cycles/op (12.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Murmur3F "MurmurHash3 for x64, 128-bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     857.005 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  539.025 cycles/op (36.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    683.809 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 398.879 cycles/op (22.4 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.050413 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing fasthash32 "fast-hash 32bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     867.452 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  636.438 cycles/op (73.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing fasthash64 "fast-hash 64bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     743.521 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  540.397 cycles/op (44.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    760.278 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 393.301 cycles/op (20.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.010825 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing MUM "github.com/vnmakarov/mum-hash" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     773.963 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  543.622 cycles/op (30.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    789.477 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 394.554 cycles/op (20.2 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.051852 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing MUMlow "github.com/vnmakarov/mum-hash" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     801.064 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  621.318 cycles/op (23.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing mirhash "mirhash" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     774.072 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  546.926 cycles/op (36.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    754.575 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 397.198 cycles/op (29.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.091223 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing mirhash32low "mirhash - lower 32bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     859.820 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  633.395 cycles/op (26.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing mirhashstrict "mirhashstrict (portable, 64-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     777.364 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  549.634 cycles/op (39.3 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    800.934 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 403.159 cycles/op (20.3 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.132361 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing mirhashstrict32low "mirhashstrict - lower 32bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     856.888 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  629.969 cycles/op (46.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing City32 "Google CityHash32WithSeed (old)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     794.106 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  642.418 cycles/op (24.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing City64low "Google CityHash64WithSeed (low 32-bits)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     786.936 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  644.166 cycles/op (25.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing City128 "Google CityHash128WithSeed (old)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     761.664 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  545.560 cycles/op (30.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    802.211 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 411.280 cycles/op (20.6 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.157004 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing CityCrc128 "Google CityHashCrc128WithSeed SSE4.2 (old)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     802.030 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  541.559 cycles/op (42.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    772.088 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 419.604 cycles/op (21.4 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.180301 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing FarmHash32 "Google FarmHash32WithSeed" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     807.325 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  636.865 cycles/op (28.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing FarmHash64 "Google FarmHash64WithSeed" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     768.925 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  548.821 cycles/op (38.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    783.537 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 421.533 cycles/op (25.1 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.218797 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing FarmHash128 "Google FarmHash128WithSeed" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     816.024 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  559.533 cycles/op (41.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    779.148 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 424.679 cycles/op (18.2 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.293235 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing farmhash32_c "farmhash32_with_seed (C99)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     862.958 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  659.066 cycles/op (61.6 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing farmhash64_c "farmhash64_with_seed (C99)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     926.116 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  575.384 cycles/op (47.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    732.112 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 434.291 cycles/op (46.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.383835 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing farmhash128_c "farmhash128_with_seed (C99)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     829.473 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  574.360 cycles/op (38.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    778.675 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 449.999 cycles/op (23.7 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.484284 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing xxHash64 "xxHash, 64-bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     786.397 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  537.693 cycles/op (31.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    719.744 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 400.102 cycles/op (24.7 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.054896 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing xxh3 "xxHash v3, 64-bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     847.460 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  534.962 cycles/op (26.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    751.464 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 396.682 cycles/op (18.2 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.022014 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing xxh3low "xxHash v3, 64-bit, low 32-bits part" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     764.379 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  597.230 cycles/op (13.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing xxh128 "xxHash v3, 128-bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     785.038 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  512.911 cycles/op (30.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    698.041 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 388.946 cycles/op (16.4 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.871200 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing xxh128low "xxHash v3, 128-bit, low 64-bits part" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     797.685 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  526.493 cycles/op (32.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    707.332 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 404.077 cycles/op (26.6 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.009132 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing Spooky32 "Bob Jenkins' SpookyHash, 32-bit result" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     827.302 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  633.072 cycles/op (24.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    -------------------------------------------------------------------------------
+--- Testing Spooky64 "Bob Jenkins' SpookyHash, 64-bit result" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     840.601 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  590.719 cycles/op (20.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    789.258 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 387.333 cycles/op (15.8 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.264868 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing Spooky128 "Bob Jenkins' SpookyHash, 128-bit result" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     857.942 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  522.447 cycles/op (28.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    726.309 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 384.682 cycles/op (16.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.925433 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash128crc_1 "MetroHash128crc_1 for x64" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     744.290 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  564.863 cycles/op (38.9 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    733.129 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 394.478 cycles/op (27.6 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.152102 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing metrohash128crc_2 "MetroHash128crc_2 for x64" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     770.679 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  521.607 cycles/op (24.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    750.732 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 388.906 cycles/op (20.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.919689 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing clhash "carry-less mult. hash -DBITMIX (64-bit for x64, SSE4.2)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     857.379 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  561.806 cycles/op (30.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    1054.451 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 413.210 cycles/op (16.6 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.275880 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha2_atonce "Fast Positive Hash (portable, aims 64-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     754.154 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  533.913 cycles/op (35.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    733.193 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 403.195 cycles/op (23.5 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.046322 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha2_stream "Fast Positive Hash (portable, aims 64-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     860.690 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  581.502 cycles/op (28.8 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    899.639 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 468.508 cycles/op (31.2 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.652428 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha1_64le "Fast Positive Hash (portable, aims 64-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     787.830 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  519.485 cycles/op (25.1 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    720.352 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 385.070 cycles/op (12.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.910081 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha1_64be "Fast Positive Hash (portable, aims 64-bit, big-engian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     816.647 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  530.249 cycles/op (23.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    689.931 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 394.583 cycles/op (17.1 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.977606 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha0_32le "Fast Positive Hash (portable, aims 32-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     781.970 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  521.575 cycles/op (24.4 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    706.009 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 397.344 cycles/op (18.6 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.966280 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha0_32be "Fast Positive Hash (portable, aims 32-bit, big-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     741.325 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  525.329 cycles/op (25.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    691.886 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 394.240 cycles/op (13.7 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 4.954947 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha0_aes_noavx "Fast Positive Hash (machine-specific, requires AES-NI)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     782.189 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  533.052 cycles/op (33.0 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    710.948 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 397.425 cycles/op (19.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.016745 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha0_aes_avx1 "Fast Positive Hash (machine-specific, requires AES-NI & AVX)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     774.581 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  529.935 cycles/op (26.2 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    694.916 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 401.250 cycles/op (28.8 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.031026 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing t1ha0_aes_avx2 "Fast Positive Hash (machine-specific, requires AES-NI & AVX2)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     805.784 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  536.819 cycles/op (32.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    757.641 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 398.687 cycles/op (20.0 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.049588 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing wyhash "wyhash v3 (portable, 64-bit, little-endian)" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     747.386 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  547.793 cycles/op (31.5 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    713.377 cycles/op (235886 inserts, 1% deletions)
+Running fast HashMapTest: 387.989 cycles/op (19.9 stdv)  ....... PASS
+
+
+Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
+Verification value is 0x00000001 - Testing took 5.037890 seconds
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+--- Testing wyhash32low "wyhash v3 - lower 32bit" GOOD
+
+[[[ 'Hashmap' Speed Tests (when inlined) ]]]
+
+std::unordered_map
+Init std HashMapTest:     775.251 cycles/op (235886 inserts, 1% deletions)
+Running std HashMapTest:  617.688 cycles/op (29.7 stdv)
+
+greg7mdp/parallel-hashmap
+Init fast HashMapTest:    
\ No newline at end of file
diff --git a/testhashmaps.sh b/testhashmaps.sh
new file mode 100755
index 00000000..4b93fbba
--- /dev/null
+++ b/testhashmaps.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+make -C build
+mv log.hashmap log.hashmap~;
+for g in `build/SMHasher --list | cut -s -f1 | tail -n +15`
+  do build/SMHasher --test=Hashmap $g
+done | tee log.hashmap