Merge branch 'master' into modified

19 files changed, 245 insertions, 237 deletions

diff --git a/misc/benchmarks/picobench/picobench_cmap.cpp b/misc/benchmarks/picobench/picobench_cmap.cpp
index 3ffba5b9..bccbe70c 100644
--- a/misc/benchmarks/picobench/picobench_cmap.cpp
+++ b/misc/benchmarks/picobench/picobench_cmap.cpp
@@ -1,5 +1,5 @@
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 #define i_static
 #include <stc/cstr.h>
 #include <cmath>
@@ -54,36 +54,36 @@ static void ins_and_erase_i(picobench::state& s)
 {
     MapInt map;
     map.max_load_factor((int)MaxLoadFactor100 / 100.0);
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations())
-        map[crandom()];
+        map[crand()];
     map.clear();
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        map[crandom()];
-    csrandom(seed);
+        map[crand()];
+    csrand(seed);
     c_forrange (s.iterations())
-        map.erase(crandom());
+        map.erase(crand());
     s.set_result(map.size());
 }
 /*
 static void ins_and_erase_cmap_i(picobench::state& s)
 {
     cmap_i map = cmap_i_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations())
-        cmap_i_insert(&map, crandom(), 0);
+        cmap_i_insert(&map, crand(), 0);
     cmap_i_clear(&map);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_i_insert(&map, crandom(), 0);
-    csrandom(seed);
+        cmap_i_insert(&map, crand(), 0);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_i_erase(&map, crandom());
+        cmap_i_erase(&map, crand());
     s.set_result(cmap_i_size(&map));
     cmap_i_drop(&map);
 }
@@ -91,18 +91,18 @@ static void ins_and_erase_cmap_i(picobench::state& s)
 static void ins_and_erase_cmap_x(picobench::state& s)
 {
     cmap_x map = cmap_x_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations())
-        cmap_x_insert(&map, crandom(), 0);
+        cmap_x_insert(&map, crand(), 0);
     cmap_x_clear(&map);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_x_insert(&map, crandom(), 0);
-    csrandom(seed);
+        cmap_x_insert(&map, crand(), 0);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_x_erase(&map, crandom());
+        cmap_x_erase(&map, crand());
     s.set_result(cmap_x_size(&map));
     cmap_x_drop(&map);
 }
@@ -124,11 +124,11 @@ static void ins_and_access_i(picobench::state& s)
     size_t result = 0;
     MapInt map;
     map.max_load_factor((int)MaxLoadFactor100 / 100.0);
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (N1)
-        result += ++map[crandom() & mask];
+        result += ++map[crand() & mask];
     s.set_result(result);
 }
 
@@ -137,11 +137,11 @@ static void ins_and_access_cmap_i(picobench::state& s)
     uint64_t mask = (1ull << s.arg()) - 1;
     size_t result = 0;
     cmap_i map = cmap_i_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (N1)
-        result += ++cmap_i_insert(&map, crandom() & mask, 0).ref->second;
+        result += ++cmap_i_insert(&map, crand() & mask, 0).ref->second;
     s.set_result(result);
     cmap_i_drop(&map);
 }
@@ -158,7 +158,7 @@ PICOBENCH_SUITE("Map3");
 
 static void randomize(char* str, size_t len) {
     for (size_t k=0; k < len; ++k) {
-        union {uint64_t i; char c[8];} r = {.i = crandom()};
+        union {uint64_t i; char c[8];} r = {.i = crand()};
         for (unsigned i=0; i<8 && k<len; ++k, ++i)
             str[k] = (r.c[i] & 63) + 48;
     }
@@ -171,7 +171,7 @@ static void ins_and_access_s(picobench::state& s)
     size_t result = 0;
     MapStr map;
     map.max_load_factor((int)MaxLoadFactor100 / 100.0);
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
@@ -189,7 +189,7 @@ static void ins_and_access_cmap_s(picobench::state& s)
     char* buf = cstr_data(&str);
     size_t result = 0;
     cmap_str map = cmap_str_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
@@ -223,22 +223,22 @@ static void iterate_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        map[crandom()] = n;
+        map[crand()] = n;
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        map.erase(crandom());
+        map.erase(crand());
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
@@ -251,22 +251,22 @@ static void iterate_cmap_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        cmap_x_insert_or_assign(&map, crandom(), n);
+        cmap_x_insert_or_assign(&map, crand(), n);
         if (!(n & K)) c_foreach (i, cmap_x, map)
             result += i.ref->second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        cmap_x_erase(&map, crandom());
+        cmap_x_erase(&map, crand());
         if (!(n & K)) c_foreach (i, cmap_x, map)
             result += i.ref->second;
     }
diff --git a/misc/benchmarks/picobench/picobench_csmap.cpp b/misc/benchmarks/picobench/picobench_csmap.cpp
index 5caab6cc..a6a97b14 100644
--- a/misc/benchmarks/picobench/picobench_csmap.cpp
+++ b/misc/benchmarks/picobench/picobench_csmap.cpp
@@ -1,6 +1,6 @@
 #include <iostream>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 #define i_static
 #include <stc/cstr.h>
 #include <cmath>
@@ -71,20 +71,20 @@ template <class MapInt>
 static void insert_i(picobench::state& s)
 {
     MapInt map;
-    csrandom(seed);
+    csrand(seed);
     picobench::scope scope(s);
     c_forrange (n, s.iterations())
-        map.emplace(crandom() & 0xfffffff, n);
+        map.emplace(crand() & 0xfffffff, n);
     s.set_result(map.size());
 }
 
 static void insert_csmap_i(picobench::state& s)
 {
     csmap_i map = csmap_i_init();
-    csrandom(seed);
+    csrand(seed);
     picobench::scope scope(s);
     c_forrange (n, s.iterations())
-        csmap_i_insert(&map, crandom() & 0xfffffff, n);
+        csmap_i_insert(&map, crand() & 0xfffffff, n);
     s.set_result(csmap_i_size(&map));
     csmap_i_drop(&map);
 }
@@ -103,21 +103,21 @@ static void ins_and_erase_i(picobench::state& s)
     size_t result = 0;
     uint64_t mask = (1ull << s.arg()) - 1;
     MapInt map;
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (i, s.iterations())
-        map.emplace(crandom() & mask, i);
+        map.emplace(crand() & mask, i);
     result = map.size();
 
     map.clear();
-    csrandom(seed);
+    csrand(seed);
     c_forrange (i, s.iterations())
-        map[crandom() & mask] = i;
+        map[crand() & mask] = i;
 
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        map.erase(crandom() & mask);
+        map.erase(crand() & mask);
     s.set_result(result);
 }
 
@@ -126,21 +126,21 @@ static void ins_and_erase_csmap_i(picobench::state& s)
     size_t result = 0;
     uint64_t mask = (1ull << s.arg()) - 1;
     csmap_i map = csmap_i_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (i, s.iterations())
-        csmap_i_insert(&map, crandom() & mask, i);
+        csmap_i_insert(&map, crand() & mask, i);
     result = csmap_i_size(&map);
 
     csmap_i_clear(&map);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (i, s.iterations())
-        csmap_i_insert_or_assign(&map, crandom() & mask, i);
+        csmap_i_insert_or_assign(&map, crand() & mask, i);
 
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        csmap_i_erase(&map, crandom() & mask);
+        csmap_i_erase(&map, crand() & mask);
     s.set_result(result);
     csmap_i_drop(&map);
 }
@@ -158,12 +158,12 @@ static void ins_and_access_i(picobench::state& s)
     uint64_t mask = (1ull << s.arg()) - 1;
     size_t result = 0;
     MapInt map;
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
-        result += ++map[crandom() & mask];
-        auto it = map.find(crandom() & mask);
+        result += ++map[crand() & mask];
+        auto it = map.find(crand() & mask);
         if (it != map.end()) map.erase(it->first);
     }
     s.set_result(result + map.size());
@@ -174,12 +174,12 @@ static void ins_and_access_csmap_i(picobench::state& s)
     uint64_t mask = (1ull << s.arg()) - 1;
     size_t result = 0;
     csmap_i map = csmap_i_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
-        result += ++csmap_i_insert(&map, crandom() & mask, 0).ref->second;
-        const csmap_i_value* val = csmap_i_get(&map, crandom() & mask);
+        result += ++csmap_i_insert(&map, crand() & mask, 0).ref->second;
+        const csmap_i_value* val = csmap_i_get(&map, crand() & mask);
         if (val) csmap_i_erase(&map, val->first);
     }
     s.set_result(result + csmap_i_size(&map));
@@ -194,7 +194,7 @@ PICOBENCH(ins_and_access_csmap_i).P;
 PICOBENCH_SUITE("Map4");
 
 static void randomize(char* str, int len) {
-    union {uint64_t i; char c[8];} r = {.i = crandom()};
+    union {uint64_t i; char c[8];} r = {.i = crand()};
     for (int i = len - 7, j = 0; i < len; ++j, ++i)
         str[i] = (r.c[j] & 63) + 48;
 }
@@ -207,12 +207,12 @@ static void ins_and_access_s(picobench::state& s)
     MapStr map;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations()) {
         randomize(&str[0], str.size());
         map.emplace(str, str);
     }
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations()) {
         randomize(&str[0], str.size());
         result += map.erase(str);
@@ -228,12 +228,12 @@ static void ins_and_access_csmap_s(picobench::state& s)
     csmap_str map = csmap_str_init();
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations()) {
         randomize(buf, s.arg());
         csmap_str_emplace(&map, buf, buf);
     }
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations()) {
         randomize(buf, s.arg());
         result += csmap_str_erase(&map, buf);
@@ -262,22 +262,22 @@ static void iterate_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        map[crandom()] = n;
+        map[crand()] = n;
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        map.erase(crandom());
+        map.erase(crand());
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
@@ -290,22 +290,22 @@ static void iterate_csmap_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        csmap_x_insert_or_assign(&map, crandom(), n);
+        csmap_x_insert_or_assign(&map, crand(), n);
         if (!(n & K)) c_foreach (i, csmap_x, map)
             result += i.ref->second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        csmap_x_erase(&map, crandom());
+        csmap_x_erase(&map, crand());
         if (!(n & K)) c_foreach (i, csmap_x, map)
             result += i.ref->second;
     }
diff --git a/misc/benchmarks/plotbench/cdeq_benchmark.cpp b/misc/benchmarks/plotbench/cdeq_benchmark.cpp
index 1259cc07..bb0e28c8 100644
--- a/misc/benchmarks/plotbench/cdeq_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cdeq_benchmark.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <time.h>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #ifdef __cplusplus
 #include <deque>
@@ -12,7 +12,7 @@ enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};
 const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};
 typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;
 typedef struct { const char* name; Range test[N_TESTS]; } Sample;
-enum {SAMPLES = 2, N = 100000000, S = 0x3ffc, R = 4};
+enum {SAMPLES = 2, N = 50000000, S = 0x3ffc, R = 4};
 uint64_t seed = 1, mask1 = 0xfffffff, mask2 = 0xffff;
 
 static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }
@@ -28,10 +28,10 @@ Sample test_std_deque() {
     {
         s.test[INSERT].t1 = clock();
         container con;
-        csrandom(seed);
-        c_forrange (N/3) con.push_front(crandom() & mask1);
-        c_forrange (N/3) {con.push_back(crandom() & mask1); con.pop_front();}
-        c_forrange (N/3) con.push_back(crandom() & mask1);
+        csrand(seed);
+        c_forrange (N/3) con.push_front(crand() & mask1);
+        c_forrange (N/3) {con.push_back(crand() & mask1); con.pop_front();}
+        c_forrange (N/3) con.push_back(crand() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
         s.test[ERASE].t1 = clock();
@@ -40,13 +40,13 @@ Sample test_std_deque() {
         s.test[ERASE].sum = con.size();
      }{
         container con;
-        csrandom(seed);
-        c_forrange (N) con.push_back(crandom() & mask2);
+        csrand(seed);
+        c_forrange (N) con.push_back(crand() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         // Iteration - not inherent find - skipping
         //container::iterator it;
-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crand() & mask2)) != con.end()) sum += *it;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -72,10 +72,10 @@ Sample test_stc_deque() {
         s.test[INSERT].t1 = clock();
         container con = cdeq_x_init();
         //cdeq_x_reserve(&con, N);
-        csrandom(seed);
-        c_forrange (N/3) cdeq_x_push_front(&con, crandom() & mask1);
-        c_forrange (N/3) {cdeq_x_push_back(&con, crandom() & mask1); cdeq_x_pop_front(&con);}
-        c_forrange (N/3) cdeq_x_push_back(&con, crandom() & mask1);
+        csrand(seed);
+        c_forrange (N/3) cdeq_x_push_front(&con, crand() & mask1);
+        c_forrange (N/3) {cdeq_x_push_back(&con, crand() & mask1); cdeq_x_pop_front(&con);}
+        c_forrange (N/3) cdeq_x_push_back(&con, crand() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = cdeq_x_size(&con);
         s.test[ERASE].t1 = clock();
@@ -84,13 +84,13 @@ Sample test_stc_deque() {
         s.test[ERASE].sum = cdeq_x_size(&con);
         cdeq_x_drop(&con);
      }{
-        csrandom(seed);
+        csrand(seed);
         container con = cdeq_x_init();
-        c_forrange (N) cdeq_x_push_back(&con, crandom() & mask2);
+        c_forrange (N) cdeq_x_push_back(&con, crand() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //cdeq_x_iter it, end = cdeq_x_end(&con);
-        //c_forrange (S) if ((it = cdeq_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
+        //c_forrange (S) if ((it = cdeq_x_find(&con, crand() & mask2)).ref != end.ref) sum += *it.ref;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -122,7 +122,7 @@ int main(int argc, char* argv[])
     bool header = (argc > 2 && argv[2][0] == '1');
     float std_sum = 0, stc_sum = 0;
 
-    c_forrange (j, N_TESTS) { 
+    c_forrange (j, N_TESTS) {
         std_sum += secs(std_s[0].test[j]);
         stc_sum += secs(stc_s[0].test[j]);
     }
diff --git a/misc/benchmarks/plotbench/clist_benchmark.cpp b/misc/benchmarks/plotbench/clist_benchmark.cpp
index 04c8e8cd..01bfbf83 100644
--- a/misc/benchmarks/plotbench/clist_benchmark.cpp
+++ b/misc/benchmarks/plotbench/clist_benchmark.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <time.h>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #ifdef __cplusplus
 #include <forward_list>
@@ -12,7 +12,7 @@ enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};
 const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};
 typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;
 typedef struct { const char* name; Range test[N_TESTS]; } Sample;
-enum {SAMPLES = 2, N = 50000000, S = 0x3ffc, R = 4};
+enum {SAMPLES = 2, N = 10000000, S = 0x3ffc, R = 4};
 uint64_t seed = 1, mask1 = 0xfffffff, mask2 = 0xffff;
 
 static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }
@@ -28,9 +28,9 @@ Sample test_std_forward_list() {
     {
         s.test[INSERT].t1 = clock();
         container con;
-        csrandom(seed);
-        c_forrange (N/2) con.push_front(crandom() & mask1);
-        c_forrange (N/2) con.push_front(crandom() & mask1);
+        csrand(seed);
+        c_forrange (N/2) con.push_front(crand() & mask1);
+        c_forrange (N/2) con.push_front(crand() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = 0;
         s.test[ERASE].t1 = clock();
@@ -39,13 +39,13 @@ Sample test_std_forward_list() {
         s.test[ERASE].sum = 0;
      }{
         container con;
-        csrandom(seed);
-        c_forrange (N) con.push_front(crandom() & mask2);
+        csrand(seed);
+        c_forrange (N) con.push_front(crand() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         container::iterator it;
         // Iteration - not inherent find - skipping
-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crand() & mask2)) != con.end()) sum += *it;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -70,9 +70,9 @@ Sample test_stc_forward_list() {
     {
         s.test[INSERT].t1 = clock();
         container con = clist_x_init();
-        csrandom(seed);
-        c_forrange (N/2) clist_x_push_front(&con, crandom() & mask1);
-        c_forrange (N/2) clist_x_push_back(&con, crandom() & mask1);
+        csrand(seed);
+        c_forrange (N/2) clist_x_push_front(&con, crand() & mask1);
+        c_forrange (N/2) clist_x_push_back(&con, crand() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = 0;
         s.test[ERASE].t1 = clock();
@@ -81,13 +81,13 @@ Sample test_stc_forward_list() {
         s.test[ERASE].sum = 0;
         clist_x_drop(&con);
      }{
-        csrandom(seed);
+        csrand(seed);
         container con = clist_x_init();
-        c_forrange (N) clist_x_push_front(&con, crandom() & mask2);
+        c_forrange (N) clist_x_push_front(&con, crand() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //clist_x_iter it, end = clist_x_end(&con);
-        //c_forrange (S) if ((it = clist_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
+        //c_forrange (S) if ((it = clist_x_find(&con, crand() & mask2)).ref != end.ref) sum += *it.ref;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -132,4 +132,4 @@ int main(int argc, char* argv[])
     c_forrange (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
-}
\ No newline at end of file
+}
diff --git a/misc/benchmarks/plotbench/cmap_benchmark.cpp b/misc/benchmarks/plotbench/cmap_benchmark.cpp
index 7a8f29d2..6b2edbd7 100644
--- a/misc/benchmarks/plotbench/cmap_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cmap_benchmark.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <time.h>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #ifdef __cplusplus
 #include <unordered_map>
@@ -11,7 +11,7 @@ enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};
 const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};
 typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;
 typedef struct { const char* name; Range test[N_TESTS]; } Sample;
-enum {SAMPLES = 2, N = 8000000, R = 4};
+enum {SAMPLES = 2, N = 2000000, R = 4};
 uint64_t seed = 1, mask1 = 0xffffffff;
 
 static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }
@@ -26,28 +26,28 @@ Sample test_std_unordered_map() {
     typedef std::unordered_map<uint64_t, uint64_t> container;
     Sample s = {"std,unordered_map"};
     {
-        csrandom(seed);
+        csrand(seed);
         s.test[INSERT].t1 = clock();
         container con;
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
+        c_forrange (i, N/2) con.emplace(crand() & mask1, i);
         c_forrange (i, N/2) con.emplace(i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
-        csrandom(seed);
+        csrand(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) con.erase(crandom() & mask1);
+        c_forrange (N) con.erase(crand() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = con.size();
      }{
         container con;
-        csrandom(seed);
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
+        csrand(seed);
+        c_forrange (i, N/2) con.emplace(crand() & mask1, i);
         c_forrange (i, N/2) con.emplace(i, i);
-        csrandom(seed);
+        csrand(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         container::iterator it;
-        c_forrange (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;
+        c_forrange (N) if ((it = con.find(crand() & mask1)) != con.end()) sum += it->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -70,30 +70,30 @@ Sample test_stc_unordered_map() {
     typedef cmap_x container;
     Sample s = {"STC,unordered_map"};
     {
-        csrandom(seed);
+        csrand(seed);
         s.test[INSERT].t1 = clock();
         container con = cmap_x_init();
-        c_forrange (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);
+        c_forrange (i, N/2) cmap_x_insert(&con, crand() & mask1, i);
         c_forrange (i, N/2) cmap_x_insert(&con, i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = cmap_x_size(&con);
-        csrandom(seed);
+        csrand(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) cmap_x_erase(&con, crandom() & mask1);
+        c_forrange (N) cmap_x_erase(&con, crand() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = cmap_x_size(&con);
         cmap_x_drop(&con);
      }{
         container con = cmap_x_init();
-        csrandom(seed);
-        c_forrange (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);
+        csrand(seed);
+        c_forrange (i, N/2) cmap_x_insert(&con, crand() & mask1, i);
         c_forrange (i, N/2) cmap_x_insert(&con, i, i);
-        csrandom(seed);
+        csrand(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         const cmap_x_value* val;
-        c_forrange (N) 
-            if ((val = cmap_x_get(&con, crandom() & mask1)))
+        c_forrange (N)
+            if ((val = cmap_x_get(&con, crand() & mask1)))
                 sum += val->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
@@ -139,4 +139,4 @@ int main(int argc, char* argv[])
     c_forrange (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
-}
\ No newline at end of file
+}
diff --git a/misc/benchmarks/plotbench/cpque_benchmark.cpp b/misc/benchmarks/plotbench/cpque_benchmark.cpp
index a729c09f..2d4c7a28 100644
--- a/misc/benchmarks/plotbench/cpque_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cpque_benchmark.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <time.h>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #define i_val float
 #define i_cmp -c_default_cmp
@@ -11,19 +11,17 @@
 #include <queue>
 
 static const uint32_t seed = 1234;
+static const int N = 2500000;
 
 void std_test()
 {
-    stc64_t rng;
-    int N = 10000000;
-
     std::priority_queue<float, std::vector<float>, std::greater<float>> pq;
-    rng = stc64_new(seed);
+    csrand(seed);
     clock_t start = clock();
     c_forrange (i, N)
-        pq.push((float) stc64_randf(&rng)*100000);
+        pq.push((float) crandf()*100000.0);
 
-    printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);
+    printf("Built priority queue: %f secs\n", (float)(clock() - start)/(float)CLOCKS_PER_SEC);
     printf("%g ", pq.top());
 
     start = clock();
@@ -31,32 +29,30 @@ void std_test()
         pq.pop();
     }
 
-    printf("\npopped PQ: %f secs\n\n", (clock() - start) / (float) CLOCKS_PER_SEC);
+    printf("\npopped PQ: %f secs\n\n", (float)(clock() - start)/(float)CLOCKS_PER_SEC);
 }
 
 
 void stc_test()
 {
-    stc64_t rng;
-    int N = 10000000, M = 10;
+    int N = 10000000;
 
     c_auto (cpque_f, pq)
     {
-        rng = stc64_new(seed);
+        csrand(seed);
         clock_t start = clock();
-        c_forrange (i, N)
-            cpque_f_push(&pq, (float) stc64_randf(&rng)*100000);
+        c_forrange (i, N) {
+            cpque_f_push(&pq, (float) crandf()*100000);
+        }
 
-        printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);
+        printf("Built priority queue: %f secs\n", (float)(clock() - start)/(float)CLOCKS_PER_SEC);
         printf("%g ", *cpque_f_top(&pq));
- 
-        c_forrange (i, M) {
-            cpque_f_pop(&pq);
-        }
 
         start = clock();
-        c_forrange (i, M, N)
+        c_forrange (i, N) {
             cpque_f_pop(&pq);
+        }
+
         printf("\npopped PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);
     }
 }
diff --git a/misc/benchmarks/plotbench/csmap_benchmark.cpp b/misc/benchmarks/plotbench/csmap_benchmark.cpp
index 46bd695c..60f2db49 100644
--- a/misc/benchmarks/plotbench/csmap_benchmark.cpp
+++ b/misc/benchmarks/plotbench/csmap_benchmark.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <time.h>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #ifdef __cplusplus
 #include <map>
@@ -11,7 +11,7 @@ enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};
 const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};
 typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;
 typedef struct { const char* name; Range test[N_TESTS]; } Sample;
-enum {SAMPLES = 2, N = 4000000, R = 4};
+enum {SAMPLES = 2, N = 1000000, R = 4};
 uint64_t seed = 1, mask1 = 0xfffffff;
 
 static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }
@@ -26,28 +26,28 @@ Sample test_std_map() {
     typedef std::map<size_t, size_t> container;
     Sample s = {"std,map"};
     {
-        csrandom(seed);
+        csrand(seed);
         s.test[INSERT].t1 = clock();
         container con;
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
+        c_forrange (i, N/2) con.emplace(crand() & mask1, i);
         c_forrange (i, N/2) con.emplace(i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
-        csrandom(seed);
+        csrand(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) con.erase(crandom() & mask1);
+        c_forrange (N) con.erase(crand() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = con.size();
      }{
         container con;
-        csrandom(seed);
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
+        csrand(seed);
+        c_forrange (i, N/2) con.emplace(crand() & mask1, i);
         c_forrange (i, N/2) con.emplace(i, i);
-        csrandom(seed);
+        csrand(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         container::iterator it;
-        c_forrange (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;
+        c_forrange (N) if ((it = con.find(crand() & mask1)) != con.end()) sum += it->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -71,30 +71,30 @@ Sample test_stc_map() {
     typedef csmap_x container;
     Sample s = {"STC,map"};
     {
-        csrandom(seed);
+        csrand(seed);
         s.test[INSERT].t1 = clock();
         container con = csmap_x_init();
-        c_forrange (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);
+        c_forrange (i, N/2) csmap_x_insert(&con, crand() & mask1, i);
         c_forrange (i, N/2) csmap_x_insert(&con, i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = csmap_x_size(&con);
-        csrandom(seed);
+        csrand(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) csmap_x_erase(&con, crandom() & mask1);
+        c_forrange (N) csmap_x_erase(&con, crand() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = csmap_x_size(&con);
         csmap_x_drop(&con);
      }{
         container con = csmap_x_init();
-        csrandom(seed);
-        c_forrange (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);
+        csrand(seed);
+        c_forrange (i, N/2) csmap_x_insert(&con, crand() & mask1, i);
         c_forrange (i, N/2) csmap_x_insert(&con, i, i);
-        csrandom(seed);
+        csrand(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         const csmap_x_value* val;
-        c_forrange (N) 
-            if ((val = csmap_x_get(&con, crandom() & mask1)))
+        c_forrange (N)
+            if ((val = csmap_x_get(&con, crand() & mask1)))
                 sum += val->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
diff --git a/misc/benchmarks/plotbench/cvec_benchmark.cpp b/misc/benchmarks/plotbench/cvec_benchmark.cpp
index fe7e09fb..c488a01c 100644
--- a/misc/benchmarks/plotbench/cvec_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cvec_benchmark.cpp
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <time.h>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #ifdef __cplusplus
 #include <vector>
@@ -12,7 +12,7 @@ enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};
 const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};
 typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;
 typedef struct { const char* name; Range test[N_TESTS]; } Sample;
-enum {SAMPLES = 2, N = 150000000, S = 0x3ffc, R = 4};
+enum {SAMPLES = 2, N = 80000000, S = 0x3ffc, R = 4};
 uint64_t seed = 1, mask1 = 0xfffffff, mask2 = 0xffff;
 
 static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }
@@ -28,8 +28,8 @@ Sample test_std_vector() {
     {
         s.test[INSERT].t1 = clock();
         container con;
-        csrandom(seed);
-        c_forrange (N) con.push_back(crandom() & mask1);
+        csrand(seed);
+        c_forrange (N) con.push_back(crand() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
         s.test[ERASE].t1 = clock();
@@ -38,13 +38,13 @@ Sample test_std_vector() {
         s.test[ERASE].sum = con.size();
      }{
         container con;
-        csrandom(seed);
-        c_forrange (N) con.push_back(crandom() & mask2);
+        csrand(seed);
+        c_forrange (N) con.push_back(crand() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //container::iterator it;
         // Iteration - not inherent find - skipping
-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crand() & mask2)) != con.end()) sum += *it;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
@@ -70,8 +70,8 @@ Sample test_stc_vector() {
     {
         s.test[INSERT].t1 = clock();
         container con = cvec_x_init();
-        csrandom(seed);
-        c_forrange (N) cvec_x_push_back(&con, crandom() & mask1);
+        csrand(seed);
+        c_forrange (N) cvec_x_push_back(&con, crand() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = cvec_x_size(&con);
         s.test[ERASE].t1 = clock();
@@ -80,13 +80,13 @@ Sample test_stc_vector() {
         s.test[ERASE].sum = cvec_x_size(&con);
         cvec_x_drop(&con);
      }{
-        csrandom(seed);
+        csrand(seed);
         container con = cvec_x_init();
-        c_forrange (N) cvec_x_push_back(&con, crandom() & mask2);
+        c_forrange (N) cvec_x_push_back(&con, crand() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //cvec_x_iter it, end = cvec_x_end(&con);
-        //c_forrange (S) if ((it = cvec_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
+        //c_forrange (S) if ((it = cvec_x_find(&con, crand() & mask2)).ref != end.ref) sum += *it.ref;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
diff --git a/misc/benchmarks/plotbench/plot.py b/misc/benchmarks/plotbench/plot.py
index fa538285..0ba92264 100644
--- a/misc/benchmarks/plotbench/plot.py
+++ b/misc/benchmarks/plotbench/plot.py
@@ -4,7 +4,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 #sns.set_theme(style="whitegrid")
 
-comp = ['All compilers', 'Mingw-g++-10.30', 'Win-Clang-12', 'VC-19.28']
+comp = ['All compilers', 'Mingw-g++-11.3.0', 'Win-Clang-14.0.1', 'VC-19.28']
 n = int(sys.argv[1]) if len(sys.argv) > 1 else 0
 file = sys.argv[2] if len(sys.argv) > 2 else 'plot_win.csv'
 df = pd.read_csv(file)
diff --git a/misc/benchmarks/plotbench/run_all.bat b/misc/benchmarks/plotbench/run_all.bat
index 2edd0a1e..98913a50 100644
--- a/misc/benchmarks/plotbench/run_all.bat
+++ b/misc/benchmarks/plotbench/run_all.bat
@@ -1,5 +1,7 @@
 set out=plot_win.csv
 echo Compiler,Library,C,Method,Seconds,Ratio> %out%
+echo gcc
 sh run_gcc.sh >> %out%
+echo clang
 sh run_clang.sh >> %out%
-call run_vc.bat >> %out%
+REM call run_vc.bat >> %out%
diff --git a/misc/benchmarks/plotbench/run_clang.sh b/misc/benchmarks/plotbench/run_clang.sh
index ae19486e..096e71be 100644
--- a/misc/benchmarks/plotbench/run_clang.sh
+++ b/misc/benchmarks/plotbench/run_clang.sh
@@ -6,7 +6,7 @@ clang++ -I../include -O3 -o cmap_benchmark$exe   cmap_benchmark.cpp
 clang++ -I../include -O3 -o csmap_benchmark$exe  csmap_benchmark.cpp
 clang++ -I../include -O3 -o cvec_benchmark$exe   cvec_benchmark.cpp
 
-c='Win-Clang-12'
+c='Win-Clang-14.0.1'
 ./cdeq_benchmark$exe $c
 ./clist_benchmark$exe $c
 ./cmap_benchmark$exe $c
diff --git a/misc/benchmarks/plotbench/run_gcc.sh b/misc/benchmarks/plotbench/run_gcc.sh
index 6a6472c0..5249ed1e 100644
--- a/misc/benchmarks/plotbench/run_gcc.sh
+++ b/misc/benchmarks/plotbench/run_gcc.sh
@@ -4,9 +4,9 @@ g++ -I../include -O3 -o cmap_benchmark   cmap_benchmark.cpp
 g++ -I../include -O3 -o csmap_benchmark  csmap_benchmark.cpp
 g++ -I../include -O3 -o cvec_benchmark   cvec_benchmark.cpp
 
-c='Mingw-g++-10.30'
+c='Mingw-g++-11.3.0'
 ./cdeq_benchmark $c
 ./clist_benchmark $c
 ./cmap_benchmark $c
 ./csmap_benchmark $c
-./cvec_benchmark $c
\ No newline at end of file
+./cvec_benchmark $c
diff --git a/misc/benchmarks/plotbench/run_vc.bat b/misc/benchmarks/plotbench/run_vc.bat
index 3dca925b..dc4938f8 100644
--- a/misc/benchmarks/plotbench/run_vc.bat
+++ b/misc/benchmarks/plotbench/run_vc.bat
@@ -1,3 +1,4 @@
+
 @echo off
 if "%VSINSTALLDIR%"=="" call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat" >nul
 cl.exe -nologo -EHsc -std:c++latest -I../include -O2 cdeq_benchmark.cpp >nul
@@ -12,4 +13,4 @@ cdeq_benchmark.exe %c%
 clist_benchmark.exe %c%
 cmap_benchmark.exe %c%
 csmap_benchmark.exe %c%
-cvec_benchmark.exe %c%
\ No newline at end of file
+cvec_benchmark.exe %c%
diff --git a/misc/benchmarks/shootout_hashmaps.cpp b/misc/benchmarks/shootout_hashmaps.cpp
index 39ad1786..bae9a42b 100644
--- a/misc/benchmarks/shootout_hashmaps.cpp
+++ b/misc/benchmarks/shootout_hashmaps.cpp
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <time.h>
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 #define MAX_LOAD_FACTOR 85
 
@@ -35,12 +35,13 @@ KHASH_MAP_INIT_INT64(ii, IValue)
 // cmap template expansion
 #define i_key IKey
 #define i_val IValue
+#define i_ssize int32_t // enable 2^K buckets like the rest.
 #define i_tag ii
 #define i_max_load_factor MAX_LOAD_FACTOR / 100.0f
 #include <stc/cmap.h>
 
-#define SEED(s) rng = stc64_new(s)
-#define RAND(N) (stc64_rand(&rng) & (((uint64_t)1 << N) - 1))
+#define SEED(s) rng = crand_init(s)
+#define RAND(N) (crand_u64(&rng) & (((uint64_t)1 << N) - 1))
 
 #define CMAP_SETUP(X, Key, Value) cmap_##X map = cmap_##X##_init()
 #define CMAP_PUT(X, key, val)     cmap_##X##_insert_or_assign(&map, key, val).ref->second
@@ -313,7 +314,7 @@ int main(int argc, char* argv[])
     unsigned keybits = argc >= 3 ? atoi(argv[2]) : DEFAULT_KEYBITS;
     unsigned n = n_mill * 1000000;
     unsigned N1 = n, N2 = n, N3 = n, N4 = n, N5 = n;
-    stc64_t rng;
+    crand_t rng;
     size_t seed = 123456; // time(NULL);
 
     printf("\nUnordered hash map shootout\n");
diff --git a/misc/benchmarks/various/cbits_benchmark.cpp b/misc/benchmarks/various/cbits_benchmark.cpp
index dd709db1..1764f556 100644
--- a/misc/benchmarks/various/cbits_benchmark.cpp
+++ b/misc/benchmarks/various/cbits_benchmark.cpp
@@ -5,7 +5,7 @@
 
 enum{ N=1<<22 }; // 4.2 mill.
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 #define i_type cbits
 #define i_len N
 #include <stc/cbits.h>
@@ -39,12 +39,12 @@ int main(int argc, char **argv)
     one_sec_delay();
 
     total = 0;
-    csrandom(seed);
+    csrand(seed);
     current_time = get_time_in_ms();
 
     c_forrange (40 * N)
     {
-        uint64_t r = crandom();
+        uint64_t r = crand();
         bools[r & (N-1)] = r & 1<<29;
     }
 
@@ -66,13 +66,13 @@ int main(int argc, char **argv)
     one_sec_delay();
 
     total = 0;
-    csrandom(seed);
+    csrand(seed);
     current_time = get_time_in_ms();
     bitset<N> bits;
 
     c_forrange (40 * N)
     {
-        uint64_t r = crandom();
+        uint64_t r = crand();
         bits[r & (N-1)] = r & 1<<29;
     }
 
@@ -92,13 +92,13 @@ int main(int argc, char **argv)
     one_sec_delay();
 
     total = 0;
-    csrandom(seed);
+    csrand(seed);
     current_time = get_time_in_ms();
     cbits bits2 = cbits_with_size(N, false);
 
     c_forrange (40 * N)
     {
-        uint64_t r = crandom();
+        uint64_t r = crand();
         cbits_set_value(&bits2, r & (N-1), r & 1<<29);
     }
 
diff --git a/misc/benchmarks/various/csort_bench.c b/misc/benchmarks/various/csort_bench.c
index 97885eb8..d5d7fa7c 100644
--- a/misc/benchmarks/various/csort_bench.c
+++ b/misc/benchmarks/various/csort_bench.c
@@ -9,7 +9,7 @@
 #include <stc/algo/csort.h>
 
 #define ROTL(d,bits) ((d<<(bits)) | (d>>(8*sizeof(d)-(bits))))
-uint64_t random(uint64_t s[3]) {
+uint64_t romutrio(uint64_t s[3]) {
     uint64_t xp = s[0], yp = s[1], zp = s[2];
     s[0] = 15241094284759029579u * zp;
     s[1] = yp - xp; s[1] = ROTL(s[1], 12);
@@ -17,12 +17,18 @@ uint64_t random(uint64_t s[3]) {
     return xp;
 }
 
+static int cmp_int(const void* a, const void* b) {
+    return c_default_cmp((const int*)a, (const int*)b);
+}
+
 void testsort(int *a, int size, const char *desc) {
     clock_t t = clock();
 #ifdef __cplusplus
-        { printf("std::sort: "); std::sort(a, a + size); }
+    printf("std::sort: "); std::sort(a, a + size);
+#elif defined QSORT
+    printf("qsort: "); qsort(a, size, sizeof *a, cmp_int);
 #else
-        { printf("stc_sort: "); csort_int(a, size); }
+    printf("stc_sort: "); csort_int(a, size);
 #endif
     t = clock() - t;
 
@@ -39,7 +45,7 @@ int main(int argc, char *argv[]) {
     if (!a) return -1;
 
     for (i = 0; i < size; i++)
-        a[i] = random(s) & (1U << 30) - 1;
+        a[i] = romutrio(s) & (1U << 30) - 1;
     testsort(a, size, "random");
     for (i = 0; i < 20; i++)
         printf(" %d", (int)a[i]);
diff --git a/misc/benchmarks/various/prng_bench.cpp b/misc/benchmarks/various/prng_bench.cpp
index 6f4e0e47..234e3805 100644
--- a/misc/benchmarks/various/prng_bench.cpp
+++ b/misc/benchmarks/various/prng_bench.cpp
@@ -2,7 +2,7 @@
 #include <iostream>
 #include <ctime>
 #include <random>
-#include <stc/crandom.h>
+#include <stc/crand.h>
 
 static inline uint64_t rotl64(const uint64_t x, const int k)
   { return (x << k) | (x >> (64 - k)); }
@@ -122,9 +122,9 @@ using namespace std;
 
 int main(void)
 {
-    enum {N = 2000000000};
+    enum {N = 500000000};
     uint16_t* recipient = new uint16_t[N];
-    static stc64_t rng;
+    static crand_t rng;
     init_state(rng.state, 12345123);
     std::mt19937 mt(12345123);
 
@@ -187,7 +187,7 @@ int main(void)
 
         beg = clock();
         for (size_t i = 0; i < N; i++)
-            recipient[i] = stc64_rand(&rng);
+            recipient[i] = crand_u64(&rng);
         end = clock();
         cout << "stc64:\t\t"
              << (float(end - beg) / CLOCKS_PER_SEC)
diff --git a/misc/benchmarks/various/rust_cmap.c b/misc/benchmarks/various/rust_cmap.c
index 83b7dd19..abdb42b0 100644
--- a/misc/benchmarks/various/rust_cmap.c
+++ b/misc/benchmarks/various/rust_cmap.c
@@ -24,38 +24,40 @@ uint64_t romu_trio(uint64_t s[3]) {
 
 int main()
 {
-    c_auto (cmap_u64, m) {
-        const size_t n = 50000000, 
-                     mask = (1 << 25) - 1,
-                     ms = CLOCKS_PER_SEC/1000; 
-        cmap_u64_reserve(&m, n);
-        printf("STC cmap  n = %" c_ZU ", mask = 0x%" PRIxMAX "\n", n, mask);
-
-        uint64_t rng[3] = {1872361123, 123879177, 87739234}, sum;
-        clock_t now = clock();
-        c_forrange (n) {
-            uint64_t key = romu_trio(rng) & mask;
-            cmap_u64_insert(&m, key, 0).ref->second += 1;
-        }
-        printf("insert  : %" c_ZU "ms  \tsize : %" c_ZU "\n", (clock() - now)/ms, cmap_u64_size(&m));
-
-        now = clock();
-        sum = 0;
-        c_forrange (key, mask + 1) { sum += cmap_u64_contains(&m, key); }
-        printf("lookup  : %" c_ZU "ms  \tsum  : %" c_ZU "\n", (clock() - now)/ms, sum);
-
-        now = clock();
-        sum = 0;
-        c_foreach (i, cmap_u64, m) { sum += i.ref->second; }
-        printf("iterate : %" c_ZU "ms  \tsum  : %" c_ZU "\n", (clock() - now)/ms, sum);
-
-        uint64_t rng2[3] = {1872361123, 123879177, 87739234};
-        now = clock();
-        c_forrange (n) {
-            uint64_t key = romu_trio(rng2) & mask;
-            cmap_u64_erase(&m, key);
-        }
-        printf("remove  : %" c_ZU "ms  \tsize : %" c_ZU "\n", (clock() - now)/ms, cmap_u64_size(&m));
-        printf("press a key:\n"); getchar();
+    cmap_u64 m = {0};
+
+    const size_t n = 50000000, 
+                    mask = (1 << 25) - 1,
+                    ms = CLOCKS_PER_SEC/1000; 
+    cmap_u64_reserve(&m, n);
+    printf("STC cmap  n = %" c_ZU ", mask = 0x%" PRIxMAX "\n", n, mask);
+
+    uint64_t rng[3] = {1872361123, 123879177, 87739234}, sum;
+    clock_t now = clock();
+    c_forrange (n) {
+        uint64_t key = romu_trio(rng) & mask;
+        cmap_u64_insert(&m, key, 0).ref->second += 1;
     }
+    printf("insert  : %" c_ZU "ms  \tsize : %" c_ZU "\n", (clock() - now)/ms, cmap_u64_size(&m));
+
+    now = clock();
+    sum = 0;
+    c_forrange (key, mask + 1) { sum += cmap_u64_contains(&m, key); }
+    printf("lookup  : %" c_ZU "ms  \tsum  : %" c_ZU "\n", (clock() - now)/ms, sum);
+
+    now = clock();
+    sum = 0;
+    c_foreach (i, cmap_u64, m) { sum += i.ref->second; }
+    printf("iterate : %" c_ZU "ms  \tsum  : %" c_ZU "\n", (clock() - now)/ms, sum);
+
+    uint64_t rng2[3] = {1872361123, 123879177, 87739234};
+    now = clock();
+    c_forrange (n) {
+        uint64_t key = romu_trio(rng2) & mask;
+        cmap_u64_erase(&m, key);
+    }
+    printf("remove  : %" c_ZU "ms  \tsize : %" c_ZU "\n", (clock() - now)/ms, cmap_u64_size(&m));
+    printf("press a key:\n"); getchar();
+
+    cmap_u64_drop(&m);
 }
diff --git a/misc/benchmarks/various/sso_bench.cpp b/misc/benchmarks/various/sso_bench.cpp
index 0fffef7a..993ff1bb 100644
--- a/misc/benchmarks/various/sso_bench.cpp
+++ b/misc/benchmarks/various/sso_bench.cpp
@@ -2,7 +2,7 @@
 #include <iostream>
 #include <chrono>
 
-#include <stc/crandom.h>
+#include <stc/crand.h>
 #include <stc/cstr.h>
 
 #define i_type StcVec
@@ -30,7 +30,7 @@ static inline std::string randomString_STD(int strsize) {
     char* p = &s[0];
     union { uint64_t u8; uint8_t b[8]; } r;
     for (int i = 0; i < strsize; ++i) {
-        if ((i & 7) == 0) r.u8 = crandom() & 0x3f3f3f3f3f3f3f3f;
+        if ((i & 7) == 0) r.u8 = crand() & 0x3f3f3f3f3f3f3f3f;
         p[i] = CHARS[r.b[i & 7]];
     }
     return s;
@@ -41,7 +41,7 @@ static inline cstr randomString_STC(int strsize) {
     char* p = cstr_data(&s);
     union { uint64_t u8; uint8_t b[8]; } r;
     for (int i = 0; i < strsize; ++i) {
-        if ((i & 7) == 0) r.u8 = crandom() & 0x3f3f3f3f3f3f3f3f;
+        if ((i & 7) == 0) r.u8 = crand() & 0x3f3f3f3f3f3f3f3f;
         p[i] = CHARS[r.b[i & 7]];
     }
     return s;
@@ -85,7 +85,7 @@ int main() {
 
     // VECTOR WITH STRINGS
 
-    csrandom(seed);
+    csrand(seed);
     sum = 0, n = 0;
     std::cerr << "\nstrsize\tmsecs\tstd::vector<std::string>, size=" << BENCHMARK_SIZE << "\n";
     for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
@@ -95,7 +95,7 @@ int main() {
     }
     std::cout << "Avg:\t" << sum/n << '\n';
 
-    csrandom(seed);
+    csrand(seed);
     sum = 0, n = 0;
     std::cerr << "\nstrsize\tmsecs\tcvec<cstr>, size=" << BENCHMARK_SIZE << "\n";
     for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
@@ -108,7 +108,7 @@ int main() {
 
     // SORTED SET WITH STRINGS
     
-    csrandom(seed);
+    csrand(seed);
     sum = 0, n = 0;
     std::cerr << "\nstrsize\tmsecs\tstd::set<std::string>, size=" << BENCHMARK_SIZE/16 << "\n";
     for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
@@ -118,7 +118,7 @@ int main() {
     }
     std::cout << "Avg:\t" << sum/n << '\n';
 
-    csrandom(seed);
+    csrand(seed);
     sum = 0, n = 0;
     std::cerr << "\nstrsize\tmsecs\tcsset<cstr>, size=" << BENCHMARK_SIZE/16 << "\n";
     for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {