77 files changed, 3563 insertions, 684 deletions

diff --git a/.gitattributes b/.gitattributes
index 474746c1..66fdcd56 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,3 +1,3 @@
-benchmarks/others/* linguist-vendored

+benchmarks/external/* linguist-vendored

 *.h linguist-language=C

 *.c linguist-language=C

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f834aceb..6389259c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ if(BUILD_TESTING)
 		add_test(NAME ${name} COMMAND ${name})
 	endforeach()
 	foreach(name IN ITEMS cdeq clist cmap csmap cvec)
-		add_executable(${name} benchmarks/${name}_benchmark.cpp)
+		add_executable(${name} benchmarks/plotbench/${name}_benchmark.cpp)
 		target_link_libraries(${name} PRIVATE stc m)
 		add_test(NAME ${name} COMMAND ${name})
 	endforeach()
diff --git a/README.md b/README.md
index a82202b7..7b53a8e5 100644
--- a/README.md
+++ b/README.md
@@ -40,8 +40,9 @@ which by the compiler is seen as different code because of macro name substituti
 - [***cvec*** - **std::vector** alike type](docs/cvec_api.md)
 
 Others:
-- [***crandom*** - A novel very fast *PRNG* named **stc64**](docs/crandom_api.md)
 - [***ccommon*** - Some handy macros and general definitions](docs/ccommon_api.md)
+- [***crandom*** - A novel very fast *PRNG* named **stc64**](docs/crandom_api.md)
+- [***coption*** - Command line options scanner](docs/coption_api.md)
 
 Highlights
 ----------
diff --git a/benchmarks/build_all.sh b/benchmarks/build_all.sh
index 36dc8f33..348a79dd 100644
--- a/benchmarks/build_all.sh
+++ b/benchmarks/build_all.sh
@@ -18,14 +18,14 @@ if [ ! -z "$1" ] ; then
     cc=$@
 fi
 if [ $run = 0 ] ; then
-    for i in *.cpp ; do
+    for i in misc/*.c* picobench/*.cpp plotbench/*.cpp ; do
         echo $cc -I../include $i
         $cc -I../include $i
     done
 else
-    for i in *.c ; do
-        echo $cc -I../include $i
-        $cc -I../include $i
+    for i in misc/*.c* picobench/*.cpp ; do
+        echo $cc -O3 -I../include $i
+        $cc -O3 -I../include $i
         if [ -f $(basename -s .c $i).exe ]; then ./$(basename -s .c $i).exe; fi
         if [ -f ./a.exe ]; then ./a.exe; fi
         if [ -f ./a.out ]; then ./a.out; fi
diff --git a/benchmarks/others/khash.h b/benchmarks/external/khash.h
index 61dabc4d..61dabc4d 100644
--- a/benchmarks/others/khash.h
+++ b/benchmarks/external/khash.h
diff --git a/benchmarks/others/parallel_hashmap/btree.h b/benchmarks/external/parallel_hashmap/btree.h
index b8c95433..b8c95433 100644
--- a/benchmarks/others/parallel_hashmap/btree.h
+++ b/benchmarks/external/parallel_hashmap/btree.h
diff --git a/benchmarks/others/parallel_hashmap/conanfile.py b/benchmarks/external/parallel_hashmap/conanfile.py
index c046377d..c046377d 100644
--- a/benchmarks/others/parallel_hashmap/conanfile.py
+++ b/benchmarks/external/parallel_hashmap/conanfile.py
diff --git a/benchmarks/others/parallel_hashmap/meminfo.h b/benchmarks/external/parallel_hashmap/meminfo.h
index 872f3c69..872f3c69 100644
--- a/benchmarks/others/parallel_hashmap/meminfo.h
+++ b/benchmarks/external/parallel_hashmap/meminfo.h
diff --git a/benchmarks/others/parallel_hashmap/phmap.h b/benchmarks/external/parallel_hashmap/phmap.h
index 653ae5ea..653ae5ea 100644
--- a/benchmarks/others/parallel_hashmap/phmap.h
+++ b/benchmarks/external/parallel_hashmap/phmap.h
diff --git a/benchmarks/others/parallel_hashmap/phmap_base.h b/benchmarks/external/parallel_hashmap/phmap_base.h
index d0c6f3ce..d0c6f3ce 100644
--- a/benchmarks/others/parallel_hashmap/phmap_base.h
+++ b/benchmarks/external/parallel_hashmap/phmap_base.h
diff --git a/benchmarks/others/parallel_hashmap/phmap_bits.h b/benchmarks/external/parallel_hashmap/phmap_bits.h
index 6b765fff..6b765fff 100644
--- a/benchmarks/others/parallel_hashmap/phmap_bits.h
+++ b/benchmarks/external/parallel_hashmap/phmap_bits.h
diff --git a/benchmarks/others/parallel_hashmap/phmap_config.h b/benchmarks/external/parallel_hashmap/phmap_config.h
index fa515025..fa515025 100644
--- a/benchmarks/others/parallel_hashmap/phmap_config.h
+++ b/benchmarks/external/parallel_hashmap/phmap_config.h
diff --git a/benchmarks/others/parallel_hashmap/phmap_dump.h b/benchmarks/external/parallel_hashmap/phmap_dump.h
index 0f2018ef..0f2018ef 100644
--- a/benchmarks/others/parallel_hashmap/phmap_dump.h
+++ b/benchmarks/external/parallel_hashmap/phmap_dump.h
diff --git a/benchmarks/others/parallel_hashmap/phmap_fwd_decl.h b/benchmarks/external/parallel_hashmap/phmap_fwd_decl.h
index a7719c49..a7719c49 100644
--- a/benchmarks/others/parallel_hashmap/phmap_fwd_decl.h
+++ b/benchmarks/external/parallel_hashmap/phmap_fwd_decl.h
diff --git a/benchmarks/others/parallel_hashmap/phmap_utils.h b/benchmarks/external/parallel_hashmap/phmap_utils.h
index 1d0c4728..1d0c4728 100644
--- a/benchmarks/others/parallel_hashmap/phmap_utils.h
+++ b/benchmarks/external/parallel_hashmap/phmap_utils.h
diff --git a/benchmarks/others/robin_hood.hpp b/benchmarks/external/robin_hood.h
index ec2af8c6..ec2af8c6 100644
--- a/benchmarks/others/robin_hood.hpp
+++ b/benchmarks/external/robin_hood.h
diff --git a/benchmarks/others/skarupke/bytell_hash_map.hpp b/benchmarks/external/skarupke/bytell_hash_map.hpp
index 9c9a2467..9c9a2467 100644
--- a/benchmarks/others/skarupke/bytell_hash_map.hpp
+++ b/benchmarks/external/skarupke/bytell_hash_map.hpp
diff --git a/benchmarks/others/skarupke/flat_hash_map.hpp b/benchmarks/external/skarupke/flat_hash_map.hpp
index a8723ee8..a8723ee8 100644
--- a/benchmarks/others/skarupke/flat_hash_map.hpp
+++ b/benchmarks/external/skarupke/flat_hash_map.hpp
diff --git a/benchmarks/others/tsl/hopscotch_growth_policy.h b/benchmarks/external/tsl/hopscotch_growth_policy.h
index 0e463868..0e463868 100644
--- a/benchmarks/others/tsl/hopscotch_growth_policy.h
+++ b/benchmarks/external/tsl/hopscotch_growth_policy.h
diff --git a/benchmarks/others/tsl/hopscotch_hash.h b/benchmarks/external/tsl/hopscotch_hash.h
index ad4f58e0..ad4f58e0 100644
--- a/benchmarks/others/tsl/hopscotch_hash.h
+++ b/benchmarks/external/tsl/hopscotch_hash.h
diff --git a/benchmarks/others/tsl/hopscotch_map.h b/benchmarks/external/tsl/hopscotch_map.h
index 15c9e398..15c9e398 100644
--- a/benchmarks/others/tsl/hopscotch_map.h
+++ b/benchmarks/external/tsl/hopscotch_map.h
diff --git a/benchmarks/external/tsl/robin_growth_policy.h b/benchmarks/external/tsl/robin_growth_policy.h
new file mode 100644
index 00000000..62f9a2e0
--- /dev/null
+++ b/benchmarks/external/tsl/robin_growth_policy.h
@@ -0,0 +1,406 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ROBIN_GROWTH_POLICY_H
+#define TSL_ROBIN_GROWTH_POLICY_H
+
+#include <algorithm>
+#include <array>
+#include <climits>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <ratio>
+#include <stdexcept>
+
+#ifdef TSL_DEBUG
+#define tsl_rh_assert(expr) assert(expr)
+#else
+#define tsl_rh_assert(expr) (static_cast<void>(0))
+#endif
+
+/**
+ * If exceptions are enabled, throw the exception passed in parameter, otherwise
+ * call std::terminate.
+ */
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || \
+     (defined(_MSC_VER) && defined(_CPPUNWIND))) &&        \
+    !defined(TSL_NO_EXCEPTIONS)
+#define TSL_RH_THROW_OR_TERMINATE(ex, msg) throw ex(msg)
+#else
+#define TSL_RH_NO_EXCEPTIONS
+#ifdef NDEBUG
+#define TSL_RH_THROW_OR_TERMINATE(ex, msg) std::terminate()
+#else
+#include <iostream>
+#define TSL_RH_THROW_OR_TERMINATE(ex, msg) \
+  do {                                     \
+    std::cerr << msg << std::endl;         \
+    std::terminate();                      \
+  } while (0)
+#endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define TSL_RH_LIKELY(exp) (__builtin_expect(!!(exp), true))
+#else
+#define TSL_RH_LIKELY(exp) (exp)
+#endif
+
+#define TSL_RH_UNUSED(x) static_cast<void>(x)
+
+namespace tsl {
+namespace rh {
+
+/**
+ * Grow the hash table by a factor of GrowthFactor keeping the bucket count to a
+ * power of two. It allows the table to use a mask operation instead of a modulo
+ * operation to map a hash to a bucket.
+ *
+ * GrowthFactor must be a power of two >= 2.
+ */
+template <std::size_t GrowthFactor>
+class power_of_two_growth_policy {
+ public:
+  /**
+   * Called on the hash table creation and on rehash. The number of buckets for
+   * the table is passed in parameter. This number is a minimum, the policy may
+   * update this value with a higher value if needed (but not lower).
+   *
+   * If 0 is given, min_bucket_count_in_out must still be 0 after the policy
+   * creation and bucket_for_hash must always return 0 in this case.
+   */
+  explicit power_of_two_growth_policy(std::size_t& min_bucket_count_in_out) {
+    if (min_bucket_count_in_out > max_bucket_count()) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    if (min_bucket_count_in_out > 0) {
+      min_bucket_count_in_out =
+          round_up_to_power_of_two(min_bucket_count_in_out);
+      m_mask = min_bucket_count_in_out - 1;
+    } else {
+      m_mask = 0;
+    }
+  }
+
+  /**
+   * Return the bucket [0, bucket_count()) to which the hash belongs.
+   * If bucket_count() is 0, it must always return 0.
+   */
+  std::size_t bucket_for_hash(std::size_t hash) const noexcept {
+    return hash & m_mask;
+  }
+
+  /**
+   * Return the number of buckets that should be used on next growth.
+   */
+  std::size_t next_bucket_count() const {
+    if ((m_mask + 1) > max_bucket_count() / GrowthFactor) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    return (m_mask + 1) * GrowthFactor;
+  }
+
+  /**
+   * Return the maximum number of buckets supported by the policy.
+   */
+  std::size_t max_bucket_count() const {
+    // Largest power of two.
+    return (std::numeric_limits<std::size_t>::max() / 2) + 1;
+  }
+
+  /**
+   * Reset the growth policy as if it was created with a bucket count of 0.
+   * After a clear, the policy must always return 0 when bucket_for_hash is
+   * called.
+   */
+  void clear() noexcept { m_mask = 0; }
+
+ private:
+  static std::size_t round_up_to_power_of_two(std::size_t value) {
+    if (is_power_of_two(value)) {
+      return value;
+    }
+
+    if (value == 0) {
+      return 1;
+    }
+
+    --value;
+    for (std::size_t i = 1; i < sizeof(std::size_t) * CHAR_BIT; i *= 2) {
+      value |= value >> i;
+    }
+
+    return value + 1;
+  }
+
+  static constexpr bool is_power_of_two(std::size_t value) {
+    return value != 0 && (value & (value - 1)) == 0;
+  }
+
+ protected:
+  static_assert(is_power_of_two(GrowthFactor) && GrowthFactor >= 2,
+                "GrowthFactor must be a power of two >= 2.");
+
+  std::size_t m_mask;
+};
+
+/**
+ * Grow the hash table by GrowthFactor::num / GrowthFactor::den and use a modulo
+ * to map a hash to a bucket. Slower but it can be useful if you want a slower
+ * growth.
+ */
+template <class GrowthFactor = std::ratio<3, 2>>
+class mod_growth_policy {
+ public:
+  explicit mod_growth_policy(std::size_t& min_bucket_count_in_out) {
+    if (min_bucket_count_in_out > max_bucket_count()) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    if (min_bucket_count_in_out > 0) {
+      m_mod = min_bucket_count_in_out;
+    } else {
+      m_mod = 1;
+    }
+  }
+
+  std::size_t bucket_for_hash(std::size_t hash) const noexcept {
+    return hash % m_mod;
+  }
+
+  std::size_t next_bucket_count() const {
+    if (m_mod == max_bucket_count()) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    const double next_bucket_count =
+        std::ceil(double(m_mod) * REHASH_SIZE_MULTIPLICATION_FACTOR);
+    if (!std::isnormal(next_bucket_count)) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    if (next_bucket_count > double(max_bucket_count())) {
+      return max_bucket_count();
+    } else {
+      return std::size_t(next_bucket_count);
+    }
+  }
+
+  std::size_t max_bucket_count() const { return MAX_BUCKET_COUNT; }
+
+  void clear() noexcept { m_mod = 1; }
+
+ private:
+  static constexpr double REHASH_SIZE_MULTIPLICATION_FACTOR =
+      1.0 * GrowthFactor::num / GrowthFactor::den;
+  static const std::size_t MAX_BUCKET_COUNT =
+      std::size_t(double(std::numeric_limits<std::size_t>::max() /
+                         REHASH_SIZE_MULTIPLICATION_FACTOR));
+
+  static_assert(REHASH_SIZE_MULTIPLICATION_FACTOR >= 1.1,
+                "Growth factor should be >= 1.1.");
+
+  std::size_t m_mod;
+};
+
+namespace detail {
+
+#if SIZE_MAX >= ULLONG_MAX
+#define TSL_RH_NB_PRIMES 51
+#elif SIZE_MAX >= ULONG_MAX
+#define TSL_RH_NB_PRIMES 40
+#else
+#define TSL_RH_NB_PRIMES 23
+#endif
+
+static constexpr const std::array<std::size_t, TSL_RH_NB_PRIMES> PRIMES = {{
+    1u,
+    5u,
+    17u,
+    29u,
+    37u,
+    53u,
+    67u,
+    79u,
+    97u,
+    131u,
+    193u,
+    257u,
+    389u,
+    521u,
+    769u,
+    1031u,
+    1543u,
+    2053u,
+    3079u,
+    6151u,
+    12289u,
+    24593u,
+    49157u,
+#if SIZE_MAX >= ULONG_MAX
+    98317ul,
+    196613ul,
+    393241ul,
+    786433ul,
+    1572869ul,
+    3145739ul,
+    6291469ul,
+    12582917ul,
+    25165843ul,
+    50331653ul,
+    100663319ul,
+    201326611ul,
+    402653189ul,
+    805306457ul,
+    1610612741ul,
+    3221225473ul,
+    4294967291ul,
+#endif
+#if SIZE_MAX >= ULLONG_MAX
+    6442450939ull,
+    12884901893ull,
+    25769803751ull,
+    51539607551ull,
+    103079215111ull,
+    206158430209ull,
+    412316860441ull,
+    824633720831ull,
+    1649267441651ull,
+    3298534883309ull,
+    6597069766657ull,
+#endif
+}};
+
+template <unsigned int IPrime>
+static constexpr std::size_t mod(std::size_t hash) {
+  return hash % PRIMES[IPrime];
+}
+
+// MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for
+// faster modulo as the compiler can optimize the modulo code better with a
+// constant known at the compilation.
+static constexpr const std::array<std::size_t (*)(std::size_t),
+                                  TSL_RH_NB_PRIMES>
+    MOD_PRIME = {{
+        &mod<0>,  &mod<1>,  &mod<2>,  &mod<3>,  &mod<4>,  &mod<5>,
+        &mod<6>,  &mod<7>,  &mod<8>,  &mod<9>,  &mod<10>, &mod<11>,
+        &mod<12>, &mod<13>, &mod<14>, &mod<15>, &mod<16>, &mod<17>,
+        &mod<18>, &mod<19>, &mod<20>, &mod<21>, &mod<22>,
+#if SIZE_MAX >= ULONG_MAX
+        &mod<23>, &mod<24>, &mod<25>, &mod<26>, &mod<27>, &mod<28>,
+        &mod<29>, &mod<30>, &mod<31>, &mod<32>, &mod<33>, &mod<34>,
+        &mod<35>, &mod<36>, &mod<37>, &mod<38>, &mod<39>,
+#endif
+#if SIZE_MAX >= ULLONG_MAX
+        &mod<40>, &mod<41>, &mod<42>, &mod<43>, &mod<44>, &mod<45>,
+        &mod<46>, &mod<47>, &mod<48>, &mod<49>, &mod<50>,
+#endif
+    }};
+
+}  // namespace detail
+
+/**
+ * Grow the hash table by using prime numbers as bucket count. Slower than
+ * tsl::rh::power_of_two_growth_policy in general but will probably distribute
+ * the values around better in the buckets with a poor hash function.
+ *
+ * To allow the compiler to optimize the modulo operation, a lookup table is
+ * used with constant primes numbers.
+ *
+ * With a switch the code would look like:
+ * \code
+ * switch(iprime) { // iprime is the current prime of the hash table
+ *     case 0: hash % 5ul;
+ *             break;
+ *     case 1: hash % 17ul;
+ *             break;
+ *     case 2: hash % 29ul;
+ *             break;
+ *     ...
+ * }
+ * \endcode
+ *
+ * Due to the constant variable in the modulo the compiler is able to optimize
+ * the operation by a series of multiplications, substractions and shifts.
+ *
+ * The 'hash % 5' could become something like 'hash - (hash * 0xCCCCCCCD) >> 34)
+ * * 5' in a 64 bits environment.
+ */
+class prime_growth_policy {
+ public:
+  explicit prime_growth_policy(std::size_t& min_bucket_count_in_out) {
+    auto it_prime = std::lower_bound(
+        detail::PRIMES.begin(), detail::PRIMES.end(), min_bucket_count_in_out);
+    if (it_prime == detail::PRIMES.end()) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    m_iprime = static_cast<unsigned int>(
+        std::distance(detail::PRIMES.begin(), it_prime));
+    if (min_bucket_count_in_out > 0) {
+      min_bucket_count_in_out = *it_prime;
+    } else {
+      min_bucket_count_in_out = 0;
+    }
+  }
+
+  std::size_t bucket_for_hash(std::size_t hash) const noexcept {
+    return detail::MOD_PRIME[m_iprime](hash);
+  }
+
+  std::size_t next_bucket_count() const {
+    if (m_iprime + 1 >= detail::PRIMES.size()) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The hash table exceeds its maximum size.");
+    }
+
+    return detail::PRIMES[m_iprime + 1];
+  }
+
+  std::size_t max_bucket_count() const { return detail::PRIMES.back(); }
+
+  void clear() noexcept { m_iprime = 0; }
+
+ private:
+  unsigned int m_iprime;
+
+  static_assert(std::numeric_limits<decltype(m_iprime)>::max() >=
+                    detail::PRIMES.size(),
+                "The type of m_iprime is not big enough.");
+};
+
+}  // namespace rh
+}  // namespace tsl
+
+#endif
diff --git a/benchmarks/external/tsl/robin_hash.h b/benchmarks/external/tsl/robin_hash.h
new file mode 100644
index 00000000..e34eac32
--- /dev/null
+++ b/benchmarks/external/tsl/robin_hash.h
@@ -0,0 +1,1625 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ROBIN_HASH_H
+#define TSL_ROBIN_HASH_H
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "robin_growth_policy.h"
+
+namespace tsl {
+
+namespace detail_robin_hash {
+
+template <typename T>
+struct make_void {
+  using type = void;
+};
+
+template <typename T, typename = void>
+struct has_is_transparent : std::false_type {};
+
+template <typename T>
+struct has_is_transparent<T,
+                          typename make_void<typename T::is_transparent>::type>
+    : std::true_type {};
+
+template <typename U>
+struct is_power_of_two_policy : std::false_type {};
+
+template <std::size_t GrowthFactor>
+struct is_power_of_two_policy<tsl::rh::power_of_two_growth_policy<GrowthFactor>>
+    : std::true_type {};
+
+// Only available in C++17, we need to be compatible with C++11
+template <class T>
+const T& clamp(const T& v, const T& lo, const T& hi) {
+  return std::min(hi, std::max(lo, v));
+}
+
+template <typename T, typename U>
+static T numeric_cast(U value,
+                      const char* error_message = "numeric_cast() failed.") {
+  T ret = static_cast<T>(value);
+  if (static_cast<U>(ret) != value) {
+    TSL_RH_THROW_OR_TERMINATE(std::runtime_error, error_message);
+  }
+
+  const bool is_same_signedness =
+      (std::is_unsigned<T>::value && std::is_unsigned<U>::value) ||
+      (std::is_signed<T>::value && std::is_signed<U>::value);
+  if (!is_same_signedness && (ret < T{}) != (value < U{})) {
+    TSL_RH_THROW_OR_TERMINATE(std::runtime_error, error_message);
+  }
+
+  return ret;
+}
+
+template <class T, class Deserializer>
+static T deserialize_value(Deserializer& deserializer) {
+  // MSVC < 2017 is not conformant, circumvent the problem by removing the
+  // template keyword
+#if defined(_MSC_VER) && _MSC_VER < 1910
+  return deserializer.Deserializer::operator()<T>();
+#else
+  return deserializer.Deserializer::template operator()<T>();
+#endif
+}
+
+/**
+ * Fixed size type used to represent size_type values on serialization. Need to
+ * be big enough to represent a std::size_t on 32 and 64 bits platforms, and
+ * must be the same size on both platforms.
+ */
+using slz_size_type = std::uint64_t;
+static_assert(std::numeric_limits<slz_size_type>::max() >=
+                  std::numeric_limits<std::size_t>::max(),
+              "slz_size_type must be >= std::size_t");
+
+using truncated_hash_type = std::uint32_t;
+
+/**
+ * Helper class that stores a truncated hash if StoreHash is true and nothing
+ * otherwise.
+ */
+template <bool StoreHash>
+class bucket_entry_hash {
+ public:
+  bool bucket_hash_equal(std::size_t /*hash*/) const noexcept { return true; }
+
+  truncated_hash_type truncated_hash() const noexcept { return 0; }
+
+ protected:
+  void set_hash(truncated_hash_type /*hash*/) noexcept {}
+};
+
+template <>
+class bucket_entry_hash<true> {
+ public:
+  bool bucket_hash_equal(std::size_t hash) const noexcept {
+    return m_hash == truncated_hash_type(hash);
+  }
+
+  truncated_hash_type truncated_hash() const noexcept { return m_hash; }
+
+ protected:
+  void set_hash(truncated_hash_type hash) noexcept {
+    m_hash = truncated_hash_type(hash);
+  }
+
+ private:
+  truncated_hash_type m_hash;
+};
+
+/**
+ * Each bucket entry has:
+ * - A value of type `ValueType`.
+ * - An integer to store how far the value of the bucket, if any, is from its
+ * ideal bucket (ex: if the current bucket 5 has the value 'foo' and
+ * `hash('foo') % nb_buckets` == 3, `dist_from_ideal_bucket()` will return 2 as
+ * the current value of the bucket is two buckets away from its ideal bucket) If
+ * there is no value in the bucket (i.e. `empty()` is true)
+ * `dist_from_ideal_bucket()` will be < 0.
+ * - A marker which tells us if the bucket is the last bucket of the bucket
+ * array (useful for the iterator of the hash table).
+ * - If `StoreHash` is true, 32 bits of the hash of the value, if any, are also
+ * stored in the bucket. If the size of the hash is more than 32 bits, it is
+ * truncated. We don't store the full hash as storing the hash is a potential
+ * opportunity to use the unused space due to the alignment of the bucket_entry
+ * structure. We can thus potentially store the hash without any extra space
+ *   (which would not be possible with 64 bits of the hash).
+ */
+template <typename ValueType, bool StoreHash>
+class bucket_entry : public bucket_entry_hash<StoreHash> {
+  using bucket_hash = bucket_entry_hash<StoreHash>;
+
+ public:
+  using value_type = ValueType;
+  using distance_type = std::int16_t;
+
+  bucket_entry() noexcept
+      : bucket_hash(),
+        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
+        m_last_bucket(false) {
+    tsl_rh_assert(empty());
+  }
+
+  bucket_entry(bool last_bucket) noexcept
+      : bucket_hash(),
+        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
+        m_last_bucket(last_bucket) {
+    tsl_rh_assert(empty());
+  }
+
+  bucket_entry(const bucket_entry& other) noexcept(
+      std::is_nothrow_copy_constructible<value_type>::value)
+      : bucket_hash(other),
+        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
+        m_last_bucket(other.m_last_bucket) {
+    if (!other.empty()) {
+      ::new (static_cast<void*>(std::addressof(m_value)))
+          value_type(other.value());
+      m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
+    }
+  }
+
+  /**
+   * Never really used, but still necessary as we must call resize on an empty
+   * `std::vector<bucket_entry>`. and we need to support move-only types. See
+   * robin_hash constructor for details.
+   */
+  bucket_entry(bucket_entry&& other) noexcept(
+      std::is_nothrow_move_constructible<value_type>::value)
+      : bucket_hash(std::move(other)),
+        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
+        m_last_bucket(other.m_last_bucket) {
+    if (!other.empty()) {
+      ::new (static_cast<void*>(std::addressof(m_value)))
+          value_type(std::move(other.value()));
+      m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
+    }
+  }
+
+  bucket_entry& operator=(const bucket_entry& other) noexcept(
+      std::is_nothrow_copy_constructible<value_type>::value) {
+    if (this != &other) {
+      clear();
+
+      bucket_hash::operator=(other);
+      if (!other.empty()) {
+        ::new (static_cast<void*>(std::addressof(m_value)))
+            value_type(other.value());
+      }
+
+      m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
+      m_last_bucket = other.m_last_bucket;
+    }
+
+    return *this;
+  }
+
+  bucket_entry& operator=(bucket_entry&&) = delete;
+
+  ~bucket_entry() noexcept { clear(); }
+
+  void clear() noexcept {
+    if (!empty()) {
+      destroy_value();
+      m_dist_from_ideal_bucket = EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET;
+    }
+  }
+
+  bool empty() const noexcept {
+    return m_dist_from_ideal_bucket == EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET;
+  }
+
+  value_type& value() noexcept {
+    tsl_rh_assert(!empty());
+    return *reinterpret_cast<value_type*>(std::addressof(m_value));
+  }
+
+  const value_type& value() const noexcept {
+    tsl_rh_assert(!empty());
+    return *reinterpret_cast<const value_type*>(std::addressof(m_value));
+  }
+
+  distance_type dist_from_ideal_bucket() const noexcept {
+    return m_dist_from_ideal_bucket;
+  }
+
+  bool last_bucket() const noexcept { return m_last_bucket; }
+
+  void set_as_last_bucket() noexcept { m_last_bucket = true; }
+
+  template <typename... Args>
+  void set_value_of_empty_bucket(distance_type dist_from_ideal_bucket,
+                                 truncated_hash_type hash,
+                                 Args&&... value_type_args) {
+    tsl_rh_assert(dist_from_ideal_bucket >= 0);
+    tsl_rh_assert(empty());
+
+    ::new (static_cast<void*>(std::addressof(m_value)))
+        value_type(std::forward<Args>(value_type_args)...);
+    this->set_hash(hash);
+    m_dist_from_ideal_bucket = dist_from_ideal_bucket;
+
+    tsl_rh_assert(!empty());
+  }
+
+  void swap_with_value_in_bucket(distance_type& dist_from_ideal_bucket,
+                                 truncated_hash_type& hash, value_type& value) {
+    tsl_rh_assert(!empty());
+
+    using std::swap;
+    swap(value, this->value());
+    swap(dist_from_ideal_bucket, m_dist_from_ideal_bucket);
+
+    if (StoreHash) {
+      const truncated_hash_type tmp_hash = this->truncated_hash();
+      this->set_hash(hash);
+      hash = tmp_hash;
+    } else {
+      // Avoid warning of unused variable if StoreHash is false
+      TSL_RH_UNUSED(hash);
+    }
+  }
+
+  static truncated_hash_type truncate_hash(std::size_t hash) noexcept {
+    return truncated_hash_type(hash);
+  }
+
+ private:
+  void destroy_value() noexcept {
+    tsl_rh_assert(!empty());
+    value().~value_type();
+  }
+
+ public:
+  static const distance_type EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET = -1;
+  static const distance_type DIST_FROM_IDEAL_BUCKET_LIMIT = 4096;
+  static_assert(DIST_FROM_IDEAL_BUCKET_LIMIT <=
+                    std::numeric_limits<distance_type>::max() - 1,
+                "DIST_FROM_IDEAL_BUCKET_LIMIT must be <= "
+                "std::numeric_limits<distance_type>::max() - 1.");
+
+ private:
+  using storage = typename std::aligned_storage<sizeof(value_type),
+                                                alignof(value_type)>::type;
+
+  distance_type m_dist_from_ideal_bucket;
+  bool m_last_bucket;
+  storage m_value;
+};
+
+/**
+ * Internal common class used by `robin_map` and `robin_set`.
+ *
+ * ValueType is what will be stored by `robin_hash` (usually `std::pair<Key, T>`
+ * for map and `Key` for set).
+ *
+ * `KeySelect` should be a `FunctionObject` which takes a `ValueType` in
+ * parameter and returns a reference to the key.
+ *
+ * `ValueSelect` should be a `FunctionObject` which takes a `ValueType` in
+ * parameter and returns a reference to the value. `ValueSelect` should be void
+ * if there is no value (in a set for example).
+ *
+ * The strong exception guarantee only holds if the expression
+ * `std::is_nothrow_swappable<ValueType>::value &&
+ * std::is_nothrow_move_constructible<ValueType>::value` is true.
+ *
+ * Behaviour is undefined if the destructor of `ValueType` throws.
+ */
+template <class ValueType, class KeySelect, class ValueSelect, class Hash,
+          class KeyEqual, class Allocator, bool StoreHash, class GrowthPolicy>
+class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
+ private:
+  template <typename U>
+  using has_mapped_type =
+      typename std::integral_constant<bool, !std::is_same<U, void>::value>;
+
+  static_assert(
+      noexcept(std::declval<GrowthPolicy>().bucket_for_hash(std::size_t(0))),
+      "GrowthPolicy::bucket_for_hash must be noexcept.");
+  static_assert(noexcept(std::declval<GrowthPolicy>().clear()),
+                "GrowthPolicy::clear must be noexcept.");
+
+ public:
+  template <bool IsConst>
+  class robin_iterator;
+
+  using key_type = typename KeySelect::key_type;
+  using value_type = ValueType;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+  using hasher = Hash;
+  using key_equal = KeyEqual;
+  using allocator_type = Allocator;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+  using iterator = robin_iterator<false>;
+  using const_iterator = robin_iterator<true>;
+
+ private:
+  /**
+   * Either store the hash because we are asked by the `StoreHash` template
+   * parameter or store the hash because it doesn't cost us anything in size and
+   * can be used to speed up rehash.
+   */
+  static constexpr bool STORE_HASH =
+      StoreHash ||
+      ((sizeof(tsl::detail_robin_hash::bucket_entry<value_type, true>) ==
+        sizeof(tsl::detail_robin_hash::bucket_entry<value_type, false>)) &&
+       (sizeof(std::size_t) == sizeof(truncated_hash_type) ||
+        is_power_of_two_policy<GrowthPolicy>::value) &&
+       // Don't store the hash for primitive types with default hash.
+       (!std::is_arithmetic<key_type>::value ||
+        !std::is_same<Hash, std::hash<key_type>>::value));
+
+  /**
+   * Only use the stored hash on lookup if we are explicitly asked. We are not
+   * sure how slow the KeyEqual operation is. An extra comparison may slow
+   * things down with a fast KeyEqual.
+   */
+  static constexpr bool USE_STORED_HASH_ON_LOOKUP = StoreHash;
+
+  /**
+   * We can only use the hash on rehash if the size of the hash type is the same
+   * as the stored one or if we use a power of two modulo. In the case of the
+   * power of two modulo, we just mask the least significant bytes, we just have
+   * to check that the truncated_hash_type didn't truncated more bytes.
+   */
+  static bool USE_STORED_HASH_ON_REHASH(size_type bucket_count) {
+    if (STORE_HASH && sizeof(std::size_t) == sizeof(truncated_hash_type)) {
+      TSL_RH_UNUSED(bucket_count);
+      return true;
+    } else if (STORE_HASH && is_power_of_two_policy<GrowthPolicy>::value) {
+      tsl_rh_assert(bucket_count > 0);
+      return (bucket_count - 1) <=
+             std::numeric_limits<truncated_hash_type>::max();
+    } else {
+      TSL_RH_UNUSED(bucket_count);
+      return false;
+    }
+  }
+
+  using bucket_entry =
+      tsl::detail_robin_hash::bucket_entry<value_type, STORE_HASH>;
+  using distance_type = typename bucket_entry::distance_type;
+
+  using buckets_allocator = typename std::allocator_traits<
+      allocator_type>::template rebind_alloc<bucket_entry>;
+  using buckets_container_type = std::vector<bucket_entry, buckets_allocator>;
+
+ public:
+  /**
+   * The 'operator*()' and 'operator->()' methods return a const reference and
+   * const pointer respectively to the stored value type.
+   *
+   * In case of a map, to get a mutable reference to the value associated to a
+   * key (the '.second' in the stored pair), you have to call 'value()'.
+   *
+   * The main reason for this is that if we returned a `std::pair<Key, T>&`
+   * instead of a `const std::pair<Key, T>&`, the user may modify the key which
+   * will put the map in a undefined state.
+   */
+  template <bool IsConst>
+  class robin_iterator {
+    friend class robin_hash;
+
+   private:
+    using bucket_entry_ptr =
+        typename std::conditional<IsConst, const bucket_entry*,
+                                  bucket_entry*>::type;
+
+    robin_iterator(bucket_entry_ptr bucket) noexcept : m_bucket(bucket) {}
+
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const typename robin_hash::value_type;
+    using difference_type = std::ptrdiff_t;
+    using reference = value_type&;
+    using pointer = value_type*;
+
+    robin_iterator() noexcept {}
+
+    // Copy constructor from iterator to const_iterator.
+    template <bool TIsConst = IsConst,
+              typename std::enable_if<TIsConst>::type* = nullptr>
+    robin_iterator(const robin_iterator<!TIsConst>& other) noexcept
+        : m_bucket(other.m_bucket) {}
+
+    robin_iterator(const robin_iterator& other) = default;
+    robin_iterator(robin_iterator&& other) = default;
+    robin_iterator& operator=(const robin_iterator& other) = default;
+    robin_iterator& operator=(robin_iterator&& other) = default;
+
+    const typename robin_hash::key_type& key() const {
+      return KeySelect()(m_bucket->value());
+    }
+
+    template <class U = ValueSelect,
+              typename std::enable_if<has_mapped_type<U>::value &&
+                                      IsConst>::type* = nullptr>
+    const typename U::value_type& value() const {
+      return U()(m_bucket->value());
+    }
+
+    template <class U = ValueSelect,
+              typename std::enable_if<has_mapped_type<U>::value &&
+                                      !IsConst>::type* = nullptr>
+    typename U::value_type& value() const {
+      return U()(m_bucket->value());
+    }
+
+    reference operator*() const { return m_bucket->value(); }
+
+    pointer operator->() const { return std::addressof(m_bucket->value()); }
+
+    robin_iterator& operator++() {
+      while (true) {
+        if (m_bucket->last_bucket()) {
+          ++m_bucket;
+          return *this;
+        }
+
+        ++m_bucket;
+        if (!m_bucket->empty()) {
+          return *this;
+        }
+      }
+    }
+
+    robin_iterator operator++(int) {
+      robin_iterator tmp(*this);
+      ++*this;
+
+      return tmp;
+    }
+
+    friend bool operator==(const robin_iterator& lhs,
+                           const robin_iterator& rhs) {
+      return lhs.m_bucket == rhs.m_bucket;
+    }
+
+    friend bool operator!=(const robin_iterator& lhs,
+                           const robin_iterator& rhs) {
+      return !(lhs == rhs);
+    }
+
+   private:
+    bucket_entry_ptr m_bucket;
+  };
+
+ public:
+#if defined(__cplusplus) && __cplusplus >= 201402L
+  robin_hash(size_type bucket_count, const Hash& hash, const KeyEqual& equal,
+             const Allocator& alloc,
+             float min_load_factor = DEFAULT_MIN_LOAD_FACTOR,
+             float max_load_factor = DEFAULT_MAX_LOAD_FACTOR)
+      : Hash(hash),
+        KeyEqual(equal),
+        GrowthPolicy(bucket_count),
+        m_buckets_data(
+            [&]() {
+              if (bucket_count > max_bucket_count()) {
+                TSL_RH_THROW_OR_TERMINATE(
+                    std::length_error,
+                    "The map exceeds its maximum bucket count.");
+              }
+
+              return bucket_count;
+            }(),
+            alloc),
+        m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
+                                         : m_buckets_data.data()),
+        m_bucket_count(bucket_count),
+        m_nb_elements(0),
+        m_grow_on_next_insert(false),
+        m_try_shrink_on_next_insert(false) {
+    if (m_bucket_count > 0) {
+      tsl_rh_assert(!m_buckets_data.empty());
+      m_buckets_data.back().set_as_last_bucket();
+    }
+
+    this->min_load_factor(min_load_factor);
+    this->max_load_factor(max_load_factor);
+  }
+#else
+  /**
+   * C++11 doesn't support the creation of a std::vector with a custom allocator
+   * and 'count' default-inserted elements. The needed contructor `explicit
+   * vector(size_type count, const Allocator& alloc = Allocator());` is only
+   * available in C++14 and later. We thus must resize after using the
+   * `vector(const Allocator& alloc)` constructor.
+   *
+   * We can't use `vector(size_type count, const T& value, const Allocator&
+   * alloc)` as it requires the value T to be copyable.
+   */
+  robin_hash(size_type bucket_count, const Hash& hash, const KeyEqual& equal,
+             const Allocator& alloc,
+             float min_load_factor = DEFAULT_MIN_LOAD_FACTOR,
+             float max_load_factor = DEFAULT_MAX_LOAD_FACTOR)
+      : Hash(hash),
+        KeyEqual(equal),
+        GrowthPolicy(bucket_count),
+        m_buckets_data(alloc),
+        m_buckets(static_empty_bucket_ptr()),
+        m_bucket_count(bucket_count),
+        m_nb_elements(0),
+        m_grow_on_next_insert(false),
+        m_try_shrink_on_next_insert(false) {
+    if (bucket_count > max_bucket_count()) {
+      TSL_RH_THROW_OR_TERMINATE(std::length_error,
+                                "The map exceeds its maximum bucket count.");
+    }
+
+    if (m_bucket_count > 0) {
+      m_buckets_data.resize(m_bucket_count);
+      m_buckets = m_buckets_data.data();
+
+      tsl_rh_assert(!m_buckets_data.empty());
+      m_buckets_data.back().set_as_last_bucket();
+    }
+
+    this->min_load_factor(min_load_factor);
+    this->max_load_factor(max_load_factor);
+  }
+#endif
+
+  robin_hash(const robin_hash& other)
+      : Hash(other),
+        KeyEqual(other),
+        GrowthPolicy(other),
+        m_buckets_data(other.m_buckets_data),
+        m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
+                                         : m_buckets_data.data()),
+        m_bucket_count(other.m_bucket_count),
+        m_nb_elements(other.m_nb_elements),
+        m_load_threshold(other.m_load_threshold),
+        m_min_load_factor(other.m_min_load_factor),
+        m_max_load_factor(other.m_max_load_factor),
+        m_grow_on_next_insert(other.m_grow_on_next_insert),
+        m_try_shrink_on_next_insert(other.m_try_shrink_on_next_insert) {}
+
+  robin_hash(robin_hash&& other) noexcept(
+      std::is_nothrow_move_constructible<
+          Hash>::value&& std::is_nothrow_move_constructible<KeyEqual>::value&&
+          std::is_nothrow_move_constructible<GrowthPolicy>::value&&
+              std::is_nothrow_move_constructible<buckets_container_type>::value)
+      : Hash(std::move(static_cast<Hash&>(other))),
+        KeyEqual(std::move(static_cast<KeyEqual&>(other))),
+        GrowthPolicy(std::move(static_cast<GrowthPolicy&>(other))),
+        m_buckets_data(std::move(other.m_buckets_data)),
+        m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
+                                         : m_buckets_data.data()),
+        m_bucket_count(other.m_bucket_count),
+        m_nb_elements(other.m_nb_elements),
+        m_load_threshold(other.m_load_threshold),
+        m_min_load_factor(other.m_min_load_factor),
+        m_max_load_factor(other.m_max_load_factor),
+        m_grow_on_next_insert(other.m_grow_on_next_insert),
+        m_try_shrink_on_next_insert(other.m_try_shrink_on_next_insert) {
+    other.clear_and_shrink();
+  }
+
+  robin_hash& operator=(const robin_hash& other) {
+    if (&other != this) {
+      Hash::operator=(other);
+      KeyEqual::operator=(other);
+      GrowthPolicy::operator=(other);
+
+      m_buckets_data = other.m_buckets_data;
+      m_buckets = m_buckets_data.empty() ? static_empty_bucket_ptr()
+                                         : m_buckets_data.data();
+      m_bucket_count = other.m_bucket_count;
+      m_nb_elements = other.m_nb_elements;
+
+      m_load_threshold = other.m_load_threshold;
+      m_min_load_factor = other.m_min_load_factor;
+      m_max_load_factor = other.m_max_load_factor;
+
+      m_grow_on_next_insert = other.m_grow_on_next_insert;
+      m_try_shrink_on_next_insert = other.m_try_shrink_on_next_insert;
+    }
+
+    return *this;
+  }
+
+  robin_hash& operator=(robin_hash&& other) {
+    other.swap(*this);
+    other.clear();
+
+    return *this;
+  }
+
+  allocator_type get_allocator() const {
+    return m_buckets_data.get_allocator();
+  }
+
+  /*
+   * Iterators
+   */
+  iterator begin() noexcept {
+    std::size_t i = 0;
+    while (i < m_bucket_count && m_buckets[i].empty()) {
+      i++;
+    }
+
+    return iterator(m_buckets + i);
+  }
+
+  const_iterator begin() const noexcept { return cbegin(); }
+
+  const_iterator cbegin() const noexcept {
+    std::size_t i = 0;
+    while (i < m_bucket_count && m_buckets[i].empty()) {
+      i++;
+    }
+
+    return const_iterator(m_buckets + i);
+  }
+
+  iterator end() noexcept { return iterator(m_buckets + m_bucket_count); }
+
+  const_iterator end() const noexcept { return cend(); }
+
+  const_iterator cend() const noexcept {
+    return const_iterator(m_buckets + m_bucket_count);
+  }
+
+  /*
+   * Capacity
+   */
+  bool empty() const noexcept { return m_nb_elements == 0; }
+
+  size_type size() const noexcept { return m_nb_elements; }
+
+  size_type max_size() const noexcept { return m_buckets_data.max_size(); }
+
+  /*
+   * Modifiers
+   */
+  void clear() noexcept {
+    if (m_min_load_factor > 0.0f) {
+      clear_and_shrink();
+    } else {
+      for (auto& bucket : m_buckets_data) {
+        bucket.clear();
+      }
+
+      m_nb_elements = 0;
+      m_grow_on_next_insert = false;
+    }
+  }
+
+  template <typename P>
+  std::pair<iterator, bool> insert(P&& value) {
+    return insert_impl(KeySelect()(value), std::forward<P>(value));
+  }
+
+  template <typename P>
+  iterator insert_hint(const_iterator hint, P&& value) {
+    if (hint != cend() &&
+        compare_keys(KeySelect()(*hint), KeySelect()(value))) {
+      return mutable_iterator(hint);
+    }
+
+    return insert(std::forward<P>(value)).first;
+  }
+
+  template <class InputIt>
+  void insert(InputIt first, InputIt last) {
+    if (std::is_base_of<
+            std::forward_iterator_tag,
+            typename std::iterator_traits<InputIt>::iterator_category>::value) {
+      const auto nb_elements_insert = std::distance(first, last);
+      const size_type nb_free_buckets = m_load_threshold - size();
+      tsl_rh_assert(m_load_threshold >= size());
+
+      if (nb_elements_insert > 0 &&
+          nb_free_buckets < size_type(nb_elements_insert)) {
+        reserve(size() + size_type(nb_elements_insert));
+      }
+    }
+
+    for (; first != last; ++first) {
+      insert(*first);
+    }
+  }
+
+  template <class K, class M>
+  std::pair<iterator, bool> insert_or_assign(K&& key, M&& obj) {
+    auto it = try_emplace(std::forward<K>(key), std::forward<M>(obj));
+    if (!it.second) {
+      it.first.value() = std::forward<M>(obj);
+    }
+
+    return it;
+  }
+
+  template <class K, class M>
+  iterator insert_or_assign(const_iterator hint, K&& key, M&& obj) {
+    if (hint != cend() && compare_keys(KeySelect()(*hint), key)) {
+      auto it = mutable_iterator(hint);
+      it.value() = std::forward<M>(obj);
+
+      return it;
+    }
+
+    return insert_or_assign(std::forward<K>(key), std::forward<M>(obj)).first;
+  }
+
+  template <class... Args>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    return insert(value_type(std::forward<Args>(args)...));
+  }
+
+  template <class... Args>
+  iterator emplace_hint(const_iterator hint, Args&&... args) {
+    return insert_hint(hint, value_type(std::forward<Args>(args)...));
+  }
+
+  template <class K, class... Args>
+  std::pair<iterator, bool> try_emplace(K&& key, Args&&... args) {
+    return insert_impl(key, std::piecewise_construct,
+                       std::forward_as_tuple(std::forward<K>(key)),
+                       std::forward_as_tuple(std::forward<Args>(args)...));
+  }
+
+  template <class K, class... Args>
+  iterator try_emplace_hint(const_iterator hint, K&& key, Args&&... args) {
+    if (hint != cend() && compare_keys(KeySelect()(*hint), key)) {
+      return mutable_iterator(hint);
+    }
+
+    return try_emplace(std::forward<K>(key), std::forward<Args>(args)...).first;
+  }
+
+  /**
+   * Here to avoid `template<class K> size_type erase(const K& key)` being used
+   * when we use an `iterator` instead of a `const_iterator`.
+   */
+  iterator erase(iterator pos) {
+    erase_from_bucket(pos);
+
+    /**
+     * Erase bucket used a backward shift after clearing the bucket.
+     * Check if there is a new value in the bucket, if not get the next
+     * non-empty.
+     */
+    if (pos.m_bucket->empty()) {
+      ++pos;
+    }
+
+    m_try_shrink_on_next_insert = true;
+
+    return pos;
+  }
+
+  iterator erase(const_iterator pos) { return erase(mutable_iterator(pos)); }
+
+  iterator erase(const_iterator first, const_iterator last) {
+    if (first == last) {
+      return mutable_iterator(first);
+    }
+
+    auto first_mutable = mutable_iterator(first);
+    auto last_mutable = mutable_iterator(last);
+    for (auto it = first_mutable.m_bucket; it != last_mutable.m_bucket; ++it) {
+      if (!it->empty()) {
+        it->clear();
+        m_nb_elements--;
+      }
+    }
+
+    if (last_mutable == end()) {
+      m_try_shrink_on_next_insert = true;
+      return end();
+    }
+
+    /*
+     * Backward shift on the values which come after the deleted values.
+     * We try to move the values closer to their ideal bucket.
+     */
+    std::size_t icloser_bucket =
+        static_cast<std::size_t>(first_mutable.m_bucket - m_buckets);
+    std::size_t ito_move_closer_value =
+        static_cast<std::size_t>(last_mutable.m_bucket - m_buckets);
+    tsl_rh_assert(ito_move_closer_value > icloser_bucket);
+
+    const std::size_t ireturn_bucket =
+        ito_move_closer_value -
+        std::min(
+            ito_move_closer_value - icloser_bucket,
+            std::size_t(
+                m_buckets[ito_move_closer_value].dist_from_ideal_bucket()));
+
+    while (ito_move_closer_value < m_bucket_count &&
+           m_buckets[ito_move_closer_value].dist_from_ideal_bucket() > 0) {
+      icloser_bucket =
+          ito_move_closer_value -
+          std::min(
+              ito_move_closer_value - icloser_bucket,
+              std::size_t(
+                  m_buckets[ito_move_closer_value].dist_from_ideal_bucket()));
+
+      tsl_rh_assert(m_buckets[icloser_bucket].empty());
+      const distance_type new_distance = distance_type(
+          m_buckets[ito_move_closer_value].dist_from_ideal_bucket() -
+          (ito_move_closer_value - icloser_bucket));
+      m_buckets[icloser_bucket].set_value_of_empty_bucket(
+          new_distance, m_buckets[ito_move_closer_value].truncated_hash(),
+          std::move(m_buckets[ito_move_closer_value].value()));
+      m_buckets[ito_move_closer_value].clear();
+
+      ++icloser_bucket;
+      ++ito_move_closer_value;
+    }
+
+    m_try_shrink_on_next_insert = true;
+
+    return iterator(m_buckets + ireturn_bucket);
+  }
+
+  template <class K>
+  size_type erase(const K& key) {
+    return erase(key, hash_key(key));
+  }
+
+  template <class K>
+  size_type erase(const K& key, std::size_t hash) {
+    auto it = find(key, hash);
+    if (it != end()) {
+      erase_from_bucket(it);
+      m_try_shrink_on_next_insert = true;
+
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  void swap(robin_hash& other) {
+    using std::swap;
+
+    swap(static_cast<Hash&>(*this), static_cast<Hash&>(other));
+    swap(static_cast<KeyEqual&>(*this), static_cast<KeyEqual&>(other));
+    swap(static_cast<GrowthPolicy&>(*this), static_cast<GrowthPolicy&>(other));
+    swap(m_buckets_data, other.m_buckets_data);
+    swap(m_buckets, other.m_buckets);
+    swap(m_bucket_count, other.m_bucket_count);
+    swap(m_nb_elements, other.m_nb_elements);
+    swap(m_load_threshold, other.m_load_threshold);
+    swap(m_min_load_factor, other.m_min_load_factor);
+    swap(m_max_load_factor, other.m_max_load_factor);
+    swap(m_grow_on_next_insert, other.m_grow_on_next_insert);
+    swap(m_try_shrink_on_next_insert, other.m_try_shrink_on_next_insert);
+  }
+
+  /*
+   * Lookup
+   */
+  template <class K, class U = ValueSelect,
+            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+  typename U::value_type& at(const K& key) {
+    return at(key, hash_key(key));
+  }
+
+  template <class K, class U = ValueSelect,
+            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+  typename U::value_type& at(const K& key, std::size_t hash) {
+    return const_cast<typename U::value_type&>(
+        static_cast<const robin_hash*>(this)->at(key, hash));
+  }
+
+  template <class K, class U = ValueSelect,
+            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+  const typename U::value_type& at(const K& key) const {
+    return at(key, hash_key(key));
+  }
+
+  template <class K, class U = ValueSelect,
+            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+  const typename U::value_type& at(const K& key, std::size_t hash) const {
+    auto it = find(key, hash);
+    if (it != cend()) {
+      return it.value();
+    } else {
+      TSL_RH_THROW_OR_TERMINATE(std::out_of_range, "Couldn't find key.");
+    }
+  }
+
+  template <class K, class U = ValueSelect,
+            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+  typename U::value_type& operator[](K&& key) {
+    return try_emplace(std::forward<K>(key)).first.value();
+  }
+
+  template <class K>
+  size_type count(const K& key) const {
+    return count(key, hash_key(key));
+  }
+
+  template <class K>
+  size_type count(const K& key, std::size_t hash) const {
+    if (find(key, hash) != cend()) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  template <class K>
+  iterator find(const K& key) {
+    return find_impl(key, hash_key(key));
+  }
+
+  template <class K>
+  iterator find(const K& key, std::size_t hash) {
+    return find_impl(key, hash);
+  }
+
+  template <class K>
+  const_iterator find(const K& key) const {
+    return find_impl(key, hash_key(key));
+  }
+
+  template <class K>
+  const_iterator find(const K& key, std::size_t hash) const {
+    return find_impl(key, hash);
+  }
+
+  template <class K>
+  bool contains(const K& key) const {
+    return contains(key, hash_key(key));
+  }
+
+  template <class K>
+  bool contains(const K& key, std::size_t hash) const {
+    return count(key, hash) != 0;
+  }
+
+  template <class K>
+  std::pair<iterator, iterator> equal_range(const K& key) {
+    return equal_range(key, hash_key(key));
+  }
+
+  template <class K>
+  std::pair<iterator, iterator> equal_range(const K& key, std::size_t hash) {
+    iterator it = find(key, hash);
+    return std::make_pair(it, (it == end()) ? it : std::next(it));
+  }
+
+  template <class K>
+  std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
+    return equal_range(key, hash_key(key));
+  }
+
+  template <class K>
+  std::pair<const_iterator, const_iterator> equal_range(
+      const K& key, std::size_t hash) const {
+    const_iterator it = find(key, hash);
+    return std::make_pair(it, (it == cend()) ? it : std::next(it));
+  }
+
+  /*
+   * Bucket interface
+   */
+  size_type bucket_count() const { return m_bucket_count; }
+
+  size_type max_bucket_count() const {
+    return std::min(GrowthPolicy::max_bucket_count(),
+                    m_buckets_data.max_size());
+  }
+
+  /*
+   * Hash policy
+   */
+  float load_factor() const {
+    if (bucket_count() == 0) {
+      return 0;
+    }
+
+    return float(m_nb_elements) / float(bucket_count());
+  }
+
+  float min_load_factor() const { return m_min_load_factor; }
+
+  float max_load_factor() const { return m_max_load_factor; }
+
+  void min_load_factor(float ml) {
+    m_min_load_factor = clamp(ml, float(MINIMUM_MIN_LOAD_FACTOR),
+                              float(MAXIMUM_MIN_LOAD_FACTOR));
+  }
+
+  void max_load_factor(float ml) {
+    m_max_load_factor = clamp(ml, float(MINIMUM_MAX_LOAD_FACTOR),
+                              float(MAXIMUM_MAX_LOAD_FACTOR));
+    m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
+  }
+
+  void rehash(size_type count_) {
+    count_ = std::max(count_,
+                     size_type(std::ceil(float(size()) / max_load_factor())));
+    rehash_impl(count_);
+  }
+
+  void reserve(size_type count_) {
+    rehash(size_type(std::ceil(float(count_) / max_load_factor())));
+  }
+
+  /*
+   * Observers
+   */
+  hasher hash_function() const { return static_cast<const Hash&>(*this); }
+
+  key_equal key_eq() const { return static_cast<const KeyEqual&>(*this); }
+
+  /*
+   * Other
+   */
+  iterator mutable_iterator(const_iterator pos) {
+    return iterator(const_cast<bucket_entry*>(pos.m_bucket));
+  }
+
+  template <class Serializer>
+  void serialize(Serializer& serializer) const {
+    serialize_impl(serializer);
+  }
+
+  template <class Deserializer>
+  void deserialize(Deserializer& deserializer, bool hash_compatible) {
+    deserialize_impl(deserializer, hash_compatible);
+  }
+
+ private:
+  template <class K>
+  std::size_t hash_key(const K& key) const {
+    return Hash::operator()(key);
+  }
+
+  template <class K1, class K2>
+  bool compare_keys(const K1& key1, const K2& key2) const {
+    return KeyEqual::operator()(key1, key2);
+  }
+
+  std::size_t bucket_for_hash(std::size_t hash) const {
+    const std::size_t bucket = GrowthPolicy::bucket_for_hash(hash);
+    tsl_rh_assert(bucket < m_bucket_count ||
+                  (bucket == 0 && m_bucket_count == 0));
+
+    return bucket;
+  }
+
+  template <class U = GrowthPolicy,
+            typename std::enable_if<is_power_of_two_policy<U>::value>::type* =
+                nullptr>
+  std::size_t next_bucket(std::size_t index) const noexcept {
+    tsl_rh_assert(index < bucket_count());
+
+    return (index + 1) & this->m_mask;
+  }
+
+  template <class U = GrowthPolicy,
+            typename std::enable_if<!is_power_of_two_policy<U>::value>::type* =
+                nullptr>
+  std::size_t next_bucket(std::size_t index) const noexcept {
+    tsl_rh_assert(index < bucket_count());
+
+    index++;
+    return (index != bucket_count()) ? index : 0;
+  }
+
+  template <class K>
+  iterator find_impl(const K& key, std::size_t hash) {
+    return mutable_iterator(
+        static_cast<const robin_hash*>(this)->find(key, hash));
+  }
+
+  template <class K>
+  const_iterator find_impl(const K& key, std::size_t hash) const {
+    std::size_t ibucket = bucket_for_hash(hash);
+    distance_type dist_from_ideal_bucket = 0;
+
+    while (dist_from_ideal_bucket <=
+           m_buckets[ibucket].dist_from_ideal_bucket()) {
+      if (TSL_RH_LIKELY(
+              (!USE_STORED_HASH_ON_LOOKUP ||
+               m_buckets[ibucket].bucket_hash_equal(hash)) &&
+              compare_keys(KeySelect()(m_buckets[ibucket].value()), key))) {
+        return const_iterator(m_buckets + ibucket);
+      }
+
+      ibucket = next_bucket(ibucket);
+      dist_from_ideal_bucket++;
+    }
+
+    return cend();
+  }
+
+  void erase_from_bucket(iterator pos) {
+    pos.m_bucket->clear();
+    m_nb_elements--;
+
+    /**
+     * Backward shift, swap the empty bucket, previous_ibucket, with the values
+     * on its right, ibucket, until we cross another empty bucket or if the
+     * other bucket has a distance_from_ideal_bucket == 0.
+     *
+     * We try to move the values closer to their ideal bucket.
+     */
+    std::size_t previous_ibucket =
+        static_cast<std::size_t>(pos.m_bucket - m_buckets);
+    std::size_t ibucket = next_bucket(previous_ibucket);
+
+    while (m_buckets[ibucket].dist_from_ideal_bucket() > 0) {
+      tsl_rh_assert(m_buckets[previous_ibucket].empty());
+
+      const distance_type new_distance =
+          distance_type(m_buckets[ibucket].dist_from_ideal_bucket() - 1);
+      m_buckets[previous_ibucket].set_value_of_empty_bucket(
+          new_distance, m_buckets[ibucket].truncated_hash(),
+          std::move(m_buckets[ibucket].value()));
+      m_buckets[ibucket].clear();
+
+      previous_ibucket = ibucket;
+      ibucket = next_bucket(ibucket);
+    }
+  }
+
+  template <class K, class... Args>
+  std::pair<iterator, bool> insert_impl(const K& key,
+                                        Args&&... value_type_args) {
+    const std::size_t hash = hash_key(key);
+
+    std::size_t ibucket = bucket_for_hash(hash);
+    distance_type dist_from_ideal_bucket = 0;
+
+    while (dist_from_ideal_bucket <=
+           m_buckets[ibucket].dist_from_ideal_bucket()) {
+      if ((!USE_STORED_HASH_ON_LOOKUP ||
+           m_buckets[ibucket].bucket_hash_equal(hash)) &&
+          compare_keys(KeySelect()(m_buckets[ibucket].value()), key)) {
+        return std::make_pair(iterator(m_buckets + ibucket), false);
+      }
+
+      ibucket = next_bucket(ibucket);
+      dist_from_ideal_bucket++;
+    }
+
+    if (rehash_on_extreme_load()) {
+      ibucket = bucket_for_hash(hash);
+      dist_from_ideal_bucket = 0;
+
+      while (dist_from_ideal_bucket <=
+             m_buckets[ibucket].dist_from_ideal_bucket()) {
+        ibucket = next_bucket(ibucket);
+        dist_from_ideal_bucket++;
+      }
+    }
+
+    if (m_buckets[ibucket].empty()) {
+      m_buckets[ibucket].set_value_of_empty_bucket(
+          dist_from_ideal_bucket, bucket_entry::truncate_hash(hash),
+          std::forward<Args>(value_type_args)...);
+    } else {
+      insert_value(ibucket, dist_from_ideal_bucket,
+                   bucket_entry::truncate_hash(hash),
+                   std::forward<Args>(value_type_args)...);
+    }
+
+    m_nb_elements++;
+    /*
+     * The value will be inserted in ibucket in any case, either because it was
+     * empty or by stealing the bucket (robin hood).
+     */
+    return std::make_pair(iterator(m_buckets + ibucket), true);
+  }
+
+  template <class... Args>
+  void insert_value(std::size_t ibucket, distance_type dist_from_ideal_bucket,
+                    truncated_hash_type hash, Args&&... value_type_args) {
+    value_type value(std::forward<Args>(value_type_args)...);
+    insert_value_impl(ibucket, dist_from_ideal_bucket, hash, value);
+  }
+
+  void insert_value(std::size_t ibucket, distance_type dist_from_ideal_bucket,
+                    truncated_hash_type hash, value_type&& value) {
+    insert_value_impl(ibucket, dist_from_ideal_bucket, hash, value);
+  }
+
+  /*
+   * We don't use `value_type&& value` as last argument due to a bug in MSVC
+   * when `value_type` is a pointer, The compiler is not able to see the
+   * difference between `std::string*` and `std::string*&&` resulting in a
+   * compilation error.
+   *
+   * The `value` will be in a moved state at the end of the function.
+   */
+  void insert_value_impl(std::size_t ibucket,
+                         distance_type dist_from_ideal_bucket,
+                         truncated_hash_type hash, value_type& value) {
+    m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash,
+                                                 value);
+    ibucket = next_bucket(ibucket);
+    dist_from_ideal_bucket++;
+
+    while (!m_buckets[ibucket].empty()) {
+      if (dist_from_ideal_bucket >
+          m_buckets[ibucket].dist_from_ideal_bucket()) {
+        if (dist_from_ideal_bucket >=
+            bucket_entry::DIST_FROM_IDEAL_BUCKET_LIMIT) {
+          /**
+           * The number of probes is really high, rehash the map on the next
+           * insert. Difficult to do now as rehash may throw an exception.
+           */
+          m_grow_on_next_insert = true;
+        }
+
+        m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket,
+                                                     hash, value);
+      }
+
+      ibucket = next_bucket(ibucket);
+      dist_from_ideal_bucket++;
+    }
+
+    m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket, hash,
+                                                 std::move(value));
+  }
+
+  void rehash_impl(size_type count_) {
+    robin_hash new_table(count_, static_cast<Hash&>(*this),
+                         static_cast<KeyEqual&>(*this), get_allocator(),
+                         m_min_load_factor, m_max_load_factor);
+
+    const bool use_stored_hash =
+        USE_STORED_HASH_ON_REHASH(new_table.bucket_count());
+    for (auto& bucket : m_buckets_data) {
+      if (bucket.empty()) {
+        continue;
+      }
+
+      const std::size_t hash =
+          use_stored_hash ? bucket.truncated_hash()
+                          : new_table.hash_key(KeySelect()(bucket.value()));
+
+      new_table.insert_value_on_rehash(new_table.bucket_for_hash(hash), 0,
+                                       bucket_entry::truncate_hash(hash),
+                                       std::move(bucket.value()));
+    }
+
+    new_table.m_nb_elements = m_nb_elements;
+    new_table.swap(*this);
+  }
+
+  void clear_and_shrink() noexcept {
+    GrowthPolicy::clear();
+    m_buckets_data.clear();
+    m_buckets = static_empty_bucket_ptr();
+    m_bucket_count = 0;
+    m_nb_elements = 0;
+    m_load_threshold = 0;
+    m_grow_on_next_insert = false;
+    m_try_shrink_on_next_insert = false;
+  }
+
+  void insert_value_on_rehash(std::size_t ibucket,
+                              distance_type dist_from_ideal_bucket,
+                              truncated_hash_type hash, value_type&& value) {
+    while (true) {
+      if (dist_from_ideal_bucket >
+          m_buckets[ibucket].dist_from_ideal_bucket()) {
+        if (m_buckets[ibucket].empty()) {
+          m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket,
+                                                       hash, std::move(value));
+          return;
+        } else {
+          m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket,
+                                                       hash, value);
+        }
+      }
+
+      dist_from_ideal_bucket++;
+      ibucket = next_bucket(ibucket);
+    }
+  }
+
+  /**
+   * Grow the table if m_grow_on_next_insert is true or we reached the
+   * max_load_factor. Shrink the table if m_try_shrink_on_next_insert is true
+   * (an erase occurred) and we're below the min_load_factor.
+   *
+   * Return true if the table has been rehashed.
+   */
+  bool rehash_on_extreme_load() {
+    if (m_grow_on_next_insert || size() >= m_load_threshold) {
+      rehash_impl(GrowthPolicy::next_bucket_count());
+      m_grow_on_next_insert = false;
+
+      return true;
+    }
+
+    if (m_try_shrink_on_next_insert) {
+      m_try_shrink_on_next_insert = false;
+      if (m_min_load_factor != 0.0f && load_factor() < m_min_load_factor) {
+        reserve(size() + 1);
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  template <class Serializer>
+  void serialize_impl(Serializer& serializer) const {
+    const slz_size_type version = SERIALIZATION_PROTOCOL_VERSION;
+    serializer(version);
+
+    // Indicate if the truncated hash of each bucket is stored. Use a
+    // std::int16_t instead of a bool to avoid the need for the serializer to
+    // support an extra 'bool' type.
+    const std::int16_t hash_stored_for_bucket =
+        static_cast<std::int16_t>(STORE_HASH);
+    serializer(hash_stored_for_bucket);
+
+    const slz_size_type nb_elements = m_nb_elements;
+    serializer(nb_elements);
+
+    const slz_size_type bucket_count = m_buckets_data.size();
+    serializer(bucket_count);
+
+    const float min_load_factor = m_min_load_factor;
+    serializer(min_load_factor);
+
+    const float max_load_factor = m_max_load_factor;
+    serializer(max_load_factor);
+
+    for (const bucket_entry& bucket : m_buckets_data) {
+      if (bucket.empty()) {
+        const std::int16_t empty_bucket =
+            bucket_entry::EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET;
+        serializer(empty_bucket);
+      } else {
+        const std::int16_t dist_from_ideal_bucket =
+            bucket.dist_from_ideal_bucket();
+        serializer(dist_from_ideal_bucket);
+        if (STORE_HASH) {
+          const std::uint32_t truncated_hash = bucket.truncated_hash();
+          serializer(truncated_hash);
+        }
+        serializer(bucket.value());
+      }
+    }
+  }
+
+  template <class Deserializer>
+  void deserialize_impl(Deserializer& deserializer, bool hash_compatible) {
+    tsl_rh_assert(m_buckets_data.empty());  // Current hash table must be empty
+
+    const slz_size_type version =
+        deserialize_value<slz_size_type>(deserializer);
+    // For now we only have one version of the serialization protocol.
+    // If it doesn't match there is a problem with the file.
+    if (version != SERIALIZATION_PROTOCOL_VERSION) {
+      TSL_RH_THROW_OR_TERMINATE(std::runtime_error,
+                                "Can't deserialize the ordered_map/set. "
+                                "The protocol version header is invalid.");
+    }
+
+    const bool hash_stored_for_bucket =
+        deserialize_value<std::int16_t>(deserializer) ? true : false;
+    if (hash_compatible && STORE_HASH != hash_stored_for_bucket) {
+      TSL_RH_THROW_OR_TERMINATE(
+          std::runtime_error,
+          "Can't deserialize a map with a different StoreHash "
+          "than the one used during the serialization when "
+          "hash compatibility is used");
+    }
+
+    const slz_size_type nb_elements =
+        deserialize_value<slz_size_type>(deserializer);
+    const slz_size_type bucket_count_ds =
+        deserialize_value<slz_size_type>(deserializer);
+    const float min_load_factor = deserialize_value<float>(deserializer);
+    const float max_load_factor = deserialize_value<float>(deserializer);
+
+    if (min_load_factor < MINIMUM_MIN_LOAD_FACTOR ||
+        min_load_factor > MAXIMUM_MIN_LOAD_FACTOR) {
+      TSL_RH_THROW_OR_TERMINATE(
+          std::runtime_error,
+          "Invalid min_load_factor. Check that the serializer "
+          "and deserializer support floats correctly as they "
+          "can be converted implicitly to ints.");
+    }
+
+    if (max_load_factor < MINIMUM_MAX_LOAD_FACTOR ||
+        max_load_factor > MAXIMUM_MAX_LOAD_FACTOR) {
+      TSL_RH_THROW_OR_TERMINATE(
+          std::runtime_error,
+          "Invalid max_load_factor. Check that the serializer "
+          "and deserializer support floats correctly as they "
+          "can be converted implicitly to ints.");
+    }
+
+    this->min_load_factor(min_load_factor);
+    this->max_load_factor(max_load_factor);
+
+    if (bucket_count_ds == 0) {
+      tsl_rh_assert(nb_elements == 0);
+      return;
+    }
+
+    if (!hash_compatible) {
+      reserve(numeric_cast<size_type>(nb_elements,
+                                      "Deserialized nb_elements is too big."));
+      for (slz_size_type ibucket = 0; ibucket < bucket_count_ds; ibucket++) {
+        const distance_type dist_from_ideal_bucket =
+            deserialize_value<std::int16_t>(deserializer);
+        if (dist_from_ideal_bucket !=
+            bucket_entry::EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET) {
+          if (hash_stored_for_bucket) {
+            TSL_RH_UNUSED(deserialize_value<std::uint32_t>(deserializer));
+          }
+
+          insert(deserialize_value<value_type>(deserializer));
+        }
+      }
+
+      tsl_rh_assert(nb_elements == size());
+    } else {
+      m_bucket_count = numeric_cast<size_type>(
+          bucket_count_ds, "Deserialized bucket_count is too big.");
+
+      GrowthPolicy::operator=(GrowthPolicy(m_bucket_count));
+      // GrowthPolicy should not modify the bucket count we got from
+      // deserialization
+      if (m_bucket_count != bucket_count_ds) {
+        TSL_RH_THROW_OR_TERMINATE(std::runtime_error,
+                                  "The GrowthPolicy is not the same even "
+                                  "though hash_compatible is true.");
+      }
+
+      m_nb_elements = numeric_cast<size_type>(
+          nb_elements, "Deserialized nb_elements is too big.");
+      m_buckets_data.resize(m_bucket_count);
+      m_buckets = m_buckets_data.data();
+
+      for (bucket_entry& bucket : m_buckets_data) {
+        const distance_type dist_from_ideal_bucket =
+            deserialize_value<std::int16_t>(deserializer);
+        if (dist_from_ideal_bucket !=
+            bucket_entry::EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET) {
+          truncated_hash_type truncated_hash = 0;
+          if (hash_stored_for_bucket) {
+            tsl_rh_assert(hash_stored_for_bucket);
+            truncated_hash = deserialize_value<std::uint32_t>(deserializer);
+          }
+
+          bucket.set_value_of_empty_bucket(
+              dist_from_ideal_bucket, truncated_hash,
+              deserialize_value<value_type>(deserializer));
+        }
+      }
+
+      if (!m_buckets_data.empty()) {
+        m_buckets_data.back().set_as_last_bucket();
+      }
+    }
+  }
+
+ public:
+  static const size_type DEFAULT_INIT_BUCKETS_SIZE = 0;
+
+  static constexpr float DEFAULT_MAX_LOAD_FACTOR = 0.5f;
+  static constexpr float MINIMUM_MAX_LOAD_FACTOR = 0.2f;
+  static constexpr float MAXIMUM_MAX_LOAD_FACTOR = 0.95f;
+
+  static constexpr float DEFAULT_MIN_LOAD_FACTOR = 0.0f;
+  static constexpr float MINIMUM_MIN_LOAD_FACTOR = 0.0f;
+  static constexpr float MAXIMUM_MIN_LOAD_FACTOR = 0.15f;
+
+  static_assert(MINIMUM_MAX_LOAD_FACTOR < MAXIMUM_MAX_LOAD_FACTOR,
+                "MINIMUM_MAX_LOAD_FACTOR should be < MAXIMUM_MAX_LOAD_FACTOR");
+  static_assert(MINIMUM_MIN_LOAD_FACTOR < MAXIMUM_MIN_LOAD_FACTOR,
+                "MINIMUM_MIN_LOAD_FACTOR should be < MAXIMUM_MIN_LOAD_FACTOR");
+  static_assert(MAXIMUM_MIN_LOAD_FACTOR < MINIMUM_MAX_LOAD_FACTOR,
+                "MAXIMUM_MIN_LOAD_FACTOR should be < MINIMUM_MAX_LOAD_FACTOR");
+
+ private:
+  /**
+   * Protocol version currenlty used for serialization.
+   */
+  static const slz_size_type SERIALIZATION_PROTOCOL_VERSION = 1;
+
+  /**
+   * Return an always valid pointer to an static empty bucket_entry with
+   * last_bucket() == true.
+   */
+  bucket_entry* static_empty_bucket_ptr() noexcept {
+    static bucket_entry empty_bucket(true);
+    return &empty_bucket;
+  }
+
+ private:
+  buckets_container_type m_buckets_data;
+
+  /**
+   * Points to m_buckets_data.data() if !m_buckets_data.empty() otherwise points
+   * to static_empty_bucket_ptr. This variable is useful to avoid the cost of
+   * checking if m_buckets_data is empty when trying to find an element.
+   *
+   * TODO Remove m_buckets_data and only use a pointer instead of a
+   * pointer+vector to save some space in the robin_hash object. Manage the
+   * Allocator manually.
+   */
+  bucket_entry* m_buckets;
+
+  /**
+   * Used a lot in find, avoid the call to m_buckets_data.size() which is a bit
+   * slower.
+   */
+  size_type m_bucket_count;
+
+  size_type m_nb_elements;
+
+  size_type m_load_threshold;
+
+  float m_min_load_factor;
+  float m_max_load_factor;
+
+  bool m_grow_on_next_insert;
+
+  /**
+   * We can't shrink down the map on erase operations as the erase methods need
+   * to return the next iterator. Shrinking the map would invalidate all the
+   * iterators and we could not return the next iterator in a meaningful way, On
+   * erase, we thus just indicate on erase that we should try to shrink the hash
+   * table on the next insert if we go below the min_load_factor.
+   */
+  bool m_try_shrink_on_next_insert;
+};
+
+}  // namespace detail_robin_hash
+
+}  // namespace tsl
+
+#endif
diff --git a/benchmarks/external/tsl/robin_map.h b/benchmarks/external/tsl/robin_map.h
new file mode 100644
index 00000000..3de7a59d
--- /dev/null
+++ b/benchmarks/external/tsl/robin_map.h
@@ -0,0 +1,807 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef TSL_ROBIN_MAP_H
+#define TSL_ROBIN_MAP_H
+
+#include <cstddef>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "robin_hash.h"
+
+namespace tsl {
+
+/**
+ * Implementation of a hash map using open-addressing and the robin hood hashing
+ * algorithm with backward shift deletion.
+ *
+ * For operations modifying the hash map (insert, erase, rehash, ...), the
+ * strong exception guarantee is only guaranteed when the expression
+ * `std::is_nothrow_swappable<std::pair<Key, T>>::value &&
+ * std::is_nothrow_move_constructible<std::pair<Key, T>>::value` is true,
+ * otherwise if an exception is thrown during the swap or the move, the hash map
+ * may end up in a undefined state. Per the standard a `Key` or `T` with a
+ * noexcept copy constructor and no move constructor also satisfies the
+ * `std::is_nothrow_move_constructible<std::pair<Key, T>>::value` criterion (and
+ * will thus guarantee the strong exception for the map).
+ *
+ * When `StoreHash` is true, 32 bits of the hash are stored alongside the
+ * values. It can improve the performance during lookups if the `KeyEqual`
+ * function takes time (if it engenders a cache-miss for example) as we then
+ * compare the stored hashes before comparing the keys. When
+ * `tsl::rh::power_of_two_growth_policy` is used as `GrowthPolicy`, it may also
+ * speed-up the rehash process as we can avoid to recalculate the hash. When it
+ * is detected that storing the hash will not incur any memory penalty due to
+ * alignment (i.e. `sizeof(tsl::detail_robin_hash::bucket_entry<ValueType,
+ * true>) == sizeof(tsl::detail_robin_hash::bucket_entry<ValueType, false>)`)
+ * and `tsl::rh::power_of_two_growth_policy` is used, the hash will be stored
+ * even if `StoreHash` is false so that we can speed-up the rehash (but it will
+ * not be used on lookups unless `StoreHash` is true).
+ *
+ * `GrowthPolicy` defines how the map grows and consequently how a hash value is
+ * mapped to a bucket. By default the map uses
+ * `tsl::rh::power_of_two_growth_policy`. This policy keeps the number of
+ * buckets to a power of two and uses a mask to map the hash to a bucket instead
+ * of the slow modulo. Other growth policies are available and you may define
+ * your own growth policy, check `tsl::rh::power_of_two_growth_policy` for the
+ * interface.
+ *
+ * `std::pair<Key, T>` must be swappable.
+ *
+ * `Key` and `T` must be copy and/or move constructible.
+ *
+ * If the destructor of `Key` or `T` throws an exception, the behaviour of the
+ * class is undefined.
+ *
+ * Iterators invalidation:
+ *  - clear, operator=, reserve, rehash: always invalidate the iterators.
+ *  - insert, emplace, emplace_hint, operator[]: if there is an effective
+ * insert, invalidate the iterators.
+ *  - erase: always invalidate the iterators.
+ */
+template <class Key, class T, class Hash = std::hash<Key>,
+          class KeyEqual = std::equal_to<Key>,
+          class Allocator = std::allocator<std::pair<Key, T>>,
+          bool StoreHash = false,
+          class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
+class robin_map {
+ private:
+  template <typename U>
+  using has_is_transparent = tsl::detail_robin_hash::has_is_transparent<U>;
+
+  class KeySelect {
+   public:
+    using key_type = Key;
+
+    const key_type& operator()(const std::pair<Key, T>& key_value) const
+        noexcept {
+      return key_value.first;
+    }
+
+    key_type& operator()(std::pair<Key, T>& key_value) noexcept {
+      return key_value.first;
+    }
+  };
+
+  class ValueSelect {
+   public:
+    using value_type = T;
+
+    const value_type& operator()(const std::pair<Key, T>& key_value) const
+        noexcept {
+      return key_value.second;
+    }
+
+    value_type& operator()(std::pair<Key, T>& key_value) noexcept {
+      return key_value.second;
+    }
+  };
+
+  using ht = detail_robin_hash::robin_hash<std::pair<Key, T>, KeySelect,
+                                           ValueSelect, Hash, KeyEqual,
+                                           Allocator, StoreHash, GrowthPolicy>;
+
+ public:
+  using key_type = typename ht::key_type;
+  using mapped_type = T;
+  using value_type = typename ht::value_type;
+  using size_type = typename ht::size_type;
+  using difference_type = typename ht::difference_type;
+  using hasher = typename ht::hasher;
+  using key_equal = typename ht::key_equal;
+  using allocator_type = typename ht::allocator_type;
+  using reference = typename ht::reference;
+  using const_reference = typename ht::const_reference;
+  using pointer = typename ht::pointer;
+  using const_pointer = typename ht::const_pointer;
+  using iterator = typename ht::iterator;
+  using const_iterator = typename ht::const_iterator;
+
+ public:
+  /*
+   * Constructors
+   */
+  robin_map() : robin_map(ht::DEFAULT_INIT_BUCKETS_SIZE) {}
+
+  explicit robin_map(size_type bucket_count, const Hash& hash = Hash(),
+                     const KeyEqual& equal = KeyEqual(),
+                     const Allocator& alloc = Allocator())
+      : m_ht(bucket_count, hash, equal, alloc) {}
+
+  robin_map(size_type bucket_count, const Allocator& alloc)
+      : robin_map(bucket_count, Hash(), KeyEqual(), alloc) {}
+
+  robin_map(size_type bucket_count, const Hash& hash, const Allocator& alloc)
+      : robin_map(bucket_count, hash, KeyEqual(), alloc) {}
+
+  explicit robin_map(const Allocator& alloc)
+      : robin_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {}
+
+  template <class InputIt>
+  robin_map(InputIt first, InputIt last,
+            size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
+            const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(),
+            const Allocator& alloc = Allocator())
+      : robin_map(bucket_count, hash, equal, alloc) {
+    insert(first, last);
+  }
+
+  template <class InputIt>
+  robin_map(InputIt first, InputIt last, size_type bucket_count,
+            const Allocator& alloc)
+      : robin_map(first, last, bucket_count, Hash(), KeyEqual(), alloc) {}
+
+  template <class InputIt>
+  robin_map(InputIt first, InputIt last, size_type bucket_count,
+            const Hash& hash, const Allocator& alloc)
+      : robin_map(first, last, bucket_count, hash, KeyEqual(), alloc) {}
+
+  robin_map(std::initializer_list<value_type> init,
+            size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
+            const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(),
+            const Allocator& alloc = Allocator())
+      : robin_map(init.begin(), init.end(), bucket_count, hash, equal, alloc) {}
+
+  robin_map(std::initializer_list<value_type> init, size_type bucket_count,
+            const Allocator& alloc)
+      : robin_map(init.begin(), init.end(), bucket_count, Hash(), KeyEqual(),
+                  alloc) {}
+
+  robin_map(std::initializer_list<value_type> init, size_type bucket_count,
+            const Hash& hash, const Allocator& alloc)
+      : robin_map(init.begin(), init.end(), bucket_count, hash, KeyEqual(),
+                  alloc) {}
+
+  robin_map& operator=(std::initializer_list<value_type> ilist) {
+    m_ht.clear();
+
+    m_ht.reserve(ilist.size());
+    m_ht.insert(ilist.begin(), ilist.end());
+
+    return *this;
+  }
+
+  allocator_type get_allocator() const { return m_ht.get_allocator(); }
+
+  /*
+   * Iterators
+   */
+  iterator begin() noexcept { return m_ht.begin(); }
+  const_iterator begin() const noexcept { return m_ht.begin(); }
+  const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
+
+  iterator end() noexcept { return m_ht.end(); }
+  const_iterator end() const noexcept { return m_ht.end(); }
+  const_iterator cend() const noexcept { return m_ht.cend(); }
+
+  /*
+   * Capacity
+   */
+  bool empty() const noexcept { return m_ht.empty(); }
+  size_type size() const noexcept { return m_ht.size(); }
+  size_type max_size() const noexcept { return m_ht.max_size(); }
+
+  /*
+   * Modifiers
+   */
+  void clear() noexcept { m_ht.clear(); }
+
+  std::pair<iterator, bool> insert(const value_type& value) {
+    return m_ht.insert(value);
+  }
+
+  template <class P, typename std::enable_if<std::is_constructible<
+                         value_type, P&&>::value>::type* = nullptr>
+  std::pair<iterator, bool> insert(P&& value) {
+    return m_ht.emplace(std::forward<P>(value));
+  }
+
+  std::pair<iterator, bool> insert(value_type&& value) {
+    return m_ht.insert(std::move(value));
+  }
+
+  iterator insert(const_iterator hint, const value_type& value) {
+    return m_ht.insert_hint(hint, value);
+  }
+
+  template <class P, typename std::enable_if<std::is_constructible<
+                         value_type, P&&>::value>::type* = nullptr>
+  iterator insert(const_iterator hint, P&& value) {
+    return m_ht.emplace_hint(hint, std::forward<P>(value));
+  }
+
+  iterator insert(const_iterator hint, value_type&& value) {
+    return m_ht.insert_hint(hint, std::move(value));
+  }
+
+  template <class InputIt>
+  void insert(InputIt first, InputIt last) {
+    m_ht.insert(first, last);
+  }
+
+  void insert(std::initializer_list<value_type> ilist) {
+    m_ht.insert(ilist.begin(), ilist.end());
+  }
+
+  template <class M>
+  std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) {
+    return m_ht.insert_or_assign(k, std::forward<M>(obj));
+  }
+
+  template <class M>
+  std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) {
+    return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj));
+  }
+
+  template <class M>
+  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
+    return m_ht.insert_or_assign(hint, k, std::forward<M>(obj));
+  }
+
+  template <class M>
+  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
+    return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj));
+  }
+
+  /**
+   * Due to the way elements are stored, emplace will need to move or copy the
+   * key-value once. The method is equivalent to
+   * insert(value_type(std::forward<Args>(args)...));
+   *
+   * Mainly here for compatibility with the std::unordered_map interface.
+   */
+  template <class... Args>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    return m_ht.emplace(std::forward<Args>(args)...);
+  }
+
+  /**
+   * Due to the way elements are stored, emplace_hint will need to move or copy
+   * the key-value once. The method is equivalent to insert(hint,
+   * value_type(std::forward<Args>(args)...));
+   *
+   * Mainly here for compatibility with the std::unordered_map interface.
+   */
+  template <class... Args>
+  iterator emplace_hint(const_iterator hint, Args&&... args) {
+    return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) {
+    return m_ht.try_emplace(k, std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
+    return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
+    return m_ht.try_emplace_hint(hint, k, std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
+    return m_ht.try_emplace_hint(hint, std::move(k),
+                                 std::forward<Args>(args)...);
+  }
+
+  iterator erase(iterator pos) { return m_ht.erase(pos); }
+  iterator erase(const_iterator pos) { return m_ht.erase(pos); }
+  iterator erase(const_iterator first, const_iterator last) {
+    return m_ht.erase(first, last);
+  }
+  size_type erase(const key_type& key) { return m_ht.erase(key); }
+
+  /**
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup to the value if you already have the hash.
+   */
+  size_type erase(const key_type& key, std::size_t precalculated_hash) {
+    return m_ht.erase(key, precalculated_hash);
+  }
+
+  /**
+   * This overload only participates in the overload resolution if the typedef
+   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
+   * to Key.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  size_type erase(const K& key) {
+    return m_ht.erase(key);
+  }
+
+  /**
+   * @copydoc erase(const K& key)
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup to the value if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  size_type erase(const K& key, std::size_t precalculated_hash) {
+    return m_ht.erase(key, precalculated_hash);
+  }
+
+  void swap(robin_map& other) { other.m_ht.swap(m_ht); }
+
+  /*
+   * Lookup
+   */
+  T& at(const Key& key) { return m_ht.at(key); }
+
+  /**
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  T& at(const Key& key, std::size_t precalculated_hash) {
+    return m_ht.at(key, precalculated_hash);
+  }
+
+  const T& at(const Key& key) const { return m_ht.at(key); }
+
+  /**
+   * @copydoc at(const Key& key, std::size_t precalculated_hash)
+   */
+  const T& at(const Key& key, std::size_t precalculated_hash) const {
+    return m_ht.at(key, precalculated_hash);
+  }
+
+  /**
+   * This overload only participates in the overload resolution if the typedef
+   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
+   * to Key.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  T& at(const K& key) {
+    return m_ht.at(key);
+  }
+
+  /**
+   * @copydoc at(const K& key)
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  T& at(const K& key, std::size_t precalculated_hash) {
+    return m_ht.at(key, precalculated_hash);
+  }
+
+  /**
+   * @copydoc at(const K& key)
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  const T& at(const K& key) const {
+    return m_ht.at(key);
+  }
+
+  /**
+   * @copydoc at(const K& key, std::size_t precalculated_hash)
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  const T& at(const K& key, std::size_t precalculated_hash) const {
+    return m_ht.at(key, precalculated_hash);
+  }
+
+  T& operator[](const Key& key) { return m_ht[key]; }
+  T& operator[](Key&& key) { return m_ht[std::move(key)]; }
+
+  size_type count(const Key& key) const { return m_ht.count(key); }
+
+  /**
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  size_type count(const Key& key, std::size_t precalculated_hash) const {
+    return m_ht.count(key, precalculated_hash);
+  }
+
+  /**
+   * This overload only participates in the overload resolution if the typedef
+   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
+   * to Key.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  size_type count(const K& key) const {
+    return m_ht.count(key);
+  }
+
+  /**
+   * @copydoc count(const K& key) const
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  size_type count(const K& key, std::size_t precalculated_hash) const {
+    return m_ht.count(key, precalculated_hash);
+  }
+
+  iterator find(const Key& key) { return m_ht.find(key); }
+
+  /**
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  iterator find(const Key& key, std::size_t precalculated_hash) {
+    return m_ht.find(key, precalculated_hash);
+  }
+
+  const_iterator find(const Key& key) const { return m_ht.find(key); }
+
+  /**
+   * @copydoc find(const Key& key, std::size_t precalculated_hash)
+   */
+  const_iterator find(const Key& key, std::size_t precalculated_hash) const {
+    return m_ht.find(key, precalculated_hash);
+  }
+
+  /**
+   * This overload only participates in the overload resolution if the typedef
+   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
+   * to Key.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  iterator find(const K& key) {
+    return m_ht.find(key);
+  }
+
+  /**
+   * @copydoc find(const K& key)
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  iterator find(const K& key, std::size_t precalculated_hash) {
+    return m_ht.find(key, precalculated_hash);
+  }
+
+  /**
+   * @copydoc find(const K& key)
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  const_iterator find(const K& key) const {
+    return m_ht.find(key);
+  }
+
+  /**
+   * @copydoc find(const K& key)
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  const_iterator find(const K& key, std::size_t precalculated_hash) const {
+    return m_ht.find(key, precalculated_hash);
+  }
+
+  bool contains(const Key& key) const { return m_ht.contains(key); }
+
+  /**
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  bool contains(const Key& key, std::size_t precalculated_hash) const {
+    return m_ht.contains(key, precalculated_hash);
+  }
+
+  /**
+   * This overload only participates in the overload resolution if the typedef
+   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
+   * to Key.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  bool contains(const K& key) const {
+    return m_ht.contains(key);
+  }
+
+  /**
+   * @copydoc contains(const K& key) const
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  bool contains(const K& key, std::size_t precalculated_hash) const {
+    return m_ht.contains(key, precalculated_hash);
+  }
+
+  std::pair<iterator, iterator> equal_range(const Key& key) {
+    return m_ht.equal_range(key);
+  }
+
+  /**
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  std::pair<iterator, iterator> equal_range(const Key& key,
+                                            std::size_t precalculated_hash) {
+    return m_ht.equal_range(key, precalculated_hash);
+  }
+
+  std::pair<const_iterator, const_iterator> equal_range(const Key& key) const {
+    return m_ht.equal_range(key);
+  }
+
+  /**
+   * @copydoc equal_range(const Key& key, std::size_t precalculated_hash)
+   */
+  std::pair<const_iterator, const_iterator> equal_range(
+      const Key& key, std::size_t precalculated_hash) const {
+    return m_ht.equal_range(key, precalculated_hash);
+  }
+
+  /**
+   * This overload only participates in the overload resolution if the typedef
+   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
+   * to Key.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  std::pair<iterator, iterator> equal_range(const K& key) {
+    return m_ht.equal_range(key);
+  }
+
+  /**
+   * @copydoc equal_range(const K& key)
+   *
+   * Use the hash value 'precalculated_hash' instead of hashing the key. The
+   * hash value should be the same as hash_function()(key). Useful to speed-up
+   * the lookup if you already have the hash.
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  std::pair<iterator, iterator> equal_range(const K& key,
+                                            std::size_t precalculated_hash) {
+    return m_ht.equal_range(key, precalculated_hash);
+  }
+
+  /**
+   * @copydoc equal_range(const K& key)
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
+    return m_ht.equal_range(key);
+  }
+
+  /**
+   * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
+   */
+  template <
+      class K, class KE = KeyEqual,
+      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  std::pair<const_iterator, const_iterator> equal_range(
+      const K& key, std::size_t precalculated_hash) const {
+    return m_ht.equal_range(key, precalculated_hash);
+  }
+
+  /*
+   * Bucket interface
+   */
+  size_type bucket_count() const { return m_ht.bucket_count(); }
+  size_type max_bucket_count() const { return m_ht.max_bucket_count(); }
+
+  /*
+   *  Hash policy
+   */
+  float load_factor() const { return m_ht.load_factor(); }
+
+  float min_load_factor() const { return m_ht.min_load_factor(); }
+  float max_load_factor() const { return m_ht.max_load_factor(); }
+
+  /**
+   * Set the `min_load_factor` to `ml`. When the `load_factor` of the map goes
+   * below `min_load_factor` after some erase operations, the map will be
+   * shrunk when an insertion occurs. The erase method itself never shrinks
+   * the map.
+   *
+   * The default value of `min_load_factor` is 0.0f, the map never shrinks by
+   * default.
+   */
+  void min_load_factor(float ml) { m_ht.min_load_factor(ml); }
+  void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
+
+  void rehash(size_type count_) { m_ht.rehash(count_); }
+  void reserve(size_type count_) { m_ht.reserve(count_); }
+
+  /*
+   * Observers
+   */
+  hasher hash_function() const { return m_ht.hash_function(); }
+  key_equal key_eq() const { return m_ht.key_eq(); }
+
+  /*
+   * Other
+   */
+
+  /**
+   * Convert a const_iterator to an iterator.
+   */
+  iterator mutable_iterator(const_iterator pos) {
+    return m_ht.mutable_iterator(pos);
+  }
+
+  /**
+   * Serialize the map through the `serializer` parameter.
+   *
+   * The `serializer` parameter must be a function object that supports the
+   * following call:
+   *  - `template<typename U> void operator()(const U& value);` where the types
+   * `std::int16_t`, `std::uint32_t`, `std::uint64_t`, `float` and
+   * `std::pair<Key, T>` must be supported for U.
+   *
+   * The implementation leaves binary compatibility (endianness, IEEE 754 for
+   * floats, ...) of the types it serializes in the hands of the `Serializer`
+   * function object if compatibility is required.
+   */
+  template <class Serializer>
+  void serialize(Serializer& serializer) const {
+    m_ht.serialize(serializer);
+  }
+
+  /**
+   * Deserialize a previously serialized map through the `deserializer`
+   * parameter.
+   *
+   * The `deserializer` parameter must be a function object that supports the
+   * following call:
+   *  - `template<typename U> U operator()();` where the types `std::int16_t`,
+   * `std::uint32_t`, `std::uint64_t`, `float` and `std::pair<Key, T>` must be
+   * supported for U.
+   *
+   * If the deserialized hash map type is hash compatible with the serialized
+   * map, the deserialization process can be sped up by setting
+   * `hash_compatible` to true. To be hash compatible, the Hash, KeyEqual and
+   * GrowthPolicy must behave the same way than the ones used on the serialized
+   * map and the StoreHash must have the same value. The `std::size_t` must also
+   * be of the same size as the one on the platform used to serialize the map.
+   * If these criteria are not met, the behaviour is undefined with
+   * `hash_compatible` sets to true.
+   *
+   * The behaviour is undefined if the type `Key` and `T` of the `robin_map` are
+   * not the same as the types used during serialization.
+   *
+   * The implementation leaves binary compatibility (endianness, IEEE 754 for
+   * floats, size of int, ...) of the types it deserializes in the hands of the
+   * `Deserializer` function object if compatibility is required.
+   */
+  template <class Deserializer>
+  static robin_map deserialize(Deserializer& deserializer,
+                               bool hash_compatible = false) {
+    robin_map map(0);
+    map.m_ht.deserialize(deserializer, hash_compatible);
+
+    return map;
+  }
+
+  friend bool operator==(const robin_map& lhs, const robin_map& rhs) {
+    if (lhs.size() != rhs.size()) {
+      return false;
+    }
+
+    for (const auto& element_lhs : lhs) {
+      const auto it_element_rhs = rhs.find(element_lhs.first);
+      if (it_element_rhs == rhs.cend() ||
+          element_lhs.second != it_element_rhs->second) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  friend bool operator!=(const robin_map& lhs, const robin_map& rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+  friend void swap(robin_map& lhs, robin_map& rhs) { lhs.swap(rhs); }
+
+ private:
+  ht m_ht;
+};
+
+/**
+ * Same as `tsl::robin_map<Key, T, Hash, KeyEqual, Allocator, StoreHash,
+ * tsl::rh::prime_growth_policy>`.
+ */
+template <class Key, class T, class Hash = std::hash<Key>,
+          class KeyEqual = std::equal_to<Key>,
+          class Allocator = std::allocator<std::pair<Key, T>>,
+          bool StoreHash = false>
+using robin_pg_map = robin_map<Key, T, Hash, KeyEqual, Allocator, StoreHash,
+                               tsl::rh::prime_growth_policy>;
+
+}  // end namespace tsl
+
+#endif
diff --git a/benchmarks/others/update.sh b/benchmarks/external/update.sh
index 1ac8ad91..c0169fab 100644
--- a/benchmarks/others/update.sh
+++ b/benchmarks/external/update.sh
@@ -1,5 +1,6 @@
 tsl_h="https://raw.github.com/Tessil/hopscotch-map/master/include/tsl/"
 tsl_r="https://raw.github.com/Tessil/robin-map/master/include/tsl/"
+tsl_s="https://raw.github.com/Tessil/sparse-map/master/include/tsl/"
 greg="https://raw.github.com/greg7mdp/sparsepp/master/sparsepp/"
 martinus="https://raw.github.com/martinus/robin-hood-hashing/master/src/include/"
 skarupke="https://raw.github.com/skarupke/flat_hash_map/master/"
@@ -28,3 +29,7 @@ wget $tsl_h"hopscotch_map.h"           -O "tsl/hopscotch_map.h"
 wget $tsl_r"robin_growth_policy.h" -O "tsl/robin_growth_policy.h"
 wget $tsl_r"robin_hash.h"          -O "tsl/robin_hash.h"
 wget $tsl_r"robin_map.h"           -O "tsl/robin_map.h"
+
+#wget $tsl_s"sparse_growth_policy.h" -O "tsl/sparse_growth_policy.h"
+#wget $tsl_s"sparse_hash.h"          -O "tsl/sparse_hash.h"
+#wget $tsl_s"sparse_map.h"           -O "tsl/sparse_map.h"
diff --git a/benchmarks/names.txt b/benchmarks/misc/names.txt
index 561acbbf..561acbbf 100644
--- a/benchmarks/names.txt
+++ b/benchmarks/misc/names.txt
diff --git a/benchmarks/shootout4_crand.cpp b/benchmarks/misc/prng_bench.cpp
index e3524766..e3524766 100644
--- a/benchmarks/shootout4_crand.cpp
+++ b/benchmarks/misc/prng_bench.cpp
diff --git a/benchmarks/rust_cmap.c b/benchmarks/misc/rust_cmap.c
index 6014b23d..88dfbec1 100644
--- a/benchmarks/rust_cmap.c
+++ b/benchmarks/misc/rust_cmap.c
@@ -27,7 +27,6 @@ int main() {
         c_forrange (n) {

             uint64_t key = romu_trio(rng) & mask;

             cmap_u64_insert(&m, key, 0).ref->second += 1;

-            

         }

         printf("insert  : %zums  \tsize : %zu\n", (clock() - now)/ms, cmap_u64_size(m));

         now = clock();

diff --git a/benchmarks/rust_hashmap.rs b/benchmarks/misc/rust_hashmap.rs
index 8e9a5250..2e042449 100644
--- a/benchmarks/rust_hashmap.rs
+++ b/benchmarks/misc/rust_hashmap.rs
@@ -88,4 +88,4 @@ fn main() {
     println!("remove  : {}ms  \tsize : {}", now.elapsed().as_millis(), m.len());
     println!("press a key:");
     std::io::stdin().bytes().next();
-}
+}
\ No newline at end of file
diff --git a/benchmarks/string_bench.c b/benchmarks/misc/string_bench.c
index 8e639aa2..28777e8d 100644
--- a/benchmarks/string_bench.c
+++ b/benchmarks/misc/string_bench.c
@@ -33,6 +33,8 @@ void initShortStringVec(cvec_str* vs)
     size_t lengths = 0;

     c_foreach (i, cvec_str, *vs)

     {

+        cstr_append_s(i.ref, *i.ref);

+        cstr_append_s(i.ref, *i.ref);

         lengths += cstr_size(*i.ref);

     }

     printf("avg len: %f\n", (float)lengths / cvec_str_size(*vs));

@@ -44,17 +46,17 @@ void initLongStringVec(cvec_str* vs)
     *vs = read_file("names.txt");

     cstr* s = vs->data;

     size_t lengths = 0;

-    cstr_append(s, s[1].str);

-    cstr_append(s, s[2].str);

-    cstr_append(s, s[3].str);

+    cstr_append_s(s, s[1]);

+    cstr_append_s(s, s[2]);

+    cstr_append_s(s, s[3]);

     for (int i=1; i < cvec_str_size(*vs); ++i)

     {

         cstr* t = vs->data + i;

-        cstr_append(t, t->str);

-        cstr_append(t, t->str);

-        cstr_append(t, s->str);

-        cstr_append(t, t->str);

-        cstr_append(t, t->str);

+        cstr_append_s(t, *t);

+        cstr_append_s(t, *t);

+        cstr_append_s(t, *s);

+        cstr_append_s(t, *t);

+        cstr_append_s(t, *t);

         lengths += cstr_size(*t);

     }

     printf("avg len: %f\n", (float)lengths / cvec_str_size(*vs));

diff --git a/benchmarks/string_bench.cpp b/benchmarks/misc/string_bench.cpp
index 37db0201..37db0201 100644
--- a/benchmarks/string_bench.cpp
+++ b/benchmarks/misc/string_bench.cpp
diff --git a/benchmarks/others/old/carray_v1.h b/benchmarks/others/old/carray_v1.h
deleted file mode 100644
index c4f294cf..00000000
--- a/benchmarks/others/old/carray_v1.h
+++ /dev/null
@@ -1,215 +0,0 @@
-/* MIT License

- *

- * Copyright (c) 2021 Tyge Løvset, NORCE, www.norceresearch.no

- *

- * Permission is hereby granted, free of charge, to any person obtaining a copy

- * of this software and associated documentation files (the "Software"), to deal

- * in the Software without restriction, including without limitation the rights

- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

- * copies of the Software, and to permit persons to whom the Software is

- * furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice shall be included in all

- * copies or substantial portions of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-#ifndef CARRAY_H_INCLUDED

-#define CARRAY_H_INCLUDED

-

-#include <stdlib.h>

-#include "ccommon.h"

-

-/*

- Multi-dimensional generic array allocated as one block of heap-memory.

- // demo:

-#include <stdio.h>

-#include "stc/carray.h"

-using_carray3(f, float);

-

-int main()

-{

-    carray3f a3 = carray3f_init(30, 20, 10, 0.0f);

-    *carray3f_at(&a3, 5, 4, 3) = 10.2f;         // a3[5][4][3]

-    carray2f a2 = carray3f_at1(&a3, 5);         // sub-array reference: a2 = a3[5]

-    printf("%g\n", *carray2f_at(&a2, 4, 3));    // lookup a2[4][3] (=10.2f)

-    printf("%g\n", *carray3f_at(&a3, 5, 4, 3)); // same data location, via a3 array.

-

-    carray2f_del(&a2); // does nothing, since it is a sub-array.

-    carray3f_del(&a3); // destroy a3, invalidates a2.

-}

-*/

-

-#define using_carray2(...) c_MACRO_OVERLOAD(using_carray2, __VA_ARGS__)

-

-#define using_carray2_2(X, Value) \

-    using_carray2_4(X, Value, c_default_del, c_default_fromraw)

-

-#define using_carray2_4(X, Value, valueDel, valueClone) \

-\

-    typedef Value carray1##X##_value, carray2##X##_value; \

-\

-    typedef struct { \

-        carray1##X##_value *data; \

-        size_t _xdim; \

-    } carray1##X; \

-\

-    typedef struct { \

-        carray2##X##_value *data; \

-        size_t _xdim, _ydim; \

-    } carray2##X; \

-\

-    STC_INLINE size_t \

-    carray1##X##_size(carray1##X a) {return _carray_xdim(a);} \

-    STC_INLINE size_t \

-    carray2##X##_size(carray2##X a) {return _carray_xdim(a)*_carray_ydim(a);} \

-    STC_INLINE size_t \

-    carray2##X##_ydim(carray2##X a) {return _carray_ydim(a);} \

-\

-    _using_carray_common(1, X, Value, valueDel, valueClone) \

-    _using_carray_common(2, X, Value, valueDel, valueClone) \

-\

-    STC_INLINE carray1##X \

-    carray1##X##_init(size_t xdim, Value val) { \

-        carray1##X##_value* m = c_new_n(carray1##X##_value, xdim); \

-        for (size_t i=0; i<xdim; ++i) m[i] = val; \

-        carray1##X a = {m, xdim | _carray_OWN}; \

-        return a; \

-    } \

-    STC_INLINE carray2##X \

-    carray2##X##_init(size_t ydim, size_t xdim, Value val) { \

-        const size_t n = ydim * xdim; \

-        carray2##X##_value* m = c_new_n(carray2##X##_value, n); \

-        for (size_t i=0; i<n; ++i) m[i] = val; \

-        carray2##X a = {m, xdim | _carray_OWN, ydim}; \

-        return a; \

-    } \

-\

-    STC_INLINE carray1##X \

-    carray1##X##_from(carray1##X##_value* array, size_t xdim) { \

-        carray1##X a = {array, xdim}; \

-        return a; \

-    } \

-    STC_INLINE carray2##X \

-    carray2##X##_from(carray2##X##_value* array, size_t ydim, size_t xdim) { \

-        carray2##X a = {array, xdim, ydim}; \

-        return a; \

-    } \

-\

-    STC_INLINE carray1##X##_value* \

-    carray1##X##_at(const carray1##X *a, size_t x) { return a->data + x; } \

-    \

-    STC_INLINE carray1##X \

-    carray2##X##_at1(const carray2##X *a, size_t y) { \

-        carray1##X sub = {a->data + y*_carray_xdim(*a), _carray_xdim(*a)}; \

-        return sub; \

-    } \

-    STC_INLINE carray2##X##_value* \

-    carray2##X##_at(const carray2##X *a, size_t y, size_t x) { \

-        return a->data + y*_carray_xdim(*a) + x; \

-    } \

-    typedef carray2##X carray2##X##_t

-

-

-#define using_carray3(...) c_MACRO_OVERLOAD(using_carray3, __VA_ARGS__)

-

-#define using_carray3_2(X, Value) \

-    using_carray3_4(X, Value, c_default_del, c_default_fromraw)

-

-#define using_carray3_4(X, Value, valueDel, valueClone) \

-\

-    using_carray2_4(X, Value, valueDel, valueClone); \

-    typedef Value carray3##X##_value; \

-\

-    typedef struct { \

-        carray3##X##_value *data; \

-        size_t _xdim, _ydim, _zdim; \

-    } carray3##X; \

-\

-    STC_INLINE size_t \

-    carray3##X##_size(carray3##X a) {return _carray_xdim(a)*_carray_ydim(a)*_carray_zdim(a);} \

-    STC_INLINE size_t \

-    carray3##X##_ydim(carray3##X a) {return _carray_ydim(a);} \

-    STC_INLINE size_t \

-    carray3##X##_zdim(carray3##X a) {return _carray_zdim(a);} \

-\

-    _using_carray_common(3, X, Value, valueDel, valueClone) \

-\

-    STC_INLINE carray3##X \

-    carray3##X##_init(size_t zdim, size_t ydim, size_t xdim, Value val) { \

-        const size_t n = zdim * ydim * xdim; \

-        carray3##X##_value* m = c_new_n(carray3##X##_value, n); \

-        for (size_t i=0; i<n; ++i) m[i] = val; \

-        carray3##X a = {m, xdim | _carray_OWN, ydim, zdim}; \

-        return a; \

-    } \

-\

-    STC_INLINE carray3##X \

-    carray3##X##_from(carray3##X##_value* array, size_t zdim, size_t ydim, size_t xdim) { \

-        carray3##X a = {array, xdim, ydim, zdim}; \

-        return a; \

-    } \

-\

-    STC_INLINE carray2##X \

-    carray3##X##_at1(const carray3##X *a, size_t z) { \

-        carray2##X sub = {a->data + z*_carray_ydim(*a)*_carray_xdim(*a), _carray_xdim(*a), _carray_ydim(*a)}; \

-        return sub; \

-    } \

-    STC_INLINE carray1##X \

-    carray3##X##_at2(const carray3##X *a, size_t z, size_t y) { \

-        carray1##X sub = {a->data + (z*_carray_ydim(*a) + y)*_carray_xdim(*a), _carray_xdim(*a)}; \

-        return sub; \

-    } \

-    STC_INLINE carray3##X##_value* \

-    carray3##X##_at(const carray3##X *a, size_t z, size_t y, size_t x) { \

-        return a->data + (z*_carray_ydim(*a) + y)*_carray_xdim(*a) + x; \

-    } \

-    typedef carray3##X carray3##X##_t

-

-

-#define _carray_SUB (SIZE_MAX >> 1)

-#define _carray_OWN (_carray_SUB + 1)

-#define _carray_xdim(a) ((a)._xdim & _carray_SUB)

-#define _carray_ydim(a) (a)._ydim

-#define _carray_zdim(a) (a)._zdim

-

-#define _using_carray_common(D, X, Value, valueDel, valueClone) \

-    typedef struct { carray1##X##_value *ref; } carray##D##X##_iter; \

-\

-    STC_INLINE carray##D##X##_iter \

-    carray##D##X##_begin(const carray##D##X* a) { \

-        carray##D##X##_iter it = {a->data}; return it; \

-    } \

-    STC_INLINE carray##D##X##_iter \

-    carray##D##X##_end(const carray##D##X* a) { \

-        carray##D##X##_iter it = {a->data + carray##D##X##_size(*a)}; return it; \

-    } \

-    STC_INLINE void \

-    carray##D##X##_next(carray##D##X##_iter* it) {++it->ref;} \

-\

-    STC_INLINE void \

-    carray##D##X##_del(carray##D##X* self) { \

-        if (self->_xdim & _carray_OWN) { \

-            c_foreach_3 (i, carray##D##X, *self) \

-                valueDel(i.ref); \

-            c_free(self->data); \

-        } \

-    } \

-    STC_INLINE carray##D##X \

-    carray##D##X##_clone(carray##D##X arr) { \

-        carray##D##X cp = arr; size_t k = 0; \

-        cp.data = c_new_n(carray1##X##_value, carray##D##X##_size(arr)); \

-        c_foreach_3 (i, carray##D##X, arr) \

-            cp.data[k++] = valueClone(*i.ref); \

-        return cp; \

-    } \

-    STC_INLINE size_t \

-    carray##D##X##_xdim(carray##D##X a) {return _carray_xdim(a);} \

-

-#endif

diff --git a/benchmarks/picobench.hpp b/benchmarks/picobench/picobench.hpp
index 2e4541e0..2e4541e0 100644
--- a/benchmarks/picobench.hpp
+++ b/benchmarks/picobench/picobench.hpp
diff --git a/benchmarks/shootout1_cmap.cpp b/benchmarks/picobench/picobench_cmap.cpp
index 87790844..68d91f86 100644
--- a/benchmarks/shootout1_cmap.cpp
+++ b/benchmarks/picobench/picobench_cmap.cpp
@@ -4,10 +4,10 @@
 #include <string>

 #include <unordered_map>

 #include <stdexcept>

-#include "others/robin_hood.hpp"

-#include "others/skarupke/bytell_hash_map.hpp"

-#include "others/tsl/hopscotch_map.h"

-#include "others/parallel_hashmap/phmap.h"

+#include "../external/robin_hood.h"

+#include "../external/skarupke/bytell_hash_map.hpp"

+#include "../external/tsl/hopscotch_map.h"

+#include "../external/parallel_hashmap/phmap.h"

 

 #define PICOBENCH_IMPLEMENT_WITH_MAIN

 #include "picobench.hpp"

diff --git a/benchmarks/shootout3_csmap.cpp b/benchmarks/picobench/picobench_csmap.cpp
index dfa0ab1b..7a0addad 100644
--- a/benchmarks/shootout3_csmap.cpp
+++ b/benchmarks/picobench/picobench_csmap.cpp
@@ -179,7 +179,7 @@ static void ins_and_access_csmap_i(picobench::state& s)
     picobench::scope scope(s);

     c_forrange (s.iterations()) {

         result += ++csmap_i_emplace(&map, stc64_random() & mask, 0).ref->second;

-        csmap_i_value* val = csmap_i_get(&map, stc64_random() & mask);

+        const csmap_i_value* val = csmap_i_get(&map, stc64_random() & mask);

         if (val) csmap_i_erase(&map, val->first);

     }

     s.set_result(result + csmap_i_size(map));

diff --git a/benchmarks/cdeq_benchmark.cpp b/benchmarks/plotbench/cdeq_benchmark.cpp
index 6db167b0..6db167b0 100644
--- a/benchmarks/cdeq_benchmark.cpp
+++ b/benchmarks/plotbench/cdeq_benchmark.cpp
diff --git a/benchmarks/clist_benchmark.cpp b/benchmarks/plotbench/clist_benchmark.cpp
index 676d31e7..676d31e7 100644
--- a/benchmarks/clist_benchmark.cpp
+++ b/benchmarks/plotbench/clist_benchmark.cpp
diff --git a/benchmarks/cmap_benchmark.cpp b/benchmarks/plotbench/cmap_benchmark.cpp
index dc104c2d..0dbe5a31 100644
--- a/benchmarks/cmap_benchmark.cpp
+++ b/benchmarks/plotbench/cmap_benchmark.cpp
@@ -91,7 +91,7 @@ Sample test_stc_unordered_map() {
         stc64_srandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

-        cmap_x_value* val;

+        const cmap_x_value* val;

         c_forrange (N) 

             if ((val = cmap_x_get(&con, stc64_random() & mask1)))

                 sum += val->second;

diff --git a/benchmarks/cpque_benchmark.cpp b/benchmarks/plotbench/cpque_benchmark.cpp
index 19a9c701..19a9c701 100644
--- a/benchmarks/cpque_benchmark.cpp
+++ b/benchmarks/plotbench/cpque_benchmark.cpp
diff --git a/benchmarks/csmap_benchmark.cpp b/benchmarks/plotbench/csmap_benchmark.cpp
index bb055367..47762791 100644
--- a/benchmarks/csmap_benchmark.cpp
+++ b/benchmarks/plotbench/csmap_benchmark.cpp
@@ -91,7 +91,7 @@ Sample test_stc_map() {
         stc64_srandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

-        csmap_x_value* val;

+        const csmap_x_value* val;

         c_forrange (N) 

             if ((val = csmap_x_get(&con, stc64_random() & mask1)))

                 sum += val->second;

diff --git a/benchmarks/cvec_benchmark.cpp b/benchmarks/plotbench/cvec_benchmark.cpp
index c4648e34..c4648e34 100644
--- a/benchmarks/cvec_benchmark.cpp
+++ b/benchmarks/plotbench/cvec_benchmark.cpp
diff --git a/benchmarks/plot.py b/benchmarks/plotbench/plot.py
index ea3871f4..ea3871f4 100644
--- a/benchmarks/plot.py
+++ b/benchmarks/plotbench/plot.py
diff --git a/benchmarks/run_all.bat b/benchmarks/plotbench/run_all.bat
index 2edd0a1e..2edd0a1e 100644
--- a/benchmarks/run_all.bat
+++ b/benchmarks/plotbench/run_all.bat
diff --git a/benchmarks/run_all.sh b/benchmarks/plotbench/run_all.sh
index f15a5881..f15a5881 100644
--- a/benchmarks/run_all.sh
+++ b/benchmarks/plotbench/run_all.sh
diff --git a/benchmarks/run_clang.sh b/benchmarks/plotbench/run_clang.sh
index ae19486e..ae19486e 100644
--- a/benchmarks/run_clang.sh
+++ b/benchmarks/plotbench/run_clang.sh
diff --git a/benchmarks/run_gcc.sh b/benchmarks/plotbench/run_gcc.sh
index 6a6472c0..6a6472c0 100644
--- a/benchmarks/run_gcc.sh
+++ b/benchmarks/plotbench/run_gcc.sh
diff --git a/benchmarks/run_vc.bat b/benchmarks/plotbench/run_vc.bat
index 3dca925b..3dca925b 100644
--- a/benchmarks/run_vc.bat
+++ b/benchmarks/plotbench/run_vc.bat
diff --git a/benchmarks/shootout2_cmap.cpp b/benchmarks/shootout2_cmap.cpp
deleted file mode 100644
index 58a31009..00000000
--- a/benchmarks/shootout2_cmap.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-#include <stdio.h>

-#include <time.h>

-#include <stc/crandom.h>

-#include <stc/cstr.h>

-#include "others/khash.h"

-

-#ifdef __cplusplus

-#include <limits>

-#include <unordered_map>

-#include "others/robin_hood.hpp"

-#include "others/skarupke/bytell_hash_map.hpp"

-#include "others/tsl/hopscotch_map.h"

-#include "others/parallel_hashmap/phmap.h"

-template<typename C> inline void destroy_me(C& c) { C().swap(c); }

-#endif

-

-

-// cmap and khash template expansion

-#define i_key int64_t

-#define i_val int64_t

-#define i_hash c_default_hash64

-#define i_tag ii

-#include <stc/cmap.h>

-

-KHASH_MAP_INIT_INT64(ii, int64_t)

-

-

-size_t seed;

-static const float max_load_factor = 0.77f;

-

-stc64_t rng;

-#define SEED(s) rng = stc64_init(seed)

-#define RAND(N) (stc64_rand(&rng) & ((1 << N) - 1))

-

-

-#define CMAP_SETUP(X, Key, Value) cmap_##X map = cmap_##X##_init() \

-                                  ; cmap_##X##_max_load_factor(&map, max_load_factor)

-#define CMAP_PUT(X, key, val)     cmap_##X##_emplace_or_assign(&map, key, val).ref->second

-#define CMAP_EMPLACE(X, key, val) cmap_##X##_emplace(&map, key, val).ref->second

-#define CMAP_ERASE(X, key)        cmap_##X##_erase(&map, key)

-#define CMAP_FIND(X, key)         cmap_##X##_contains(map, key)

-#define CMAP_FOR(X, i)            c_foreach (i, cmap_##X, map)

-#define CMAP_ITEM(X, i)           i.ref->second

-#define CMAP_SIZE(X)              cmap_##X##_size(map)

-#define CMAP_BUCKETS(X)           cmap_##X##_bucket_count(map)

-#define CMAP_CLEAR(X)             cmap_##X##_clear(&map)

-#define CMAP_DTOR(X)              cmap_##X##_del(&map)

-

-#define KMAP_SETUP(X, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret

-#define KMAP_PUT(X, key, val)     (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, map->vals+ki))

-#define KMAP_EMPLACE(X, key, val) (*(ki = kh_put(ii, map, key, &ret), ret ? (map->vals[ki] = val, 0) : 1, map->vals+ki))

-#define KMAP_ERASE(X, key)        ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0)

-#define KMAP_FIND(X, key)         (kh_get(ii, map, key) != kh_end(map))

-#define KMAP_SIZE(X)              kh_size(map)

-#define KMAP_BUCKETS(X)           kh_n_buckets(map)

-#define KMAP_CLEAR(X)             kh_clear(ii, map)

-#define KMAP_DTOR(X)              kh_destroy(ii, map)

-

-#define UMAP_SETUP(X, Key, Value) std::unordered_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define UMAP_PUT(X, key, val)     (map[key] = val)

-#define UMAP_EMPLACE(X, key, val) map.emplace(key, val).first->second

-#define UMAP_FIND(X, key)         (map.find(key) != map.end())

-#define UMAP_ERASE(X, key)        map.erase(key)

-#define UMAP_FOR(X, i)            for (auto i: map)

-#define UMAP_ITEM(X, i)           i.second

-#define UMAP_SIZE(X)              map.size()

-#define UMAP_BUCKETS(X)           map.bucket_count()

-#define UMAP_CLEAR(X)             map.clear()

-#define UMAP_DTOR(X)              destroy_me(map)

-

-#define BMAP_SETUP(X, Key, Value) ska::bytell_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define BMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

-#define BMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

-#define BMAP_FIND(X, key)         UMAP_FIND(X, key)

-#define BMAP_ERASE(X, key)        UMAP_ERASE(X, key)

-#define BMAP_FOR(X, i)            UMAP_FOR(X, i)

-#define BMAP_ITEM(X, i)           UMAP_ITEM(X, i)

-#define BMAP_SIZE(X)              UMAP_SIZE(X)

-#define BMAP_BUCKETS(X)           UMAP_BUCKETS(X)

-#define BMAP_CLEAR(X)             UMAP_CLEAR(X)

-#define BMAP_DTOR(X)              UMAP_DTOR(X)

-

-#define FMAP_SETUP(X, Key, Value) ska::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define FMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

-#define FMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

-#define FMAP_FIND(X, key)         UMAP_FIND(X, key)

-#define FMAP_ERASE(X, key)        UMAP_ERASE(X, key)

-#define FMAP_FOR(X, i)            UMAP_FOR(X, i)

-#define FMAP_ITEM(X, i)           UMAP_ITEM(X, i)

-#define FMAP_SIZE(X)              UMAP_SIZE(X)

-#define FMAP_BUCKETS(X)           UMAP_BUCKETS(X)

-#define FMAP_CLEAR(X)             UMAP_CLEAR(X)

-#define FMAP_DTOR(X)              UMAP_DTOR(X)

-

-#define HMAP_SETUP(X, Key, Value) tsl::hopscotch_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define HMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

-#define HMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

-#define HMAP_FIND(X, key)         UMAP_FIND(X, key)

-#define HMAP_ERASE(X, key)        UMAP_ERASE(X, key)

-#define HMAP_FOR(X, i)            UMAP_FOR(X, i)

-#define HMAP_ITEM(X, i)           UMAP_ITEM(X, i)

-#define HMAP_SIZE(X)              UMAP_SIZE(X)

-#define HMAP_BUCKETS(X)           UMAP_BUCKETS(X)

-#define HMAP_CLEAR(X)             UMAP_CLEAR(X)

-#define HMAP_DTOR(X)              UMAP_DTOR(X)

-

-#define RMAP_SETUP(X, Key, Value) robin_hood::unordered_map<Key, Value> map

-#define RMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

-#define RMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

-#define RMAP_FIND(X, key)         UMAP_FIND(X, key)

-#define RMAP_ERASE(X, key)        UMAP_ERASE(X, key)

-#define RMAP_FOR(X, i)            UMAP_FOR(X, i)

-#define RMAP_ITEM(X, i)           UMAP_ITEM(X, i)

-#define RMAP_SIZE(X)              UMAP_SIZE(X)

-#define RMAP_BUCKETS(X)           map.mask()

-#define RMAP_CLEAR(X)             UMAP_CLEAR(X)

-#define RMAP_DTOR(X)              UMAP_DTOR(X)

-

-#define PMAP_SETUP(X, Key, Value) phmap::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define PMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

-#define PMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

-#define PMAP_FIND(X, key)         UMAP_FIND(X, key)

-#define PMAP_ERASE(X, key)        UMAP_ERASE(X, key)

-#define PMAP_FOR(X, i)            UMAP_FOR(X, i)

-#define PMAP_ITEM(X, i)           UMAP_ITEM(X, i)

-#define PMAP_SIZE(X)              UMAP_SIZE(X)

-#define PMAP_BUCKETS(X)           UMAP_BUCKETS(X)

-#define PMAP_CLEAR(X)             UMAP_CLEAR(X)

-#define PMAP_DTOR(X)              UMAP_DTOR(X)

-

-enum {

-    RR =  27,

-    FAC = 3,

-    N0 = 10000000 * FAC,

-    N1 = 10000000 * FAC,

-    N2 = 10000000 * FAC,

-    N3 = 10000000 * FAC,

-    N4 = 10000000 * FAC,

-};

-int rr = RR;

-

-

-#define MAP_TEST0(M, X) \

-{ \

-    M##_SETUP(X, int64_t, int64_t); \

-    uint64_t checksum = 0; \

-    SEED(seed); \

-    clock_t difference, before = clock(); \

-    for (size_t i = 0; i < N0; ++i) { \

-        checksum += ++ M##_EMPLACE(X, RAND(rr), i); \

-    } \

-    difference = clock() - before; \

-    printf(#M ": time: %5.02f, sum: %zu, size: %zu, buckets: %8zu\n", \

-           (float) difference / CLOCKS_PER_SEC, checksum, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X)); \

-    M##_DTOR(X); \

-}

-

-#define MAP_TEST1(M, X) \

-{ \

-    M##_SETUP(X, int64_t, int64_t); \

-    uint64_t checksum = 0, erased = 0; \

-    SEED(seed); \

-    clock_t difference, before = clock(); \

-    for (size_t i = 0; i < N1; ++i) { \

-        checksum += ++ M##_EMPLACE(X, RAND(rr), i); \

-        erased += M##_ERASE(X, RAND(rr)); \

-    } \

-    difference = clock() - before; \

-    printf(#M ": time: %5.02f, sum: %zu, erased %zu, size: %zu, buckets: %8zu\n", \

-           (float) difference / CLOCKS_PER_SEC, checksum, erased, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X)); \

-    M##_DTOR(X); \

-}

-

-#define MAP_TEST2(M, X) \

-{ \

-    M##_SETUP(X, int64_t, int64_t); \

-    size_t erased = 0; \

-    clock_t difference, before = clock(); \

-    for (size_t i = 0; i < N2; ++i) \

-        M##_PUT(X, i, i); \

-    for (size_t i = 0; i < N2; ++i) \

-        erased += M##_ERASE(X, i); \

-    difference = clock() - before; \

-    printf(#M ": time: %5.02f, erased %zu, size: %zu, buckets: %8zu\n", \

-           (float) difference / CLOCKS_PER_SEC, erased, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X)); \

-    M##_DTOR(X); \

-}

-

-#define MAP_TEST3(M, X) \

-{ \

-    M##_SETUP(X, int64_t, int64_t); \

-    size_t erased = 0; \

-    clock_t difference, before = clock(); \

-    SEED(seed); \

-    for (size_t i = 0; i < N3; ++i) \

-        M##_PUT(X, RAND(rr), i); \

-    SEED(seed); \

-    for (size_t i = 0; i < N3; ++i) \

-        erased += M##_ERASE(X, RAND(rr)); \

-    difference = clock() - before; \

-    printf(#M ": time: %5.02f, erased %zu, size: %zu, buckets: %8zu\n", \

-           (float) difference / CLOCKS_PER_SEC, erased, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X)); \

-    M##_DTOR(X); \

-}

-

-#define MAP_TEST4(M, X) \

-{ \

-    M##_SETUP(X, int64_t, int64_t); \

-    size_t sum = 0; \

-    SEED(seed); \

-    for (size_t i = 0; i < N4; ++i) \

-        M##_PUT(X, RAND(rr), i); \

-    clock_t difference, before = clock(); \

-    for (int k=0; k<5; k++) M##_FOR (X, i) \

-        sum += M##_ITEM(X, i); \

-    difference = clock() - before; \

-    printf(#M ": time: %5.02f, sum %zu, size: %zu, buckets: %8zu\n", \

-           (float) difference / CLOCKS_PER_SEC, sum, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X)); \

-    M##_DTOR(X); \

-}

-

-#ifdef __cplusplus

-#define RUN_TEST(n) MAP_TEST##n(CMAP, ii) MAP_TEST##n(KMAP, ii) MAP_TEST##n(UMAP, ii) MAP_TEST##n(PMAP, ii) \

-                    MAP_TEST##n(BMAP, ii) MAP_TEST##n(FMAP, ii) MAP_TEST##n(RMAP, ii) /*MAP_TEST##n(HMAP, ii)*/

-#define RUNX_TEST(n) MAP_TEST##n(CMAP, ii) /*MAP_TEST##n(KMAP, ii)*/ MAP_TEST##n(UMAP, ii) MAP_TEST##n(PMAP, ii) \

-                    MAP_TEST##n(BMAP, ii) MAP_TEST##n(FMAP, ii) MAP_TEST##n(RMAP, ii) /*MAP_TEST##n(HMAP, ii)*/

-#else

-#define RUN_TEST(n) MAP_TEST##n(CMAP, ii) MAP_TEST##n(KMAP, ii)

-#define RUNX_TEST(n) MAP_TEST##n(CMAP, ii)

-#endif

-

-

-int main(int argc, char* argv[])

-{

-    rr = argc == 2 ? atoi(argv[1]) : RR;

-    seed = time(NULL);

-

-    printf("\nRandom keys are in range [0, 2^%d), seed = %zu:\n", rr, seed);

-    printf("CMAP = STC cmap\n"

-           "KMAP = Klib khash\n"

-           "UMAP = std::unordered_map\n"

-           "PMAP = phmap::flat_hash_map\n"

-           "BMAP = ska::bytell_hash_map\n"

-           "FMAP = ska::flat_hash_map\n"

-           "RMAP = robin_hood::unordered_map\n");

-    printf("\nUnordered maps: Insert %d random keys:\n", N0);

-    RUN_TEST(0)

-

-    printf("\nUnordered maps: %d insert random key + try to remove another random key:\n", N1);

-    RUN_TEST(1)

-

-    printf("\nUnordered maps: Insert %d sequential keys, then remove them in same order:\n", N2);

-    RUN_TEST(2)

-

-    printf("\nUnordered maps: Insert %d random keys, then remove them in same order:\n", N3);

-    RUN_TEST(3)

-

-    printf("\nUnordered maps: Iterate %d random keys:\n", N4);

-    RUNX_TEST(4)

-}

diff --git a/benchmarks/shootout_hashmaps.cpp b/benchmarks/shootout_hashmaps.cpp
new file mode 100644
index 00000000..382a6334
--- /dev/null
+++ b/benchmarks/shootout_hashmaps.cpp
@@ -0,0 +1,295 @@
+#include <stdio.h>
+#include <time.h>
+#include <stc/crandom.h>
+#include <stc/cstr.h>
+#include "external/khash.h"
+
+enum {max_load_factor = 77};
+
+#ifdef __cplusplus
+#include <limits>
+#include <unordered_map>
+#include "external/robin_hood.h"
+#include "external/skarupke/bytell_hash_map.hpp"
+#include "external/parallel_hashmap/phmap.h"
+#include "external/tsl/hopscotch_map.h"
+#include "external/tsl/robin_map.h"
+
+template<typename C> inline void std_destroy(C& c) { C().swap(c); }
+
+template <class K, class V> using robin_hood_flat_map = robin_hood::unordered_flat_map<
+                                  K, V, robin_hood::hash<K>, std::equal_to<K>, max_load_factor>;
+#endif
+
+KHASH_MAP_INIT_INT64(ii, int64_t)
+
+// cmap and khash template expansion
+#define i_key int64_t
+#define i_val int64_t
+#define i_hash c_default_hash64
+#define i_tag ii
+#include <stc/cmap.h>
+
+stc64_t rng;
+size_t seed;
+#define SEED(s) rng = stc64_init(seed)
+#define RAND(N) (stc64_rand(&rng) & (((uint64_t)1 << N) - 1))
+
+
+#define CMAP_SETUP(X, Key, Value) cmap_##X map = cmap_##X##_init() \
+                                  ; cmap_##X##_max_load_factor(&map, max_load_factor/100.0f)
+#define CMAP_PUT(X, key, val)     cmap_##X##_emplace_or_assign(&map, key, val).ref->second
+#define CMAP_EMPLACE(X, key, val) cmap_##X##_emplace(&map, key, val).ref->second
+#define CMAP_ERASE(X, key)        cmap_##X##_erase(&map, key)
+#define CMAP_FIND(X, key)         cmap_##X##_contains(&map, key)
+#define CMAP_FOR(X, i)            c_foreach (i, cmap_##X, map)
+#define CMAP_ITEM(X, i)           i.ref->second
+#define CMAP_SIZE(X)              cmap_##X##_size(map)
+#define CMAP_BUCKETS(X)           cmap_##X##_bucket_count(map)
+#define CMAP_CLEAR(X)             cmap_##X##_clear(&map)
+#define CMAP_DTOR(X)              cmap_##X##_del(&map)
+
+#define KMAP_SETUP(X, Key, Value) khash_t(X)* map = kh_init(X); khiter_t ki; int ret
+#define KMAP_PUT(X, key, val)     (*(ki = kh_put(X, map, key, &ret), map->vals[ki] = val, map->vals+ki))
+#define KMAP_EMPLACE(X, key, val) (*(ki = kh_put(X, map, key, &ret), ret ? (map->vals[ki] = val, 0) : 1, map->vals+ki))
+#define KMAP_ERASE(X, key)        ((ki = kh_get(X, map, key)) != kh_end(map) ? kh_del(X, map, ki), 1 : 0)
+#define KMAP_FOR(X, i)            for (khint_t i = kh_begin(map); i != kh_end(map); ++i) if (kh_exist(map, i))
+#define KMAP_ITEM(X, i)           map->vals[i]
+#define KMAP_FIND(X, key)         (kh_get(X, map, key) != kh_end(map))
+#define KMAP_SIZE(X)              kh_size(map)
+#define KMAP_BUCKETS(X)           kh_n_buckets(map)
+#define KMAP_CLEAR(X)             kh_clear(X, map)
+#define KMAP_DTOR(X)              kh_destroy(X, map)
+
+#define UMAP_SETUP(X, Key, Value) std::unordered_map<Key, Value> map; map.max_load_factor(max_load_factor/100.0f)
+#define UMAP_PUT(X, key, val)     (map[key] = val)
+#define UMAP_EMPLACE(X, key, val) map.emplace(key, val).first->second
+#define UMAP_FIND(X, key)         int(map.find(key) != map.end())
+#define UMAP_ERASE(X, key)        map.erase(key)
+#define UMAP_FOR(X, i)            for (auto i: map)
+#define UMAP_ITEM(X, i)           i.second
+#define UMAP_SIZE(X)              map.size()
+#define UMAP_BUCKETS(X)           map.bucket_count()
+#define UMAP_CLEAR(X)             map.clear()
+#define UMAP_DTOR(X)              std_destroy(map)
+
+#define FMAP_SETUP(X, Key, Value) ska::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor/100.0f)
+#define FMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)
+#define FMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)
+#define FMAP_FIND(X, key)         UMAP_FIND(X, key)
+#define FMAP_ERASE(X, key)        UMAP_ERASE(X, key)
+#define FMAP_FOR(X, i)            UMAP_FOR(X, i)
+#define FMAP_ITEM(X, i)           UMAP_ITEM(X, i)
+#define FMAP_SIZE(X)              UMAP_SIZE(X)
+#define FMAP_BUCKETS(X)           UMAP_BUCKETS(X)
+#define FMAP_CLEAR(X)             UMAP_CLEAR(X)
+#define FMAP_DTOR(X)              UMAP_DTOR(X)
+
+#define HMAP_SETUP(X, Key, Value) tsl::hopscotch_map<Key, Value> map; map.max_load_factor(max_load_factor/100.0f)
+#define HMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)
+#define HMAP_EMPLACE(X, key, val) map.emplace(key, val).first.value()
+#define HMAP_FIND(X, key)         UMAP_FIND(X, key)
+#define HMAP_ERASE(X, key)        UMAP_ERASE(X, key)
+#define HMAP_FOR(X, i)            UMAP_FOR(X, i)
+#define HMAP_ITEM(X, i)           UMAP_ITEM(X, i)
+#define HMAP_SIZE(X)              UMAP_SIZE(X)
+#define HMAP_BUCKETS(X)           UMAP_BUCKETS(X)
+#define HMAP_CLEAR(X)             UMAP_CLEAR(X)
+#define HMAP_DTOR(X)              UMAP_DTOR(X)
+
+#define TMAP_SETUP(X, Key, Value) tsl::robin_map<Key, Value> map; map.max_load_factor(max_load_factor/100.0f)
+#define TMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)
+#define TMAP_EMPLACE(X, key, val) map.emplace(key, val).first.value()
+#define TMAP_FIND(X, key)         UMAP_FIND(X, key)
+#define TMAP_ERASE(X, key)        UMAP_ERASE(X, key)
+#define TMAP_FOR(X, i)            UMAP_FOR(X, i)
+#define TMAP_ITEM(X, i)           UMAP_ITEM(X, i)
+#define TMAP_SIZE(X)              UMAP_SIZE(X)
+#define TMAP_BUCKETS(X)           UMAP_BUCKETS(X)
+#define TMAP_CLEAR(X)             UMAP_CLEAR(X)
+#define TMAP_DTOR(X)              UMAP_DTOR(X)
+
+//#define RMAP_SETUP(X, Key, Value) robin_hood::unordered_map<Key, Value> map
+#define RMAP_SETUP(X, Key, Value) robin_hood_flat_map<Key, Value> map
+#define RMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)
+#define RMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)
+#define RMAP_FIND(X, key)         UMAP_FIND(X, key)
+#define RMAP_ERASE(X, key)        UMAP_ERASE(X, key)
+#define RMAP_FOR(X, i)            UMAP_FOR(X, i)
+#define RMAP_ITEM(X, i)           UMAP_ITEM(X, i)
+#define RMAP_SIZE(X)              UMAP_SIZE(X)
+#define RMAP_BUCKETS(X)           map.mask()
+#define RMAP_CLEAR(X)             UMAP_CLEAR(X)
+#define RMAP_DTOR(X)              UMAP_DTOR(X)
+
+#define PMAP_SETUP(X, Key, Value) phmap::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor/100.0f)
+#define PMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)
+#define PMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)
+#define PMAP_FIND(X, key)         UMAP_FIND(X, key)
+#define PMAP_ERASE(X, key)        UMAP_ERASE(X, key)
+#define PMAP_FOR(X, i)            UMAP_FOR(X, i)
+#define PMAP_ITEM(X, i)           UMAP_ITEM(X, i)
+#define PMAP_SIZE(X)              UMAP_SIZE(X)
+#define PMAP_BUCKETS(X)           UMAP_BUCKETS(X)
+#define PMAP_CLEAR(X)             UMAP_CLEAR(X)
+#define PMAP_DTOR(X)              UMAP_DTOR(X)
+
+
+#define MAP_TEST0(M, X, n) \
+{   /* Insert, update */ \
+    M##_SETUP(X, int64_t, int64_t); \
+    uint64_t sum = 0; \
+    SEED(seed); \
+    clock_t difference, before = clock(); \
+    for (size_t i = 0; i < n; ++i) { \
+        sum += ++ M##_EMPLACE(X, RAND(keybits), i); \
+    } \
+    difference = clock() - before; \
+    printf(#M ": time: %5.02f, size: %zu, buckets: %8zu, sum: %zu\n", \
+           (float) difference / CLOCKS_PER_SEC, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), sum); \
+    M##_DTOR(X); \
+}
+
+#define MAP_TEST1(M, X, n) \
+{   /* Insert, update and erase another */ \
+    M##_SETUP(X, int64_t, int64_t); \
+    uint64_t sum = 0, erased = 0; \
+    SEED(seed); \
+    clock_t difference, before = clock(); \
+    for (size_t i = 0; i < n; ++i) { \
+        sum += ++ M##_EMPLACE(X, RAND(keybits), i); \
+        erased += M##_ERASE(X, RAND(keybits)); \
+    } \
+    difference = clock() - before; \
+    printf(#M ": time: %5.02f, size: %zu, buckets: %8zu, erased %zu, sum: %zu\n", \
+           (float) difference / CLOCKS_PER_SEC, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), erased, sum); \
+    M##_DTOR(X); \
+}
+
+#define MAP_TEST2(M, X, n) \
+{   /* Insert sequential keys, then erase them */ \
+    M##_SETUP(X, int64_t, int64_t); \
+    size_t erased = 0; \
+    clock_t difference, before = clock(); \
+    for (size_t i = 0; i < n; ++i) \
+        M##_PUT(X, i, i); \
+    for (size_t i = 0; i < n; ++i) \
+        erased += M##_ERASE(X, i); \
+    difference = clock() - before; \
+    printf(#M ": time: %5.02f, size: %zu, buckets: %8zu, erased %zu\n", \
+           (float) difference / CLOCKS_PER_SEC, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), erased); \
+    M##_DTOR(X); \
+}
+
+#define MAP_TEST3(M, X, n) \
+{   /* Erase elements */ \
+    M##_SETUP(X, int64_t, int64_t); \
+    size_t erased = 0; \
+    clock_t difference, before; \
+    SEED(seed); \
+    for (size_t i = 0; i < n; ++i) \
+        M##_PUT(X, RAND(keybits), i); \
+    SEED(seed); \
+    before = clock(); \
+    for (size_t i = 0; i < n; ++i) \
+        erased += M##_ERASE(X, RAND(keybits)); \
+    difference = clock() - before; \
+    printf(#M ": time: %5.02f, size: %zu, buckets: %8zu, erased %zu\n", \
+           (float) difference / CLOCKS_PER_SEC, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), erased); \
+    M##_DTOR(X); \
+}
+
+#define MAP_TEST4(M, X, n) \
+{   /* Iterate */ \
+    M##_SETUP(X, int64_t, int64_t); \
+    size_t sum = 0, m = 1ull << (keybits + 1), nn = n; \
+    if (nn < m) m = nn; \
+    SEED(seed); \
+    for (size_t i = 0; i < m; ++i) \
+        M##_PUT(X, RAND(keybits), i); \
+    size_t x = 500000000/M##_SIZE(X); \
+    clock_t difference, before = clock(); \
+    for (int k=0; k < x; k++) M##_FOR (X, it) \
+        sum += M##_ITEM(X, it); \
+    difference = clock() - before; \
+    printf(#M ": time: %5.02f, size: %zu, buckets: %8zu, repeats: %zu, sum: %zu\n", \
+           (float) difference / CLOCKS_PER_SEC, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), x, sum); \
+    M##_DTOR(X); \
+}
+
+#define MAP_TEST5(M, X, n) \
+{   /* Lookup */ \
+    M##_SETUP(X, int64_t, int64_t); \
+    size_t found = 0, m = 1ull << (keybits + 1), nn = n; \
+    clock_t difference, before; \
+    if (nn < m) m = nn; \
+    SEED(seed); \
+    for (size_t i = 0; i < m; ++i) \
+        M##_PUT(X, RAND(keybits), i); \
+    before = clock(); \
+    size_t x = m * 20000000/M##_SIZE(X); \
+    for (size_t i = 0; i < x; ++i) \
+        found += M##_FIND(X, RAND(keybits)); \
+    SEED(seed); \
+    for (size_t i = 0; i < x; ++i) \
+        found += M##_FIND(X, RAND(keybits)); \
+    difference = clock() - before; \
+    printf(#M ": time: %5.02f, size: %zu, buckets: %8zu, lookups: %zu, found: %zu\n", \
+           (float) difference / CLOCKS_PER_SEC, (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), x*2, found); \
+    M##_DTOR(X); \
+}
+
+
+#ifdef __cplusplus
+#define RUN_TEST(n) MAP_TEST##n(CMAP, ii, N##n) MAP_TEST##n(KMAP, ii, N##n) \
+                    MAP_TEST##n(PMAP, ii, N##n) MAP_TEST##n(FMAP, ii, N##n) \
+                    MAP_TEST##n(RMAP, ii, N##n) MAP_TEST##n(HMAP, ii, N##n) \
+                    MAP_TEST##n(TMAP, ii, N##n) MAP_TEST##n(UMAP, ii, N##n)
+#else
+#define RUN_TEST(n) MAP_TEST##n(CMAP, ii, N##n) MAP_TEST##n(KMAP, ii, N##n)
+#endif
+
+enum {
+    DEFAULT_N_MILL = 40,
+    DEFAULT_KEYBITS = 25,
+};
+
+int main(int argc, char* argv[])
+{
+    int n_mill = argc >= 2 ? atoi(argv[1]) : DEFAULT_N_MILL;
+    int keybits = argc >= 3 ? atoi(argv[2]) : DEFAULT_KEYBITS;
+    int n = n_mill * 1000000;
+    int N0 = n, N1 = n/2, N2 = n/2, N3 = n, N4 = n, N5 = n;
+    seed = time(NULL); // 1636306010;
+
+    printf("\nUnordered hash map shootout\n");
+    printf("CMAP = https://github.com/tylov/STC\n"
+           "KMAP = https://github.com/attractivechaos/klib\n"
+           "PMAP = https://github.com/greg7mdp/parallel-hashmap\n"
+           "FMAP = https://github.com/skarupke/flat_hash_map\n"
+           "RMAP = https://github.com/martinus/robin-hood-hashing\n"
+           "HMAP = https://github.com/Tessil/hopscotch-map\n"
+           "TMAP = https://github.com/Tessil/robin-map\n"
+           "UMAP = std::unordered_map\n\n");
+           
+    printf("Usage %s [n-million=%d key-bits=%d]\n", argv[0], DEFAULT_N_MILL, DEFAULT_KEYBITS);
+    printf("N-base = %d. Random keys are in range [0, 2^%d). Seed = %zu:\n", n_mill, keybits, seed);
+
+    printf("\nT0: Insert/update random keys:\n");
+    RUN_TEST(0)
+
+    printf("\nT1: Insert/update random key + try to remove another random key:\n");
+    RUN_TEST(1)
+
+    printf("\nT2: Insert sequential keys, then remove them in same order:\n");
+    RUN_TEST(2)
+
+    printf("\nT3: Remove random keys:\n");
+    RUN_TEST(3)
+
+    printf("\nT4: Iterate random keys:\n");
+    RUN_TEST(4)
+
+    printf("\nT5: Lookup random keys:\n");
+    RUN_TEST(5)
+}
diff --git a/docs/carray_api.md b/docs/carray_api.md
index a6870b91..aa9ea681 100644
--- a/docs/carray_api.md
+++ b/docs/carray_api.md
@@ -33,7 +33,7 @@ void                carr2_X_del(carr2_X* self);
 
 size_t              carr2_X_size(carr2_X arr);
 i_val*              carr2_X_data(carr2_X* self);          // access storage data
-i_val*              carr2_X_at(carr2_X* self, size_t x, size_t y);
+const i_val*        carr2_X_at(const carr2_X* self, size_t x, size_t y);
 
 carr2_X_iter        carr2_X_begin(const carr2_X* self);
 carr2_X_iter        carr2_X_end(const carr2_X* self);
@@ -46,12 +46,12 @@ carr3_X             carr3_X_with_values(size_t xdim, size_t ydim, size_t zdim, i
 carr3_X             carr3_X_with_storage(size_t xdim, size_t ydim, size_t zdim, i_val* array);
 carr3_X             carr3_X_clone(carr3_X arr);
 void                carr3_X_copy(carr3_X* self, carr3_X other);
-i_val*              carr3_X_release(carr3_X* self);       // release storage (not freed)
+i_val*              carr3_X_release(carr3_X* self);                               // release storage (not freed)
 void                carr3_X_del(carr3_X* self);
 
 size_t              carr3_X_size(carr3_X arr);
-i_val*              carr3_X_data(carr3_X* self);          // access storage data
-i_val*              carr3_X_at(carr3_X* self, size_t x, size_t y, size_t z);
+i_val*              carr3_X_data(carr3_X* self);                                  // storage data
+const i_val*        carr3_X_at(const carr3_X* self, size_t x, size_t y, size_t z);
 
 carr3_X_iter        carr3_X_begin(const carr3_X* self);
 carr3_X_iter        carr3_X_end(const carr3_X* self);
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index ab0a1b12..22487682 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -28,17 +28,21 @@ cdeq_X              cdeq_X_clone(cdeq_X deq);
 
 void                cdeq_X_clear(cdeq_X* self);
 void                cdeq_X_copy(cdeq_X* self, cdeq_X other);
-void                cdeq_X_shrink_to_fit(cdeq_X* self);
 void                cdeq_X_reserve(cdeq_X* self, size_t cap);
+void                cdeq_X_shrink_to_fit(cdeq_X* self);
 void                cdeq_X_swap(cdeq_X* a, cdeq_X* b);
-
-void                cdeq_X_del(cdeq_X* self);      // destructor
+void                cdeq_X_del(cdeq_X* self);                                                    // destructor
 
 bool                cdeq_X_empty(cdeq_X deq);
 size_t              cdeq_X_size(cdeq_X deq);
 size_t              cdeq_X_capacity(cdeq_X deq);
 
-cdeq_X_value*       cdeq_X_at(const cdeq_X* self, size_t idx);
+const cdeq_X_value* cdeq_X_at(const cdeq_X* self, size_t idx);
+const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw);                                 // return NULL if not found
+cdeq_X_value*       cdeq_X_get_mut(cdeq_X* self, i_valraw raw);                                   // mutable get
+cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_valraw raw);
+cdeq_X_iter         cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw);
+
 cdeq_X_value*       cdeq_X_front(const cdeq_X* self);
 cdeq_X_value*       cdeq_X_back(const cdeq_X* self);
 
@@ -52,13 +56,13 @@ void                cdeq_X_pop_back(cdeq_X* self);
 
 cdeq_X_iter         cdeq_X_insert(cdeq_X* self, size_t idx, i_val value);                        // move value 
 cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
-cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);               // move value 
+cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);                 // move value 
 
 cdeq_X_iter         cdeq_X_emplace(cdeq_X* self, size_t idx, i_valraw raw);
 cdeq_X_iter         cdeq_X_emplace_n(cdeq_X* self, size_t idx, const i_valraw[] arr, size_t n);
 cdeq_X_iter         cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter it, i_valraw raw);
 cdeq_X_iter         cdeq_X_emplace_range(cdeq_X* self, cdeq_X_iter it, 
-                                         cdeq_X_iter it1, cdeq_X_iter it2);                 // will clone
+                                         cdeq_X_iter it1, cdeq_X_iter it2);                      // will clone
 cdeq_X_iter         cdeq_X_emplace_range_p(cdeq_X* self, i_val* pos, 
                                            const i_val* p1, const i_val* p2);
 
@@ -66,10 +70,6 @@ cdeq_X_iter         cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
 cdeq_X_iter         cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter it);
 cdeq_X_iter         cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter it1, cdeq_X_iter it2);
 
-cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_valraw raw);
-cdeq_X_iter         cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw);
-cdeq_X_value*       cdeq_X_get(const cdeq_X* self, i_valraw raw);                            // returns NULL if not found
-
 void                cdeq_X_sort(cdeq_X* self);
 void                cdeq_X_sort_range(cdeq_X_iter i1, cdeq_X_iter i2,
                                       int(*cmp)(const i_val*, const i_val*));
diff --git a/docs/clist_api.md b/docs/clist_api.md
index a00b9551..b45108a7 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -42,10 +42,10 @@ clist_X             clist_X_clone(clist_X list);
 
 void                clist_X_clear(clist_X* self);
 void                clist_X_copy(clist_X* self, clist_X other);
-void                clist_X_del(clist_X* self);                                             // destructor
+void                clist_X_del(clist_X* self);                                           // destructor
 
 bool                clist_X_empty(clist_X list);
-size_t              clist_X_count(clist_X list);                                            // size() in O(n) time
+size_t              clist_X_count(clist_X list);                                          // size() in O(n) time
 
 clist_X_value*      clist_X_front(const clist_X* self);
 clist_X_value*      clist_X_back(const clist_X* self);
@@ -54,7 +54,7 @@ void                clist_X_push_front(clist_X* self, i_val value);
 void                clist_X_emplace_front(clist_X* self, i_valraw raw);
 void                clist_X_pop_front(clist_X* self);
 
-void                clist_X_push_back(clist_X* self, i_val value);                          // note: no pop_back().
+void                clist_X_push_back(clist_X* self, i_val value);                        // note: no pop_back().
 void                clist_X_emplace_back(clist_X* self, i_valraw raw);
 
 clist_X_iter        clist_X_insert(clist_X* self, clist_X_iter it, i_val value);          // return iter to new elem
@@ -62,22 +62,24 @@ clist_X_iter        clist_X_emplace(clist_X* self, clist_X_iter it, i_valraw raw
 
 clist_X_iter        clist_X_erase_at(clist_X* self, clist_X_iter it);                     // return iter after it
 clist_X_iter        clist_X_erase_range(clist_X* self, clist_X_iter it1, clist_X_iter it2);
-size_t              clist_X_remove(clist_X* self, i_valraw raw);                            // removes matching elements
+size_t              clist_X_remove(clist_X* self, i_valraw raw);                          // removes matching elements
 
-clist_X             clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2); // split off [i1, i2)
+clist_X             clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2);   // split off [i1, i2)
 clist_X_iter        clist_X_splice(clist_X* self, clist_X_iter it, clist_X* other);       // return updated valid it
 clist_X_iter        clist_X_splice_range(clist_X* self, clist_X_iter it,                  // return updated valid it
                                          clist_X* other, clist_X_iter it1, clist_X_iter it2);
 
 clist_X_iter        clist_X_find(const clist_X* self, i_valraw raw);
 clist_X_iter        clist_X_find_in(clist_X_iter it1, clist_X_iter it2, i_valraw raw);
+const i_val*        clist_X_get(const clist_X* self, i_valraw val);
+i_val*              clist_X_get_mut(clist_X* self, i_valraw val);
 
 void                clist_X_sort(clist_X* self);
 
 clist_X_iter        clist_X_begin(const clist_X* self);
 clist_X_iter        clist_X_end(const clist_X* self);
 void                clist_X_next(clist_X_iter* it);
-clist_X_iter        clist_X_advance(clist_X_iter it, size_t n);                        // return it n elements ahead. End allowed.
+clist_X_iter        clist_X_advance(clist_X_iter it, size_t n);                           // return n elements ahead.
 
 clist_X_rawvalue    clist_X_value_toraw(clist_X_value* pval);
 clist_X_value       clist_X_value_clone(clist_X_value val);
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 9bdafcb9..7f7ffe6f 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -49,15 +49,16 @@ void                cmap_X_shrink_to_fit(cmap_X* self);
 void                cmap_X_swap(cmap_X* a, cmap_X* b);
 void                cmap_X_del(cmap_X* self);                                                 // destructor
 
-bool                cmap_X_empty(cmap_X map);
 size_t              cmap_X_size(cmap_X map);
 size_t              cmap_X_capacity(cmap_X map);                                              // buckets * max_load_factor
+bool                cmap_X_empty(cmap_X map);
 size_t              cmap_X_bucket_count(cmap_X map);                                          // num. of allocated buckets
 
-bool                cmap_X_contains(const cmap_X* self, i_keyraw rkey);
-cmap_X_mapped*      cmap_X_at(const cmap_X* self, i_keyraw rkey);                             // rkey must be in map.
-cmap_X_value*       cmap_X_get(const cmap_X* self, i_keyraw rkey);                            // return NULL if not found
-cmap_X_iter         cmap_X_find(const cmap_X* self, i_keyraw rkey);
+const cmap_X_mapped* cmap_X_at(const cmap_X* self, i_keyraw rkey);                            // rkey must be in map.
+const cmap_X_value*  cmap_X_get(const cmap_X* self, i_keyraw rkey);                           // const get
+cmap_X_value*        cmap_X_get_mut(cmap_X* self, i_keyraw rkey);                             // mutable get
+bool                 cmap_X_contains(const cmap_X* self, i_keyraw rkey);
+cmap_X_iter          cmap_X_find(const cmap_X* self, i_keyraw rkey);                          // find element
 
 cmap_X_result       cmap_X_insert(cmap_X* self, i_key key, i_val mapped);                     // no change if key in map
 cmap_X_result       cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val mapped);           // always update mapped
diff --git a/docs/coption_api.md b/docs/coption_api.md
index f7c870bc..b7eebc43 100644
--- a/docs/coption_api.md
+++ b/docs/coption_api.md
@@ -7,35 +7,33 @@ See [getopt_long](https://www.freebsd.org/cgi/man.cgi?getopt_long(3)) for a simi
 ## Types
 
 ```c
-enum {
-    copt_no_argument = 0,
-    copt_required_argument = 1,
-    copt_optional_argument = 2
-};
-typedef struct {
-    int ind;             /* equivalent to posix optind */
-    int opt;             /* equivalent to posix optopt */
-    const char *arg;     /* equivalent to posix optarg */
-    const char *faulty;  /* points to the faulty option, if any */
-    int longindex;       /* index of long option; or -1 if short */
-    ...
-} coption;
+typedef enum {
+    coption_no_argument,
+    coption_required_argument,
+    coption_optional_argument
+} coption_type;
 
 typedef struct {
     const char *name;
-    int has_arg;
+    coption_type type;
     int val;
 } coption_long;
 
-const coption coption_inits;
+typedef struct {
+    int ind;            /* equivalent to posix optind */
+    int opt;            /* equivalent to posix optopt */
+    const char *optstr; /* points to the option string, if any */
+    const char *arg;    /* equivalent to posix optarg */
+    ...
+} coption;
 ```
 
 ## Methods
 
 ```c
-coption             coption_init(void);
-int                 coption_get(coption *opt, int argc, char *argv[],
-                                const char *shortopts, const coption_long *longopts);
+coption         coption_init(void);
+int             coption_get(coption *opt, int argc, char *argv[],
+                            const char *shortopts, const coption_long *longopts);
 ```
 
 ## Example
@@ -46,13 +44,13 @@ int                 coption_get(coption *opt, int argc, char *argv[],
 
 int main(int argc, char *argv[]) {
     static coption_long long_options[] = {
-      {"verbose", copt_no_argument,       'V'},
-      {"help",    copt_no_argument,       'H'},
-      {"add",     copt_no_argument,       'a'},
-      {"append",  copt_no_argument,       'b'},
-      {"delete",  copt_required_argument, 'd'},
-      {"create",  copt_required_argument, 'c'},
-      {"file",    copt_required_argument, 'f'},
+      {"verbose", coption_no_argument,       'V'},
+      {"help",    coption_no_argument,       'H'},
+      {"add",     coption_no_argument,       'a'},
+      {"append",  coption_no_argument,       'b'},
+      {"delete",  coption_required_argument, 'd'},
+      {"create",  coption_required_argument, 'c'},
+      {"file",    coption_required_argument, 'f'},
       {NULL}
     };
     coption opt = coption_init();
@@ -70,10 +68,10 @@ int main(int argc, char *argv[]) {
                 printf("filename: %s\n", opt.arg);
                 break;
             case ':':
-                printf("option %s needs a value\n", opt.faulty);
+                printf("option %s needs a value\n", opt.optstr);
                 break;
             case '?':
-                printf("unknown option: %s\n", opt.faulty);
+                printf("unknown option: %s\n", opt.optstr);
                 break;
         }
     }
diff --git a/docs/cset_api.md b/docs/cset_api.md
index 04a1617f..8ded9d0c 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -35,13 +35,14 @@ void                cset_X_shrink_to_fit(cset_X* self);
 void                cset_X_swap(cset_X* a, cset_X* b);

 void                cset_X_del(cset_X* self);                                                // destructor

 

-bool                cset_X_empty(cset_X set);

 size_t              cset_X_size(cset_X set);                                                 // num. of allocated buckets

 size_t              cset_X_capacity(cset_X set);                                             // buckets * max_load_factor

+bool                cset_X_empty(cset_X set);

 size_t              cset_X_bucket_count(cset_X set);

 

 bool                cset_X_contains(const cset_X* self, i_keyraw rkey);

-cset_X_value*       cset_X_get(const cset_X* self, i_keyraw rkey);                           // return NULL if not found

+const cset_X_value* cset_X_get(const cset_X* self, i_keyraw rkey);                           // return NULL if not found

+cset_X_value*       cset_X_get_mut(cset_X* self, i_keyraw rkey);                             // mutable get

 cset_X_iter         cset_X_find(const cset_X* self, i_keyraw rkey);

 

 cset_X_result       cset_X_insert(cset_X* self, i_key key);

diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 7a528c7b..646f8c99 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -34,42 +34,46 @@ See the c++ class [std::map](https://en.cppreference.com/w/cpp/container/map) fo
 ## Methods
 
 ```c
-csmap_X             csmap_X_init(void);
-csmap_X             csmap_X_clone(csmap_x map);
-
-void                csmap_X_clear(csmap_X* self);
-void                csmap_X_copy(csmap_X* self, csmap_X other);
-void                csmap_X_swap(csmap_X* a, csmap_X* b);
-void                csmap_X_del(csmap_X* self);                                                  // destructor
-
-bool                csmap_X_empty(csmap_X map);
-size_t              csmap_X_size(csmap_X map);
-
-bool                csmap_X_contains(const csmap_X* self, i_keyraw rkey);
-csmap_X_mapped*     csmap_X_at(const csmap_X* self, i_keyraw rkey);                              // rkey must be in map.
-csmap_X_value*      csmap_X_get(const csmap_X* self, i_keyraw rkey);                             // return NULL if not found
-csmap_X_iter        csmap_X_lower_bound(const csmap_X* self, i_keyraw rkey);                     // find closest entry >= rkey
-csmap_X_iter        csmap_X_find(const csmap_X* self, i_keyraw rkey);
-csmap_X_value*      csmap_X_find_it(const csmap_X* self, i_keyraw rkey, csmap_X_iter* out);      // return NULL if not found
-
-csmap_X_result      csmap_X_insert(csmap_X* self, i_key key, i_val mapped);                      // no change if key in map
-csmap_X_result      csmap_X_insert_or_assign(csmap_X* self, i_key key, i_val mapped);            // always update mapped
-csmap_X_result      csmap_X_put(csmap_X* self, i_key key, i_val mapped);                         // same as insert_or_assign()
-
-csmap_X_result      csmap_X_emplace(csmap_X* self, i_keyraw rkey, i_valraw rmapped);             // no change if rkey in map
-csmap_X_result      csmap_X_emplace_or_assign(csmap_X* self, i_keyraw rkey, i_valraw rmapped);   // always update rmapped
-
-size_t              csmap_X_erase(csmap_X* self, i_keyraw rkey);
-csmap_X_iter        csmap_X_erase_at(csmap_X* self, csmap_X_iter it);                            // returns iter after it
-csmap_X_iter        csmap_X_erase_range(csmap_X* self, csmap_X_iter it1, csmap_X_iter it2);      // returns updated it2
-
-csmap_X_iter        csmap_X_begin(const csmap_X* self);
-csmap_X_iter        csmap_X_end(const csmap_X* self);
-void                csmap_X_next(csmap_X_iter* iter);
-csmap_X_iter        csmap_X_advance(csmap_X_iter it, size_t n);
-
-csmap_X_value       csmap_X_value_clone(csmap_X_value val);
-csmap_X_rawvalue    csmap_X_value_toraw(csmap_X_value* pval);
+csmap_X               csmap_X_init(void);
+csmap_X               csmap_X_clone(csmap_x map);
+
+void                  csmap_X_clear(csmap_X* self);
+void                  csmap_X_copy(csmap_X* self, csmap_X other);
+void                  csmap_X_swap(csmap_X* a, csmap_X* b);
+void                  csmap_X_del(csmap_X* self);                                                // destructor
+
+size_t                csmap_X_size(csmap_X map);
+bool                  csmap_X_empty(csmap_X map);
+
+const csmap_X_mapped* csmap_X_at(const csmap_X* self, i_keyraw rkey);                            // rkey must be in map.
+const csmap_X_value*  csmap_X_get(const csmap_X* self, i_keyraw rkey);                           // return NULL if not found
+csmap_X_value*        csmap_X_get_mut(csmap_X* self, i_keyraw rkey);                             // mutable get
+bool                  csmap_X_contains(const csmap_X* self, i_keyraw rkey);
+csmap_X_iter          csmap_X_find(const csmap_X* self, i_keyraw rkey);
+csmap_X_value*        csmap_X_find_it(const csmap_X* self, i_keyraw rkey, csmap_X_iter* out);    // return NULL if not found
+csmap_X_iter          csmap_X_lower_bound(const csmap_X* self, i_keyraw rkey);                   // find closest entry >= rkey
+
+csmap_X_value*        csmap_X_front(const csmap_X* self);
+csmap_X_value*        csmap_X_back(const csmap_X* self);
+
+csmap_X_result        csmap_X_insert(csmap_X* self, i_key key, i_val mapped);                    // no change if key in map
+csmap_X_result        csmap_X_insert_or_assign(csmap_X* self, i_key key, i_val mapped);          // always update mapped
+csmap_X_result        csmap_X_put(csmap_X* self, i_key key, i_val mapped);                       // same as insert_or_assign()
+
+csmap_X_result        csmap_X_emplace(csmap_X* self, i_keyraw rkey, i_valraw rmapped);           // no change if rkey in map
+csmap_X_result        csmap_X_emplace_or_assign(csmap_X* self, i_keyraw rkey, i_valraw rmapped); // always update rmapped
+
+size_t                csmap_X_erase(csmap_X* self, i_keyraw rkey);
+csmap_X_iter          csmap_X_erase_at(csmap_X* self, csmap_X_iter it);                          // returns iter after it
+csmap_X_iter          csmap_X_erase_range(csmap_X* self, csmap_X_iter it1, csmap_X_iter it2);    // returns updated it2
+
+csmap_X_iter          csmap_X_begin(const csmap_X* self);
+csmap_X_iter          csmap_X_end(const csmap_X* self);
+void                  csmap_X_next(csmap_X_iter* iter);
+csmap_X_iter          csmap_X_advance(csmap_X_iter it, size_t n);
+
+csmap_X_value         csmap_X_value_clone(csmap_X_value val);
+csmap_X_rawvalue      csmap_X_value_toraw(csmap_X_value* pval);
 ```
 ## Types
 
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 41e0063f..501473a6 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -22,35 +22,36 @@ See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) fo
 ## Methods

 

 ```c

-csset_X             csset_X_init(void);

-csset_X             csset_X_clone(csset_x set);

+csset_X              csset_X_init(void);

+csset_X              csset_X_clone(csset_x set);

 

-void                csset_X_clear(csset_X* self);

-void                csset_X_copy(csset_X* self, csset_X other);

-void                csset_X_swap(csset_X* a, csset_X* b);

-void                csset_X_del(csset_X* self);                                               // destructor

+void                 csset_X_clear(csset_X* self);

+void                 csset_X_copy(csset_X* self, csset_X other);

+void                 csset_X_swap(csset_X* a, csset_X* b);

+void                 csset_X_del(csset_X* self);                                              // destructor

 

-bool                csset_X_empty(csset_X set);

-size_t              csset_X_size(csset_X set);

+size_t               csset_X_size(csset_X set);

+bool                 csset_X_empty(csset_X set);

 

-bool                csset_X_contains(const csset_X* self, i_keyraw rkey);

-csset_X_value*      csset_X_get(const csset_X* self, i_keyraw rkey);                          // return NULL if not found

-csset_X_iter        csset_X_lower_bound(const csset_X* self, i_keyraw rkey);                  // find closest entry >= rkey

-csset_X_iter        csset_X_find(const csset_X* self, i_keyraw rkey);

-csset_X_value*      csset_X_find_it(const csset_X* self, i_keyraw rkey, csset_X_iter* out);   // return NULL if not found

+const csset_X_value* csset_X_get(const csset_X* self, i_keyraw rkey);                         // const get

+csset_X_value*       csset_X_get_mut(csset_X* self, i_keyraw rkey);                           // return NULL if not found

+bool                 csset_X_contains(const csset_X* self, i_keyraw rkey);

+csset_X_iter         csset_X_find(const csset_X* self, i_keyraw rkey);

+csset_X_value*       csset_X_find_it(const csset_X* self, i_keyraw rkey, csset_X_iter* out);  // return NULL if not found

+csset_X_iter         csset_X_lower_bound(const csset_X* self, i_keyraw rkey);                 // find closest entry >= rkey

 

-csset_X_result      csset_X_insert(csset_X* self, i_key key);

-csset_X_result      csset_X_emplace(csset_X* self, i_keyraw rkey);

+csset_X_result       csset_X_insert(csset_X* self, i_key key);

+csset_X_result       csset_X_emplace(csset_X* self, i_keyraw rkey);

 

-size_t              csset_X_erase(csset_X* self, i_keyraw rkey);

-csset_X_iter        csset_X_erase_at(csset_X* self, csset_X_iter it);                         // return iter after it

-csset_X_iter        csset_X_erase_range(csset_X* self, csset_X_iter it1, csset_X_iter it2);   // return updated it2

+size_t               csset_X_erase(csset_X* self, i_keyraw rkey);

+csset_X_iter         csset_X_erase_at(csset_X* self, csset_X_iter it);                         // return iter after it

+csset_X_iter         csset_X_erase_range(csset_X* self, csset_X_iter it1, csset_X_iter it2);   // return updated it2

 

-csset_X_iter        csset_X_begin(const csset_X* self);

-csset_X_iter        csset_X_end(const csset_X* self);

-void                csset_X_next(csset_X_iter* it);

+csset_X_iter         csset_X_begin(const csset_X* self);

+csset_X_iter         csset_X_end(const csset_X* self);

+void                 csset_X_next(csset_X_iter* it);

 

-csset_X_value       csset_X_value_clone(csset_X_value val);

+csset_X_value        csset_X_value_clone(csset_X_value val);

 ```

 

 ## Types

diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index a1edf9ea..25cbcfb7 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -36,8 +36,9 @@ void                cstack_X_del(cstack_X* self);       // destructor
 size_t              cstack_X_size(cstack_X st);
 size_t              cstack_X_capacity(cstack_X st);
 bool                cstack_X_empty(cstack_X st);
-cstack_X_value*     cstack_X_top(const cstack_X* self);
-cstack_X_value*     cstack_X_at(const cstack_X* self, size_t idx);
+
+cstack_X_value*       cstack_X_top(const cstack_X* self);
+const cstack_X_value* cstack_X_at(const cstack_X* self, size_t idx);
 
 cstack_X_value*     cstack_X_push(cstack_X* self, i_val value);
 cstack_X_value*     cstack_X_emplace(cstack_X* self, i_valraw raw);
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 42ec944e..64ca724f 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -35,9 +35,9 @@ cvec_X              cvec_X_clone(cvec_X vec);
 
 void                cvec_X_clear(cvec_X* self);
 void                cvec_X_copy(cvec_X* self, cvec_X other);
-void                cvec_X_shrink_to_fit(cvec_X* self);
 void                cvec_X_reserve(cvec_X* self, size_t cap);
 void                cvec_X_resize(cvec_X* self, size_t size, i_val fill);
+void                cvec_X_shrink_to_fit(cvec_X* self);
 void                cvec_X_swap(cvec_X* a, cvec_X* b);
 void                cvec_X_del(cvec_X* self);                                                // destructor
 
@@ -45,7 +45,14 @@ bool                cvec_X_empty(cvec_X vec);
 size_t              cvec_X_size(cvec_X vec);
 size_t              cvec_X_capacity(cvec_X vec);
 
-cvec_X_value*       cvec_X_at(const cvec_X* self, size_t idx);
+const cvec_X_value* cvec_X_at(const cvec_X* self, size_t idx);
+const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw);                            // return NULL if not found
+cvec_X_value*       cvec_X_get_mut(cvec_X* self, i_valraw raw);                               // get mutable value
+cvec_X_iter         cvec_X_find(const cvec_X* self, i_valraw raw);
+cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
+cvec_X_iter         cvec_X_bsearch(const cvec_X* self, i_valraw raw);
+cvec_X_iter         cvec_X_bsearch_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
+
 cvec_X_value*       cvec_X_front(const cvec_X* self);
 cvec_X_value*       cvec_X_back(const cvec_X* self);
 
@@ -69,12 +76,6 @@ cvec_X_iter         cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
 cvec_X_iter         cvec_X_erase_at(cvec_X* self, cvec_X_iter it);
 cvec_X_iter         cvec_X_erase_range(cvec_X* self, cvec_X_iter it1, cvec_X_iter it2);
 
-cvec_X_iter         cvec_X_find(const cvec_X* self, i_valraw raw);
-cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
-cvec_X_value*       cvec_X_get(const cvec_X* self, i_valraw raw);                            // return NULL if not found
-cvec_X_iter         cvec_X_bsearch(const cvec_X* self, i_valraw raw);
-cvec_X_iter         cvec_X_bsearch_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
-
 void                cvec_X_sort(cvec_X* self);
 void                cvec_X_sort_range(cvec_X_iter i1, cvec_X_iter i2,
                                       int(*cmp)(const i_val*, const i_val*));
diff --git a/examples/astar.c b/examples/astar.c
index 04c18113..7410de96 100644
--- a/examples/astar.c
+++ b/examples/astar.c
@@ -107,7 +107,7 @@ astar(cstr* maze, int width)
                 int new_cost = *csmap_pcost_at(&costs, current);

                 if (maze->str[point_index(&next)] != '#')

                 {

-                    csmap_pcost_value *cost = csmap_pcost_get(&costs, next);

+                    const csmap_pcost_value *cost = csmap_pcost_get(&costs, next);

                     if (cost == NULL || new_cost < cost->second)

                     {

                         csmap_pcost_insert(&costs, next, new_cost);

diff --git a/examples/complex.c b/examples/complex.c
index 69900bba..32dd82eb 100644
--- a/examples/complex.c
+++ b/examples/complex.c
@@ -53,10 +53,10 @@ int main() {
         cmap_map_insert(&myMap, cstr_from(strKey), listMap);

 

         // Access the data entry

-        cmap_lst* mapL = &cmap_map_find(&myMap, strKey).ref->second;

-        clist_arr* lstA = &cmap_lst_find(mapL, tableKey).ref->second;

-        cstack_f arr = *clist_arr_back(lstA);

-        printf("value (%d) is: %f\n", x, arr.data[x]);

+        const cmap_lst* mapL = cmap_map_at(&myMap, strKey);

+        const clist_arr* lstA = cmap_lst_at(mapL, tableKey);

+        const cstack_f* arr = clist_arr_back(lstA);

+        printf("value (%d) is: %f\n", x, *cstack_f_at(arr, x));

 

         stk.data[x] = 1.41421356f; // change the value in array

     }

diff --git a/examples/mapmap.c b/examples/mapmap.c
index 047132d1..73a00861 100644
--- a/examples/mapmap.c
+++ b/examples/mapmap.c
@@ -19,7 +19,7 @@ void add(csmap_conf* map, const char* section, const char* entry, const char* va
 

 bool contains(csmap_conf* map, const char* section, const char* entry)

 {

-    csmap_conf_value *val = csmap_conf_get(map, section);

+    const csmap_conf_value *val = csmap_conf_get(map, section);

     return val && csmap_sect_get(&val->second, entry);

 }

 

diff --git a/examples/stack.c b/examples/stack.c
index 54d5aeed..dac0112e 100644
--- a/examples/stack.c
+++ b/examples/stack.c
@@ -11,9 +11,8 @@
 #include <stc/cstack.h>

 

 int main() {

-    cstack_i stack = cstack_i_init();

-    cstack_c chars = cstack_c_init();

-    c_autodefer (cstack_i_del(&stack), cstack_c_del(&chars))

+    c_auto (cstack_i, stack)

+    c_auto (cstack_c, chars)

     {

         c_forrange (i, int, 101)

             cstack_i_push(&stack, i*i);

diff --git a/benchmarks/others/old/clist.h b/include/stc/alt/clist.h
index ea1bb9a5..ea1bb9a5 100644
--- a/benchmarks/others/old/clist.h
+++ b/include/stc/alt/clist.h
diff --git a/benchmarks/others/old/csmap.h b/include/stc/alt/csmap.h
index 699e18c1..699e18c1 100644
--- a/benchmarks/others/old/csmap.h
+++ b/include/stc/alt/csmap.h
diff --git a/include/stc/alt/cstr.h b/include/stc/alt/cstr.h
index 98a090e0..39da2e6a 100644
--- a/include/stc/alt/cstr.h
+++ b/include/stc/alt/cstr.h
@@ -274,7 +274,7 @@ STC_DEF void cstr_internal_move_(cstr* self, size_t pos1, size_t pos2) {
     cstr_rep_t rep = cstr_rep_(self);

     cstr_size_t newlen = rep.size + pos2 - pos1;

     if (newlen > rep.cap)

-        rep.data = cstr_reserve(self, (rep.size*13 >> 3) + pos2 - pos1);

+        rep.data = cstr_reserve(self, (rep.size*3 >> 1) + pos2 - pos1);

     memmove(&rep.data[pos2], &rep.data[pos1], rep.size - pos1);

     cstr_set_size_(self, newlen);

 }

@@ -368,7 +368,7 @@ STC_DEF void cstr_append_n(cstr* self, const char* str, cstr_size_t n) {
     cstr_rep_t rep = cstr_rep_(self);

     if (rep.size + n > rep.cap) {

         cstr_size_t off = (cstr_size_t)(str - rep.data); /* handle self append */

-        rep.data = cstr_reserve(self, (rep.size*13 >> 3) + n);

+        rep.data = cstr_reserve(self, (rep.size*3 >> 1) + n);

         if (off <= rep.size) str = rep.data + off;

     }

     memcpy(rep.data + rep.size, str, n);

@@ -388,7 +388,7 @@ STC_DEF bool cstr_getdelim(cstr *self, int delim, FILE *fp) {
         }

         if (pos == rep.cap) {

             cstr_set_size_(self, pos);

-            rep.data = cstr_reserve(self, (rep.cap = (rep.cap*13 >> 3) + 16));

+            rep.data = cstr_reserve(self, (rep.cap = (rep.cap*3 >> 1) + 16));

         }

         rep.data[pos++] = (char) c;

         c = fgetc(fp);

diff --git a/benchmarks/others/old/sstr.h b/include/stc/alt/sstr.h
index 68b724a8..2ea1033d 100644
--- a/benchmarks/others/old/sstr.h
+++ b/include/stc/alt/sstr.h
@@ -274,7 +274,7 @@ STC_DEF void sstr_internal_move_(sstr* self, size_t pos1, size_t pos2) {
     sstr_rep_t rep = sstr_rep_(self);

     sstr_size_t newlen = rep.size + pos2 - pos1;

     if (newlen > rep.cap)

-        rep.data = sstr_reserve(self, (rep.size*13 >> 3) + pos2 - pos1);

+        rep.data = sstr_reserve(self, (rep.size*3 >> 1) + pos2 - pos1);

     memmove(&rep.data[pos2], &rep.data[pos1], rep.size - pos1);

     sstr_set_size_(self, newlen);

 }

@@ -368,7 +368,7 @@ STC_DEF void sstr_append_n(sstr* self, const char* str, sstr_size_t n) {
     sstr_rep_t rep = sstr_rep_(self);

     if (rep.size + n > rep.cap) {

         sstr_size_t off = (sstr_size_t)(str - rep.data); /* handle self append */

-        rep.data = sstr_reserve(self, (rep.size*13 >> 3) + n);

+        rep.data = sstr_reserve(self, (rep.size*3 >> 1) + n);

         if (off <= rep.size) str = rep.data + off;

     }

     memcpy(rep.data + rep.size, str, n);

@@ -388,7 +388,7 @@ STC_DEF bool sstr_getdelim(sstr *self, int delim, FILE *fp) {
         }

         if (pos == rep.cap) {

             sstr_set_size_(self, pos);

-            rep.data = sstr_reserve(self, (rep.cap = (rep.cap*13 >> 3) + 16));

+            rep.data = sstr_reserve(self, (rep.cap = (rep.cap*3 >> 1) + 16));

         }

         rep.data[pos++] = (char) c;

         c = fgetc(fp);

diff --git a/include/stc/carr2.h b/include/stc/carr2.h
index 3f9d1540..b961c47e 100644
--- a/include/stc/carr2.h
+++ b/include/stc/carr2.h
@@ -76,8 +76,10 @@ STC_INLINE size_t _cx_memb(_size)(_cx_self arr)
 STC_INLINE _cx_value *_cx_memb(_data)(_cx_self* self)
     { return *self->data; }
 
-STC_INLINE _cx_value *_cx_memb(_at)(_cx_self* self, size_t x, size_t y)
-    { return *self->data + self->ydim*x + y; }
+STC_INLINE const _cx_value *_cx_memb(_at)(const _cx_self* self, size_t x, size_t y) {
+    assert(x < self->xdim && y < self->ydim);
+    return *self->data + self->ydim*x + y;
+}
 
 STC_INLINE void _cx_memb(_copy)(_cx_self *self, _cx_self other) {
     if (self->data == other.data) return;
diff --git a/include/stc/carr3.h b/include/stc/carr3.h
index 1133dcc3..3f230204 100644
--- a/include/stc/carr3.h
+++ b/include/stc/carr3.h
@@ -78,8 +78,10 @@ STC_INLINE size_t _cx_memb(_size)(_cx_self arr)
 STC_INLINE _cx_value* _cx_memb(_data)(_cx_self* self)
     { return **self->data; }
 
-STC_INLINE _cx_value* _cx_memb(_at)(_cx_self* self, size_t x, size_t y, size_t z)
-    { return **self->data + self->zdim*(self->ydim*x + y) + z; }
+STC_INLINE const _cx_value* _cx_memb(_at)(const _cx_self* self, size_t x, size_t y, size_t z) {
+    assert(x < self->xdim && y < self->ydim && z < self->zdim);
+    return **self->data + self->zdim*(self->ydim*x + y) + z;
+}
 
 STC_INLINE void _cx_memb(_copy)(_cx_self *self, _cx_self other) {
     if (self->data == other.data) return;
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 6e6aefd2..4f97344c 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -73,20 +73,23 @@
 #define c_container_of(ptr, type, member) \

     ((type *)((char *)(ptr) - offsetof(type, member)))

 

-#if __cplusplus

-#define c_new(T)                static_cast<T*>(c_malloc(sizeof(T)))

-#define c_new_n(T, n)           static_cast<T*>(c_malloc(sizeof(T)*(n)))

-#define c_make(T)               T

+#ifndef __cplusplus

+#  define c_new(T)              c_malloc(sizeof(T))

+#  define c_new_n(T, n)         c_malloc(sizeof(T)*(n))

+#  define c_make(T)             (T)

+#  define c_make_ptr(T, ...)    memcpy(c_new(T), (T[]){__VA_ARGS__}, sizeof(T))

 #else

-#define c_new(T)                c_malloc(sizeof(T))

-#define c_new_n(T, n)           c_malloc(sizeof(T)*(n))

-#define c_make(T)               (T)

+#  include <new>

+#  define c_new(T)              static_cast<T*>(c_malloc(sizeof(T)))

+#  define c_new_n(T, n)         static_cast<T*>(c_malloc(sizeof(T)*(n)))

+#  define c_make(T)             T

+#  define c_make_ptr(T, ...)    new (c_new(T)) T{__VA_ARGS__}

 #endif

 #ifndef c_malloc

-#define c_malloc(sz)            malloc(sz)

-#define c_calloc(n, sz)         calloc(n, sz)

-#define c_realloc(p, sz)        realloc(p, sz)

-#define c_free(p)               free(p)

+#  define c_malloc(sz)          malloc(sz)

+#  define c_calloc(n, sz)       calloc(n, sz)

+#  define c_realloc(p, sz)      realloc(p, sz)

+#  define c_free(p)             free(p)

 #endif

 

 #define c_swap(T, x, y)         do { T _c_t = x; x = y; y = _c_t; } while (0)

@@ -110,20 +113,27 @@
 

 #define c_default_del(ptr)      ((void) (ptr))

 

+/* Generic algorithms */

+

 #define _c_rotl(x, k) (x << (k) | x >> (8*sizeof(x) - (k)))

-STC_INLINE uint64_t c_strhash(const char *str) {

-    int c; uint64_t h = 0xb5ad4eceda1ce2a9;

-    while ((c = *str++)) h = (_c_rotl(h, 4) ^ (h << 13)) + c;

-    return h ^ (h >> 15);

+

+STC_INLINE uint64_t c_strhash(const char *s) {

+    int c; uint64_t h = *s++;

+    if (h) while ((c = *s++)) h = (h << 10) - h + c;

+    return _c_rotl(h, 26) ^ h;

+}

+// len = 2,4,6,...:

+STC_INLINE uint64_t c_default_hash(const void* key, size_t len) {

+    const uint16_t *x = (const uint16_t*) key; 

+    uint64_t h = *x++; h += h << 14;

+    while ((len -= 2)) h = (h << 10) - h + *x++;

+    return _c_rotl(h, 24) ^ h;

 }

-STC_INLINE uint64_t c_default_hash(const void *key, size_t len);

 #define c_default_hash32(data, len_is_4) \

     ((*(const uint32_t*)data * 0xc6a4a7935bd1e99d) >> 15)

 #define c_default_hash64(data, len_is_8) \

     (*(const uint64_t *)data * 0xc6a4a7935bd1e99d)

 

-/* Generic algorithms */

-

 #define c_foreach(...) c_MACRO_OVERLOAD(c_foreach, __VA_ARGS__)

 #define c_foreach_3(it, CX, cnt) \

     for (CX##_iter it = CX##_begin(&cnt), it##_end_ = CX##_end(&cnt) \

diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h
index ab454247..bd7085c7 100644
--- a/include/stc/cdeq.h
+++ b/include/stc/cdeq.h
@@ -112,7 +112,7 @@ STC_INLINE void _cx_memb(_pop_back)(_cx_self* self) {
     i_valdel(p);

 }

 

-STC_INLINE _cx_value* _cx_memb(_at)(const _cx_self* self, size_t idx) {

+STC_INLINE const _cx_value* _cx_memb(_at)(const _cx_self* self, size_t idx) {

     assert(idx < cdeq_rep_(self)->size); 

     return self->data + idx;

 }

@@ -175,13 +175,17 @@ _cx_memb(_find)(const _cx_self* self, i_valraw raw) {
     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_valraw raw) {

     _cx_iter end = _cx_memb(_end)(self);

     _cx_value* val = _cx_memb(_find_in)(_cx_memb(_begin)(self), end, raw).ref;

     return val == end.ref ? NULL : val;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_get_mut)(_cx_self* self, i_valraw raw)

+    { return (_cx_value *) _cx_memb(_get)(self, raw); }

+

 STC_INLINE void

 _cx_memb(_sort_range)(_cx_iter i1, _cx_iter i2,

                 int(*_cmp_)(const _cx_value*, const _cx_value*)) {

diff --git a/include/stc/clist.h b/include/stc/clist.h
index a97c9526..037d5104 100644
--- a/include/stc/clist.h
+++ b/include/stc/clist.h
@@ -166,11 +166,16 @@ _cx_memb(_find)(const _cx_self* self, i_valraw val) {
     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), val);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_valraw val) {

     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), val).ref;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_get_mut)(_cx_self* self, i_valraw val) {

+    return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), val).ref;

+}

+

 // -------------------------- IMPLEMENTATION -------------------------

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp)

diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 0c5aab4e..2d0a81f7 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -117,7 +117,7 @@ cx_MAP_ONLY(
         return _cx_memb(_insert_or_assign)(self, key, mapped);

     }

 

-    STC_INLINE _cx_mapped*

+    STC_INLINE const _cx_mapped*

     _cx_memb(_at)(const _cx_self* self, i_keyraw rkey) {

         chash_bucket_t b = _cx_memb(_bucket_)(self, &rkey);

         assert(self->_hashx[b.idx]);

@@ -169,13 +169,17 @@ _cx_memb(_find)(const _cx_self* self, i_keyraw rkey) {
     return c_make(_cx_iter){self->table+idx, self->_hashx+idx};

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_keyraw rkey) {

     _cx_size idx;

     return self->size && self->_hashx[idx = _cx_memb(_bucket_)(self, &rkey).idx] ?

            self->table + idx : NULL;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_get_mut)(const _cx_self* self, i_keyraw rkey)

+    { return (_cx_value*) _cx_memb(_get)(self, rkey); }

+

 STC_INLINE _cx_iter

 _cx_memb(_begin)(const _cx_self* self) {

     _cx_iter it = {self->table, self->_hashx};

@@ -217,13 +221,6 @@ _cx_memb(_erase_at)(_cx_self* self, _cx_iter it) {
 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp)

 

 #ifndef CMAP_H_INCLUDED

-STC_INLINE uint64_t c_default_hash(const void *key, size_t len) {

-    const char* str = (const char*)key, *e = str + len;

-    uint64_t h = 0xb5ad4eceda1ce2a9;

-    while (str != e) h = (_c_rotl(h, 4) ^ (h << 13)) + *str++;

-    return h ^ (h >> 15);

-}

-

 //STC_INLINE size_t fastrange_uint64_t(uint64_t x, uint64_t n)

 //    { uint64_t lo, hi; c_umul128(x, n, &lo, &hi); return hi; }

 #define fastrange_uint32_t(x, n) (uint32_t)((uint32_t)(x)*(uint64_t)(n) >> 32)

@@ -298,7 +295,7 @@ _cx_memb(_bucket_)(const _cx_self* self, const _cx_rawkey* rkeyptr) {
 STC_DEF _cx_result

 _cx_memb(_insert_entry_)(_cx_self* self, i_keyraw rkey) {

     if (self->size + 1 >= (_cx_size) (self->bucket_count * self->max_load_factor))

-        _cx_memb(_reserve)(self, 8 + (self->size*13ull >> 3));

+        _cx_memb(_reserve)(self, ((size_t)self->size*3 >> 1) + 4);

     chash_bucket_t b = _cx_memb(_bucket_)(self, &rkey);

     _cx_result res = {&self->table[b.idx], !self->_hashx[b.idx]};

     if (res.inserted) {

diff --git a/include/stc/coption.h b/include/stc/coption.h
new file mode 100644
index 00000000..fb61bf2b
--- /dev/null
+++ b/include/stc/coption.h
@@ -0,0 +1,180 @@
+/* MIT License

+ *

+ * Copyright (c) 2021 Tyge Løvset, NORCE, www.norceresearch.no

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+ * copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ */

+/*

+Inspired by https://attractivechaos.wordpress.com/2018/08/31/a-survey-of-argument-parsing-libraries-in-c-c

+Fixed major bugs with optional arguments (both long and short).

+Added arg->optstr output field, more consistent API.

+

+coption_get() is similar to GNU's getopt_long(). Each call parses one option and

+returns the option name. opt->arg points to  the option argument if present.

+The function returns -1 when all command-line arguments are parsed. In this case,

+opt->ind is the index of the first non-option argument.

+

+#include <stdio.h>

+#include <stc/coption.h>

+

+int main(int argc, char *argv[])

+{

+    coption_long longopts[] = {

+        {"foo", coption_no_argument,       'f'},

+        {"bar", coption_required_argument, 'b'},

+        {"opt", coption_optional_argument, 'o'},

+        {0}

+    };

+    const char* optstr = "xy:z::123";

+    printf("program -x -y ARG -z [ARG] -1 -2 -3 --foo --bar ARG --opt [ARG] [ARGUMENTS]\n");

+    int c;

+    coption opt = coption_init();

+    while ((c = coption_get(&opt, argc, argv, optstr, longopts)) != -1) {

+        switch (c) {

+            case '?': printf("error: unknown option: %s\n", opt.optstr); break;

+            case ':': printf("error: missing argument for %s (%c)\n", opt.optstr, opt.opt); break;

+            default:  printf("option: %c [%s]\n", opt.opt, opt.arg ? opt.arg : ""); break;

+        }

+    }

+    printf("\nNon-option arguments:");

+    for (int i = opt.ind; i < argc; ++i)

+        printf(" %s", argv[i]);

+    putchar('\n');

+    return 0;

+}

+*/

+#ifndef COPTION_H_INCLUDED

+#define COPTION_H_INCLUDED

+

+#include <string.h>

+#include <stdbool.h>

+

+typedef enum {

+    coption_no_argument,

+    coption_required_argument,

+    coption_optional_argument

+} coption_type;

+

+typedef struct {

+    const char *name;

+    coption_type type;

+    int val;

+} coption_long;

+

+typedef struct {

+    int ind;            /* equivalent to optind */

+    int opt;            /* equivalent to optopt */

+    const char *optstr; /* points to the option string */

+    const char *arg;    /* equivalent to optarg */

+    int _i, _pos, _nargs;

+    char _optstr[4];

+} coption;

+

+static inline coption coption_init(void) {

+     coption opt = {1, 0, NULL, NULL, 1, 0, 0, {'-', '?', '\0'}};

+     return opt;

+}

+

+/* move argv[j] over n elements to the left */

+static void coption_permute_(char *argv[], int j, int n) {

+    int k;

+    char *p = argv[j];

+    for (k = 0; k < n; ++k)

+        argv[j - k] = argv[j - k - 1];

+    argv[j - k] = p;

+}

+

+/* @param opt   output; must be initialized to coption_init() on first call

+ * @return      ASCII val for a short option; longopt.val for a long option;

+ *              -1 if argv[] is fully processed; '?' for an unknown option or

+ *              an ambiguous long option; ':' if an option argument is missing

+ */

+static int coption_get(coption *opt, int argc, char *argv[],

+                       const char *shortopts, const coption_long *longopts) {

+    int optc = -1, i0, j, posixly_correct = (shortopts[0] == '+');

+    if (!posixly_correct) {

+        while (opt->_i < argc && (argv[opt->_i][0] != '-' || argv[opt->_i][1] == '\0'))

+            ++opt->_i, ++opt->_nargs;

+    }

+    opt->opt = 0, opt->optstr = NULL, opt->arg = NULL, i0 = opt->_i;

+    if (opt->_i >= argc || argv[opt->_i][0] != '-' || argv[opt->_i][1] == '\0') {

+        opt->ind = opt->_i - opt->_nargs;

+        return -1;

+    }

+    if (argv[opt->_i][0] == '-' && argv[opt->_i][1] == '-') { /* "--" or a long option */

+        if (argv[opt->_i][2] == '\0') { /* a bare "--" */

+            coption_permute_(argv, opt->_i, opt->_nargs);

+            ++opt->_i, opt->ind = opt->_i - opt->_nargs;

+            return -1;

+        }

+        optc = '?', opt->_pos = -1;

+        if (longopts) { /* parse long options */

+            int k, n_exact = 0, n_partial = 0;

+            const coption_long *o = 0, *o_exact = 0, *o_partial = 0;

+            for (j = 2; argv[opt->_i][j] != '\0' && argv[opt->_i][j] != '='; ++j) {} /* find the end of the option name */

+            for (k = 0; longopts[k].name != 0; ++k)

+                if (strncmp(&argv[opt->_i][2], longopts[k].name, j - 2) == 0) {

+                    if (longopts[k].name[j - 2] == 0) ++n_exact, o_exact = &longopts[k];

+                    else ++n_partial, o_partial = &longopts[k];

+                }

+            opt->optstr = argv[opt->_i];

+            if (n_exact > 1 || (n_exact == 0 && n_partial > 1)) return '?';

+            o = n_exact == 1? o_exact : n_partial == 1? o_partial : 0;

+            if (o) {

+                opt->opt = optc = o->val;

+                if (o->type != coption_no_argument) {

+                    if (argv[opt->_i][j] == '=') 

+                        opt->arg = &argv[opt->_i][j + 1];

+                    else if (argv[opt->_i][j] == '\0' && opt->_i < argc - 1 && (o->type == coption_required_argument ||

+                                                                                argv[opt->_i + 1][0] != '-'))

+                        opt->arg = argv[++opt->_i];

+                    else if (o->type == coption_required_argument)

+                        optc = ':'; /* missing option argument */

+                }

+            }

+        }

+    } else { /* a short option */

+        const char *p;

+        if (opt->_pos == 0) opt->_pos = 1;

+        optc = opt->opt = argv[opt->_i][opt->_pos++];

+        opt->_optstr[1] = optc, opt->optstr = opt->_optstr;

+        p = strchr((char *) shortopts, optc);

+        if (p == 0) {

+            optc = '?'; /* unknown option */

+        } else if (p[1] == ':') {

+            if (argv[opt->_i][opt->_pos] != '\0')

+                opt->arg = &argv[opt->_i][opt->_pos];

+            else if (opt->_i < argc - 1 && (p[2] != ':' || argv[opt->_i + 1][0] != '-')) 

+                opt->arg = argv[++opt->_i];

+            else if (p[2] != ':')

+                optc = ':';

+            opt->_pos = -1;

+        }

+    }

+    if (opt->_pos < 0 || argv[opt->_i][opt->_pos] == 0) {

+        ++opt->_i, opt->_pos = 0;

+        if (opt->_nargs > 0) /* permute */

+            for (j = i0; j < opt->_i; ++j)

+                coption_permute_(argv, j, opt->_nargs);

+    }

+    opt->ind = opt->_i - opt->_nargs;

+    return optc;

+}

+

+#endif
\ No newline at end of file
diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index 3319d435..2a0e6b89 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -114,7 +114,9 @@ STC_INLINE void         _cx_memb(_clear)(_cx_self* self) { _cx_memb(_del)(self);
 STC_INLINE void         _cx_memb(_swap)(_cx_self* a, _cx_self* b) { c_swap(_cx_self, *a, *b); }

 STC_INLINE bool         _cx_memb(_contains)(const _cx_self* self, i_keyraw rkey)

                             { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it) != NULL; }

-STC_INLINE _cx_value*   _cx_memb(_get)(const _cx_self* self, i_keyraw rkey)

+STC_INLINE const _cx_value* _cx_memb(_get)(const _cx_self* self, i_keyraw rkey)

+                            { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it); }

+STC_INLINE _cx_value*   _cx_memb(_get_mut)(_cx_self* self, i_keyraw rkey)

                             { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it); }

 

 STC_INLINE _cx_self

@@ -156,7 +158,7 @@ cx_MAP_ONLY(
     _cx_memb(_put)(_cx_self* self, i_key key, i_val mapped)

         { return _cx_memb(_insert_or_assign)(self, key, mapped); }

 

-    STC_INLINE _cx_mapped*

+    STC_INLINE const _cx_mapped*

     _cx_memb(_at)(const _cx_self* self, i_keyraw rkey)

         { _cx_iter it; return &_cx_memb(_find_it)(self, rkey, &it)->second; }

 )

@@ -256,7 +258,7 @@ _cx_memb(_node_new_)(_cx_self* self, int level) {
         tn = rep->disp;

         rep->disp = self->nodes[tn].link[1];

     } else {

-        if ((tn = rep->head + 1) > rep->cap) _cx_memb(_reserve)(self, 4 + (tn*13 >> 3));

+        if ((tn = rep->head + 1) > rep->cap) _cx_memb(_reserve)(self, 4 + (tn*3 >> 1));

         ++_csmap_rep(self)->head; /* do after reserve */

     }

     _cx_node* dn = &self->nodes[tn];

diff --git a/include/stc/cstr.h b/include/stc/cstr.h
index c0a6650b..d07b3ce3 100644
--- a/include/stc/cstr.h
+++ b/include/stc/cstr.h
@@ -269,7 +269,7 @@ cstr_append_n(cstr* self, const char* str, size_t n) {
     size_t oldlen = _cstr_rep(self)->size, newlen = oldlen + n;

     if (newlen > _cstr_rep(self)->cap) {

         size_t off = (size_t) (str - self->str); /* handle self append */

-        cstr_reserve(self, (oldlen*13 >> 3) + n);

+        cstr_reserve(self, (oldlen*3 >> 1) + n);

         if (off <= oldlen) str = self->str + off;

     }

     memcpy(&self->str[oldlen], str, n);

@@ -282,7 +282,7 @@ STC_INLINE void _cstr_internal_move(cstr* self, size_t pos1, size_t pos2) {
         return;

     size_t len = _cstr_rep(self)->size, newlen = len + pos2 - pos1;

     if (newlen > _cstr_rep(self)->cap)

-        cstr_reserve(self, (len*13 >> 3) + pos2 - pos1);

+        cstr_reserve(self, (len*3 >> 1) + pos2 - pos1);

     memmove(&self->str[pos2], &self->str[pos1], len - pos1);

     self->str[_cstr_rep(self)->size = newlen] = '\0';

 }

@@ -343,7 +343,7 @@ cstr_getdelim(cstr *self, int delim, FILE *fp) {
             return true;

         }

         if (pos == cap)

-            cap = cstr_reserve(self, (cap*13 >> 3) + 16);

+            cap = cstr_reserve(self, (cap*3 >> 1) + 16);

         self->str[pos++] = (char) c;

         c = fgetc(fp);

     }

diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index 92c8f5bd..e58e8793 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -186,7 +186,7 @@ _cx_memb(_erase_range)(_cx_self* self, _cx_iter it1, _cx_iter it2) {
     return _cx_memb(_erase_range_p)(self, it1.ref, it2.ref);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_at)(const _cx_self* self, size_t idx) {

     assert(idx < cvec_rep_(self)->size);

     return self->data + idx;

@@ -197,17 +197,21 @@ _cx_memb(_find)(const _cx_self* self, i_valraw raw) {
     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_valraw raw) {

     _cx_iter end = _cx_memb(_end)(self);

     _cx_value* val = _cx_memb(_find_in)(_cx_memb(_begin)(self), end, raw).ref;

     return val == end.ref ? NULL : val;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_get_mut)(const _cx_self* self, i_valraw raw)

+    { return (_cx_value*) _cx_memb(_get)(self, raw); }

+

 STC_INLINE _cx_iter

-_cx_memb(_bsearch)(const _cx_self* self, i_valraw raw) {

-    return _cx_memb(_bsearch_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);

-}

+_cx_memb(_bsearch)(const _cx_self* self, i_valraw raw)

+    { return _cx_memb(_bsearch_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw); }

+

 STC_INLINE void

 _cx_memb(_sort_range)(_cx_iter i1, _cx_iter i2,

                      int(*_cmp_)(const _cx_value*, const _cx_value*)) {

@@ -276,7 +280,7 @@ STC_DEF _cx_value*
 _cx_memb(_push_back)(_cx_self* self, i_val value) {

     size_t len = cvec_rep_(self)->size;

     if (len == _cx_memb(_capacity)(*self))

-        _cx_memb(_reserve)(self, (len*13 >> 3) + 4);

+        _cx_memb(_reserve)(self, (len*3 >> 1) + 4);

     _cx_value *v = self->data + cvec_rep_(self)->size++;

     *v = value; return v;

 }

@@ -294,7 +298,7 @@ _cx_memb(_insert_space_)(_cx_self* self, _cx_value* pos, size_t len) {
     size_t idx = pos - self->data, size = cvec_rep_(self)->size;

     if (len == 0) return pos;

     if (size + len > _cx_memb(_capacity)(*self))

-        _cx_memb(_reserve)(self, (size*13 >> 3) + len),

+        _cx_memb(_reserve)(self, (size*3 >> 1) + len),

         pos = self->data + idx;

     cvec_rep_(self)->size += len;

     memmove(pos + len, pos, (size - idx) * sizeof(i_val));