Added Sparsepp hashmap from Greg to benchmark comparison.

9 files changed, 10120 insertions, 0 deletions

diff --git a/examples/others/sparsepp/spp.h b/examples/others/sparsepp/spp.h
new file mode 100644
index 00000000..35d58492
--- /dev/null
+++ b/examples/others/sparsepp/spp.h
@@ -0,0 +1,4358 @@
+#if !defined(sparsepp_h_guard_)
+#define sparsepp_h_guard_
+
+
+// ----------------------------------------------------------------------
+// Copyright (c) 2016, Gregory Popovitch - [email protected]
+// All rights reserved.
+//
+// This work is derived from Google's sparsehash library
+//
+// Copyright (c) 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// ----------------------------------------------------------------------
+
+
+// some macros for portability
+// ---------------------------
+// includes
+// --------
+#include <cassert>
+#include <cstring>
+#include <string>
+#include <limits>                           // for numeric_limits
+#include <algorithm>                        // For swap(), eg
+#include <iterator>                         // for iterator tags
+#include <functional>                       // for equal_to<>, select1st<>, std::unary_function, etc
+#include <memory>                           // for alloc, uninitialized_copy, uninitialized_fill
+#include <cstdlib>                          // for malloc/realloc/free
+#include <cstddef>                          // for ptrdiff_t
+#include <new>                              // for placement new
+#include <stdexcept>                        // For length_error
+#include <utility>                          // for pair<>
+#include <cstdio>
+#include <iosfwd>
+#include <ios>
+
+#include "spp_stdint.h"  // includes spp_config.h
+#include "spp_traits.h"
+#include "spp_utils.h"
+
+#ifdef SPP_INCLUDE_SPP_ALLOC
+    #include "spp_dlalloc.h"
+#endif
+
+#if !defined(SPP_NO_CXX11_HDR_INITIALIZER_LIST)
+    #include <initializer_list>
+#endif
+
+#if (SPP_GROUP_SIZE == 32)
+    #define SPP_SHIFT_ 5
+    #define SPP_MASK_  0x1F
+    typedef uint32_t group_bm_type;
+#elif (SPP_GROUP_SIZE == 64)
+    #define SPP_SHIFT_ 6
+    #define SPP_MASK_  0x3F
+    typedef uint64_t group_bm_type;
+#else
+    #error "SPP_GROUP_SIZE must be either 32 or 64"
+#endif
+
+namespace spp_ {
+
+//  ----------------------------------------------------------------------
+//                  U T I L    F U N C T I O N S
+//  ----------------------------------------------------------------------
+template <class E>
+inline void throw_exception(const E& exception)
+{
+#if !defined(SPP_NO_EXCEPTIONS)
+    throw exception;
+#else
+    assert(0);
+    abort();
+#endif
+}
+
+//  ----------------------------------------------------------------------
+//              M U T A B L E     P A I R      H A C K
+// turn std::pair<const K, V> into mutable std::pair<K, V>
+//  ----------------------------------------------------------------------
+template <class T>
+struct cvt
+{
+    typedef T type;
+};
+
+template <class K, class V>
+struct cvt<std::pair<const K, V> >
+{
+    typedef std::pair<K, V> type;
+};
+
+template <class K, class V>
+struct cvt<const std::pair<const K, V> >
+{
+    typedef const std::pair<K, V> type;
+};
+
+//  ----------------------------------------------------------------------
+//              M O V E   I T E R A T O R
+//  ----------------------------------------------------------------------
+#ifdef SPP_NO_CXX11_RVALUE_REFERENCES
+    #define MK_MOVE_IT(p) (p)
+#else
+    #define MK_MOVE_IT(p) std::make_move_iterator(p)
+#endif
+
+
+//  ----------------------------------------------------------------------
+//             I N T E R N A L    S T U F F
+//  ----------------------------------------------------------------------
+#ifdef SPP_NO_CXX11_STATIC_ASSERT
+    template <bool> struct SppCompileAssert { };
+    #define SPP_COMPILE_ASSERT(expr, msg) \
+      SPP_ATTRIBUTE_UNUSED typedef SppCompileAssert<(bool(expr))> spp_bogus_[bool(expr) ? 1 : -1]
+#else
+    #define SPP_COMPILE_ASSERT static_assert
+#endif
+
+namespace sparsehash_internal
+{
+
+// Adaptor methods for reading/writing data from an INPUT or OUPTUT
+// variable passed to serialize() or unserialize().  For now we
+// have implemented INPUT/OUTPUT for FILE*, istream*/ostream* (note
+// they are pointers, unlike typical use), or else a pointer to
+// something that supports a Read()/Write() method.
+//
+// For technical reasons, we implement read_data/write_data in two
+// stages.  The actual work is done in *_data_internal, which takes
+// the stream argument twice: once as a template type, and once with
+// normal type information.  (We only use the second version.)  We do
+// this because of how C++ picks what function overload to use.  If we
+// implemented this the naive way:
+//    bool read_data(istream* is, const void* data, size_t length);
+//    template<typename T> read_data(T* fp,  const void* data, size_t length);
+// C++ would prefer the second version for every stream type except
+// istream.  However, we want C++ to prefer the first version for
+// streams that are *subclasses* of istream, such as istringstream.
+// This is not possible given the way template types are resolved.  So
+// we split the stream argument in two, one of which is templated and
+// one of which is not.  The specialized functions (like the istream
+// version above) ignore the template arg and use the second, 'type'
+// arg, getting subclass matching as normal.  The 'catch-all'
+// functions (the second version above) use the template arg to deduce
+// the type, and use a second, void* arg to achieve the desired
+// 'catch-all' semantics.
+
+    // ----- low-level I/O for FILE* ----
+
+    template<typename Ignored>
+    inline bool read_data_internal(Ignored* /*unused*/, FILE* fp,
+                                   void* data, size_t length)
+    {
+        return fread(data, length, 1, fp) == 1;
+    }
+
+    template<typename Ignored>
+    inline bool write_data_internal(Ignored* /*unused*/, FILE* fp,
+                                    const void* data, size_t length)
+    {
+        return fwrite(data, length, 1, fp) == 1;
+    }
+
+    // ----- low-level I/O for iostream ----
+
+    // We want the caller to be responsible for #including <iostream>, not
+    // us, because iostream is a big header!  According to the standard,
+    // it's only legal to delay the instantiation the way we want to if
+    // the istream/ostream is a template type.  So we jump through hoops.
+    template<typename ISTREAM>
+    inline bool read_data_internal_for_istream(ISTREAM* fp,
+                                               void* data, size_t length)
+    {
+        return fp->read(reinterpret_cast<char*>(data),
+                        static_cast<std::streamsize>(length)).good();
+    }
+    template<typename Ignored>
+    inline bool read_data_internal(Ignored* /*unused*/, std::istream* fp,
+                                   void* data, size_t length)
+    {
+        return read_data_internal_for_istream(fp, data, length);
+    }
+
+    template<typename OSTREAM>
+    inline bool write_data_internal_for_ostream(OSTREAM* fp,
+                                                const void* data, size_t length)
+    {
+        return fp->write(reinterpret_cast<const char*>(data),
+                         static_cast<std::streamsize>(length)).good();
+    }
+    template<typename Ignored>
+    inline bool write_data_internal(Ignored* /*unused*/, std::ostream* fp,
+                                    const void* data, size_t length)
+    {
+        return write_data_internal_for_ostream(fp, data, length);
+    }
+
+    // ----- low-level I/O for custom streams ----
+
+    // The INPUT type needs to support a Read() method that takes a
+    // buffer and a length and returns the number of bytes read.
+    template <typename INPUT>
+    inline bool read_data_internal(INPUT* fp, void* /*unused*/,
+                                   void* data, size_t length)
+    {
+        return static_cast<size_t>(fp->Read(data, length)) == length;
+    }
+
+    // The OUTPUT type needs to support a Write() operation that takes
+    // a buffer and a length and returns the number of bytes written.
+    template <typename OUTPUT>
+    inline bool write_data_internal(OUTPUT* fp, void* /*unused*/,
+                                    const void* data, size_t length)
+    {
+        return static_cast<size_t>(fp->Write(data, length)) == length;
+    }
+
+    // ----- low-level I/O: the public API ----
+
+    template <typename INPUT>
+    inline bool read_data(INPUT* fp, void* data, size_t length)
+    {
+        return read_data_internal(fp, fp, data, length);
+    }
+
+    template <typename OUTPUT>
+    inline bool write_data(OUTPUT* fp, const void* data, size_t length)
+    {
+        return write_data_internal(fp, fp, data, length);
+    }
+
+    // Uses read_data() and write_data() to read/write an integer.
+    // length is the number of bytes to read/write (which may differ
+    // from sizeof(IntType), allowing us to save on a 32-bit system
+    // and load on a 64-bit system).  Excess bytes are taken to be 0.
+    // INPUT and OUTPUT must match legal inputs to read/write_data (above).
+    // --------------------------------------------------------------------
+    template <typename INPUT, typename IntType>
+    bool read_bigendian_number(INPUT* fp, IntType* value, size_t length)
+    {
+        *value = 0;
+        unsigned char byte;
+        // We require IntType to be unsigned or else the shifting gets all screwy.
+        SPP_COMPILE_ASSERT(static_cast<IntType>(-1) > static_cast<IntType>(0), "serializing_int_requires_an_unsigned_type");
+        for (size_t i = 0; i < length; ++i)
+        {
+            if (!read_data(fp, &byte, sizeof(byte)))
+                return false;
+            *value |= static_cast<IntType>(byte) << ((length - 1 - i) * 8);
+        }
+        return true;
+    }
+
+    template <typename OUTPUT, typename IntType>
+    bool write_bigendian_number(OUTPUT* fp, IntType value, size_t length)
+    {
+        unsigned char byte;
+        // We require IntType to be unsigned or else the shifting gets all screwy.
+        SPP_COMPILE_ASSERT(static_cast<IntType>(-1) > static_cast<IntType>(0), "serializing_int_requires_an_unsigned_type");
+        for (size_t i = 0; i < length; ++i)
+        {
+            byte = (sizeof(value) <= length-1 - i)
+                ? static_cast<unsigned char>(0) : static_cast<unsigned char>((value >> ((length-1 - i) * 8)) & 255);
+            if (!write_data(fp, &byte, sizeof(byte))) return false;
+        }
+        return true;
+    }
+
+    // If your keys and values are simple enough, you can pass this
+    // serializer to serialize()/unserialize().  "Simple enough" means
+    // value_type is a POD type that contains no pointers.  Note,
+    // however, we don't try to normalize endianness.
+    // This is the type used for NopointerSerializer.
+    // ---------------------------------------------------------------
+    template <typename value_type> struct pod_serializer
+    {
+        template <typename INPUT>
+        bool operator()(INPUT* fp, value_type* value) const
+        {
+            return read_data(fp, value, sizeof(*value));
+        }
+
+        template <typename OUTPUT>
+        bool operator()(OUTPUT* fp, const value_type& value) const
+        {
+            return write_data(fp, &value, sizeof(value));
+        }
+    };
+
+
+    // Settings contains parameters for growing and shrinking the table.
+    // It also packages zero-size functor (ie. hasher).
+    //
+    // It does some munging of the hash value for the cases where
+    // the original hash function is not be very good.
+    // ---------------------------------------------------------------
+    template<typename Key, typename HashFunc, typename SizeType, int HT_MIN_BUCKETS>
+    class sh_hashtable_settings : public HashFunc
+    {
+    private:
+#ifndef SPP_MIX_HASH
+        template <class T, int sz> struct Mixer
+        {
+            inline T operator()(T h) const { return h; }
+        };
+#else
+        template <class T, int sz> struct Mixer
+        {
+            inline T operator()(T h) const;
+        };
+
+         template <class T> struct Mixer<T, 4>
+        {
+            inline T operator()(T h) const
+            {
+                // from Thomas Wang - https://gist.github.com/badboy/6267743
+                // ---------------------------------------------------------
+                h = (h ^ 61) ^ (h >> 16);
+                h = h + (h << 3);
+                h = h ^ (h >> 4);
+                h = h * 0x27d4eb2d;
+                h = h ^ (h >> 15);
+                return h;
+            }
+        };
+
+        template <class T> struct Mixer<T, 8>
+        {
+            inline T operator()(T h) const
+            {
+                // from Thomas Wang - https://gist.github.com/badboy/6267743
+                // ---------------------------------------------------------
+                h = (~h) + (h << 21);              // h = (h << 21) - h - 1;
+                h = h ^ (h >> 24);
+                h = (h + (h << 3)) + (h << 8);     // h * 265
+                h = h ^ (h >> 14);
+                h = (h + (h << 2)) + (h << 4);     // h * 21
+                h = h ^ (h >> 28);
+                h = h + (h << 31);
+                return h;
+            }
+        };
+#endif
+
+    public:
+        typedef Key key_type;
+        typedef HashFunc hasher;
+        typedef SizeType size_type;
+
+    public:
+        sh_hashtable_settings(const hasher& hf,
+                              const float ht_occupancy_flt,
+                              const float ht_empty_flt)
+            : hasher(hf),
+              enlarge_threshold_(0),
+              shrink_threshold_(0),
+              consider_shrink_(false),
+              num_ht_copies_(0)
+        {
+            set_enlarge_factor(ht_occupancy_flt);
+            set_shrink_factor(ht_empty_flt);
+        }
+
+        size_t hash(const key_type& v) const
+        {
+            size_t h = hasher::operator()(v);
+            Mixer<size_t, sizeof(size_t)> mixer;
+
+            return mixer(h);
+        }
+
+        float enlarge_factor() const            { return enlarge_factor_; }
+        void set_enlarge_factor(float f)        { enlarge_factor_ = f;    }
+        float shrink_factor() const             { return shrink_factor_;  }
+        void set_shrink_factor(float f)         { shrink_factor_ = f;     }
+
+        size_type enlarge_threshold() const     { return enlarge_threshold_; }
+        void set_enlarge_threshold(size_type t) { enlarge_threshold_ = t; }
+        size_type shrink_threshold() const      { return shrink_threshold_; }
+        void set_shrink_threshold(size_type t)  { shrink_threshold_ = t; }
+
+        size_type enlarge_size(size_type x) const { return static_cast<size_type>(x * enlarge_factor_); }
+        size_type shrink_size(size_type x) const { return static_cast<size_type>(x * shrink_factor_); }
+
+        bool consider_shrink() const            { return consider_shrink_; }
+        void set_consider_shrink(bool t)        { consider_shrink_ = t; }
+
+        unsigned int num_ht_copies() const      { return num_ht_copies_; }
+        void inc_num_ht_copies()                { ++num_ht_copies_; }
+
+        // Reset the enlarge and shrink thresholds
+        void reset_thresholds(size_type num_buckets)
+        {
+            set_enlarge_threshold(enlarge_size(num_buckets));
+            set_shrink_threshold(shrink_size(num_buckets));
+            // whatever caused us to reset already considered
+            set_consider_shrink(false);
+        }
+
+        // Caller is resposible for calling reset_threshold right after
+        // set_resizing_parameters.
+        // ------------------------------------------------------------
+        void set_resizing_parameters(float shrink, float grow)
+        {
+            assert(shrink >= 0);
+            assert(grow <= 1);
+            if (shrink > grow/2.0f)
+                shrink = grow / 2.0f;     // otherwise we thrash hashtable size
+            set_shrink_factor(shrink);
+            set_enlarge_factor(grow);
+        }
+
+        // This is the smallest size a hashtable can be without being too crowded
+        // If you like, you can give a min #buckets as well as a min #elts
+        // ----------------------------------------------------------------------
+        size_type min_buckets(size_type num_elts, size_type min_buckets_wanted)
+        {
+            float enlarge = enlarge_factor();
+            size_type sz = HT_MIN_BUCKETS;             // min buckets allowed
+            while (sz < min_buckets_wanted ||
+                   num_elts >= static_cast<size_type>(sz * enlarge))
+            {
+                // This just prevents overflowing size_type, since sz can exceed
+                // max_size() here.
+                // -------------------------------------------------------------
+                if (static_cast<size_type>(sz * 2) < sz)
+                    throw_exception(std::length_error("resize overflow"));  // protect against overflow
+                sz *= 2;
+            }
+            return sz;
+        }
+
+    private:
+        size_type enlarge_threshold_;  // table.size() * enlarge_factor
+        size_type shrink_threshold_;   // table.size() * shrink_factor
+        float enlarge_factor_;         // how full before resize
+        float shrink_factor_;          // how empty before resize
+        bool consider_shrink_;         // if we should try to shrink before next insert
+
+        unsigned int num_ht_copies_;   // num_ht_copies is a counter incremented every Copy/Move
+    };
+
+}  // namespace sparsehash_internal
+
+#undef SPP_COMPILE_ASSERT
+
+//  ----------------------------------------------------------------------
+//                    S P A R S E T A B L E
+//  ----------------------------------------------------------------------
+//
+// A sparsetable is a random container that implements a sparse array,
+// that is, an array that uses very little memory to store unassigned
+// indices (in this case, between 1-2 bits per unassigned index).  For
+// instance, if you allocate an array of size 5 and assign a[2] = <big
+// struct>, then a[2] will take up a lot of memory but a[0], a[1],
+// a[3], and a[4] will not.  Array elements that have a value are
+// called "assigned".  Array elements that have no value yet, or have
+// had their value cleared using erase() or clear(), are called
+// "unassigned".
+//
+// Unassigned values seem to have the default value of T (see below).
+// Nevertheless, there is a difference between an unassigned index and
+// one explicitly assigned the value of T().  The latter is considered
+// assigned.
+//
+// Access to an array element is constant time, as is insertion and
+// deletion.  Insertion and deletion may be fairly slow, however:
+// because of this container's memory economy, each insert and delete
+// causes a memory reallocation.
+//
+// NOTE: You should not test(), get(), or set() any index that is
+// greater than sparsetable.size().  If you need to do that, call
+// resize() first.
+//
+// --- Template parameters
+// PARAMETER   DESCRIPTION                           DEFAULT
+// T           The value of the array: the type of   --
+//             object that is stored in the array.
+//
+// Alloc:      Allocator to use to allocate memory.
+//
+// --- Model of
+// Random Access Container
+//
+// --- Type requirements
+// T must be Copy Constructible. It need not be Assignable.
+//
+// --- Public base classes
+// None.
+//
+// --- Members
+//
+// [*] All iterators are const in a sparsetable (though nonempty_iterators
+//     may not be).  Use get() and set() to assign values, not iterators.
+//
+// [+] iterators are random-access iterators.  nonempty_iterators are
+//     bidirectional iterators.
+
+// [*] If you shrink a sparsetable using resize(), assigned elements
+// past the end of the table are removed using erase().  If you grow
+// a sparsetable, new unassigned indices are created.
+//
+// [+] Note that operator[] returns a const reference.  You must use
+// set() to change the value of a table element.
+//
+// [!] Unassignment also calls the destructor.
+//
+// Iterators are invalidated whenever an item is inserted or
+// deleted (ie set() or erase() is used) or when the size of
+// the table changes (ie resize() or clear() is used).
+
+
+
+// ---------------------------------------------------------------------------
+// Our iterator as simple as iterators can be: basically it's just
+// the index into our table.  Dereference, the only complicated
+// thing, we punt to the table class.  This just goes to show how
+// much machinery STL requires to do even the most trivial tasks.
+//
+// A NOTE ON ASSIGNING:
+// A sparse table does not actually allocate memory for entries
+// that are not filled.  Because of this, it becomes complicated
+// to have a non-const iterator: we don't know, if the iterator points
+// to a not-filled bucket, whether you plan to fill it with something
+// or whether you plan to read its value (in which case you'll get
+// the default bucket value).  Therefore, while we can define const
+// operations in a pretty 'normal' way, for non-const operations, we
+// define something that returns a helper object with operator= and
+// operator& that allocate a bucket lazily.  We use this for table[]
+// and also for regular table iterators.
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Our iterator as simple as iterators can be: basically it's just
+// the index into our table.  Dereference, the only complicated
+// thing, we punt to the table class.  This just goes to show how
+// much machinery STL requires to do even the most trivial tasks.
+//
+// By templatizing over tabletype, we have one iterator type which
+// we can use for both sparsetables and sparsebins.  In fact it
+// works on any class that allows size() and operator[] (eg vector),
+// as long as it does the standard STL typedefs too (eg value_type).
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+template <class tabletype>
+class table_iterator
+{
+public:
+    typedef table_iterator iterator;
+
+    typedef std::random_access_iterator_tag      iterator_category;
+    typedef typename tabletype::value_type       value_type;
+    typedef typename tabletype::difference_type  difference_type;
+    typedef typename tabletype::size_type        size_type;
+
+    explicit table_iterator(tabletype *tbl = 0, size_type p = 0) :
+        table(tbl), pos(p)
+    { }
+
+    // Helper function to assert things are ok; eg pos is still in range
+    void check() const
+    {
+        assert(table);
+        assert(pos <= table->size());
+    }
+
+    // Arithmetic: we just do arithmetic on pos.  We don't even need to
+    // do bounds checking, since STL doesn't consider that its job.  :-)
+    iterator& operator+=(size_type t) { pos += t; check(); return *this; }
+    iterator& operator-=(size_type t) { pos -= t; check(); return *this; }
+    iterator& operator++()            { ++pos; check(); return *this; }
+    iterator& operator--()            { --pos; check(); return *this; }
+    iterator operator++(int)
+    {
+        iterator tmp(*this);     // for x++
+        ++pos; check(); return tmp;
+    }
+
+    iterator operator--(int)
+    {
+        iterator tmp(*this);     // for x--
+        --pos; check(); return tmp;
+    }
+
+    iterator operator+(difference_type i) const
+    {
+        iterator tmp(*this);
+        tmp += i; return tmp;
+    }
+
+    iterator operator-(difference_type i) const
+    {
+        iterator tmp(*this);
+        tmp -= i; return tmp;
+    }
+
+    difference_type operator-(iterator it) const
+    {
+        // for "x = it2 - it"
+        assert(table == it.table);
+        return pos - it.pos;
+    }
+
+    // Comparisons.
+    bool operator==(const iterator& it) const
+    {
+        return table == it.table && pos == it.pos;
+    }
+
+    bool operator<(const iterator& it) const
+    {
+        assert(table == it.table);              // life is bad bad bad otherwise
+        return pos < it.pos;
+    }
+
+    bool operator!=(const iterator& it) const { return !(*this == it); }
+    bool operator<=(const iterator& it) const { return !(it < *this); }
+    bool operator>(const iterator& it) const { return it < *this; }
+    bool operator>=(const iterator& it) const { return !(*this < it); }
+
+    // Here's the info we actually need to be an iterator
+    tabletype *table;              // so we can dereference and bounds-check
+    size_type pos;                 // index into the table
+};
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+template <class tabletype>
+class const_table_iterator
+{
+public:
+    typedef table_iterator<tabletype> iterator;
+    typedef const_table_iterator const_iterator;
+
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef typename tabletype::value_type value_type;
+    typedef typename tabletype::difference_type difference_type;
+    typedef typename tabletype::size_type size_type;
+    typedef typename tabletype::const_reference reference;  // we're const-only
+    typedef typename tabletype::const_pointer pointer;
+
+    // The "real" constructor
+    const_table_iterator(const tabletype *tbl, size_type p)
+        : table(tbl), pos(p) { }
+
+    // The default constructor, used when I define vars of type table::iterator
+    const_table_iterator() : table(NULL), pos(0) { }
+
+    // The copy constructor, for when I say table::iterator foo = tbl.begin()
+    // Also converts normal iterators to const iterators // not explicit on purpose
+    const_table_iterator(const iterator &from)
+        : table(from.table), pos(from.pos) { }
+
+    // The default destructor is fine; we don't define one
+    // The default operator= is fine; we don't define one
+
+    // The main thing our iterator does is dereference.  If the table entry
+    // we point to is empty, we return the default value type.
+    reference operator*() const       { return (*table)[pos]; }
+    pointer operator->() const        { return &(operator*()); }
+
+    // Helper function to assert things are ok; eg pos is still in range
+    void check() const
+    {
+        assert(table);
+        assert(pos <= table->size());
+    }
+
+    // Arithmetic: we just do arithmetic on pos.  We don't even need to
+    // do bounds checking, since STL doesn't consider that its job.  :-)
+    const_iterator& operator+=(size_type t) { pos += t; check(); return *this; }
+    const_iterator& operator-=(size_type t) { pos -= t; check(); return *this; }
+    const_iterator& operator++()            { ++pos; check(); return *this; }
+    const_iterator& operator--()            { --pos; check(); return *this; }
+    const_iterator operator++(int)          
+    {
+        const_iterator tmp(*this); // for x++
+        ++pos; check(); 
+        return tmp; 
+    }
+    const_iterator operator--(int)          
+    {
+        const_iterator tmp(*this); // for x--
+        --pos; check(); 
+        return tmp;
+    }
+    const_iterator operator+(difference_type i) const
+    {
+        const_iterator tmp(*this);
+        tmp += i;
+        return tmp;
+    }
+    const_iterator operator-(difference_type i) const
+    {
+        const_iterator tmp(*this);
+        tmp -= i;
+        return tmp;
+    }
+    difference_type operator-(const_iterator it) const
+    {
+        // for "x = it2 - it"
+        assert(table == it.table);
+        return pos - it.pos;
+    }
+    reference operator[](difference_type n) const
+    {
+        return *(*this + n);            // simple though not totally efficient
+    }
+
+    // Comparisons.
+    bool operator==(const const_iterator& it) const
+    {
+        return table == it.table && pos == it.pos;
+    }
+
+    bool operator<(const const_iterator& it) const
+    {
+        assert(table == it.table);              // life is bad bad bad otherwise
+        return pos < it.pos;
+    }
+    bool operator!=(const const_iterator& it) const { return !(*this == it); }
+    bool operator<=(const const_iterator& it) const { return !(it < *this); }
+    bool operator>(const const_iterator& it) const { return it < *this; }
+    bool operator>=(const const_iterator& it) const { return !(*this < it); }
+
+    // Here's the info we actually need to be an iterator
+    const tabletype *table;        // so we can dereference and bounds-check
+    size_type pos;                 // index into the table
+};
+
+// ---------------------------------------------------------------------------
+// This is a 2-D iterator.  You specify a begin and end over a list
+// of *containers*.  We iterate over each container by iterating over
+// it.  It's actually simple:
+// VECTOR.begin() VECTOR[0].begin()  --------> VECTOR[0].end() ---,
+//     |          ________________________________________________/
+//     |          \_> VECTOR[1].begin()  -------->  VECTOR[1].end() -,
+//     |          ___________________________________________________/
+//     v          \_> ......
+// VECTOR.end()
+//
+// It's impossible to do random access on one of these things in constant
+// time, so it's just a bidirectional iterator.
+//
+// Unfortunately, because we need to use this for a non-empty iterator,
+// we use ne_begin() and ne_end() instead of begin() and end()
+// (though only going across, not down).
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+template <class T, class row_it, class col_it, class iter_type>
+class Two_d_iterator
+{
+public:
+    typedef Two_d_iterator iterator;
+    typedef iter_type      iterator_category;
+    typedef T              value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T*             pointer;
+    typedef T&             reference;
+
+    explicit Two_d_iterator(row_it curr) : row_current(curr), col_current(0)
+    {
+        if (row_current && !row_current->is_marked())
+        {
+            col_current = row_current->ne_begin();
+            advance_past_end();                 // in case cur->begin() == cur->end()
+        }
+    }
+
+    explicit Two_d_iterator(row_it curr, col_it col) : row_current(curr), col_current(col)
+    {
+        assert(col);
+    }
+
+    // The default constructor
+    Two_d_iterator() :  row_current(0), col_current(0) { }
+
+    // Need this explicitly so we can convert normal iterators <=> const iterators
+    // not explicit on purpose
+    // ---------------------------------------------------------------------------
+    template <class T2, class row_it2, class col_it2, class iter_type2>
+    Two_d_iterator(const Two_d_iterator<T2, row_it2, col_it2, iter_type2>& it) :
+        row_current (*(row_it *)&it.row_current),
+        col_current (*(col_it *)&it.col_current)
+    { }
+
+    // The default destructor is fine; we don't define one
+    // The default operator= is fine; we don't define one
+
+    value_type& operator*() const  { return *(col_current); }
+    value_type* operator->() const { return &(operator*()); }
+
+    // Arithmetic: we just do arithmetic on pos.  We don't even need to
+    // do bounds checking, since STL doesn't consider that its job.  :-)
+    // NOTE: this is not amortized constant time!  What do we do about it?
+    // ------------------------------------------------------------------
+    void advance_past_end()
+    {
+        // used when col_current points to end()
+        while (col_current == row_current->ne_end())
+        {
+            // end of current row
+            // ------------------
+            ++row_current;                                // go to beginning of next
+            if (!row_current->is_marked())                // col is irrelevant at end
+                col_current = row_current->ne_begin();
+            else
+                break;                                    // don't go past row_end
+        }
+    }
+
+    friend size_t operator-(iterator l, iterator f)
+    {
+        if (f.row_current->is_marked())
+            return 0;
+
+        size_t diff(0);
+        while (f != l)
+        {
+            ++diff;
+            ++f;
+        }
+        return diff;
+    }
+
+    iterator& operator++()
+    {
+        // assert(!row_current->is_marked());               // how to ++ from there?
+        ++col_current;
+        advance_past_end();                              // in case col_current is at end()
+        return *this;
+    }
+
+    iterator& operator--()
+    {
+        while (row_current->is_marked() ||
+               col_current == row_current->ne_begin())
+        {
+            --row_current;
+            col_current = row_current->ne_end();             // this is 1 too far
+        }
+        --col_current;
+        return *this;
+    }
+    iterator operator++(int)       { iterator tmp(*this); ++*this; return tmp; }
+    iterator operator--(int)       { iterator tmp(*this); --*this; return tmp; }
+
+
+    // Comparisons.
+    bool operator==(const iterator& it) const
+    {
+        return (row_current == it.row_current &&
+                (!row_current || row_current->is_marked() || col_current == it.col_current));
+    }
+
+    bool operator!=(const iterator& it) const { return !(*this == it); }
+
+    // Here's the info we actually need to be an iterator
+    // These need to be public so we convert from iterator to const_iterator
+    // ---------------------------------------------------------------------
+    row_it row_current;
+    col_it col_current;
+};
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+template <class T, class row_it, class col_it, class iter_type, class Alloc>
+class Two_d_destructive_iterator : public Two_d_iterator<T, row_it, col_it, iter_type>
+{
+public:
+    typedef Two_d_destructive_iterator iterator;
+
+    Two_d_destructive_iterator(Alloc &alloc, row_it curr) :
+        _alloc(alloc)
+    {
+        this->row_current = curr;
+        this->col_current = 0;
+        if (this->row_current && !this->row_current->is_marked())
+        {
+            this->col_current = this->row_current->ne_begin();
+            advance_past_end();                 // in case cur->begin() == cur->end()
+        }
+    }
+
+    // Arithmetic: we just do arithmetic on pos.  We don't even need to
+    // do bounds checking, since STL doesn't consider that its job.  :-)
+    // NOTE: this is not amortized constant time!  What do we do about it?
+    // ------------------------------------------------------------------
+    void advance_past_end()
+    {
+        // used when col_current points to end()
+        while (this->col_current == this->row_current->ne_end())
+        {
+            this->row_current->clear(_alloc, true);  // This is what differs from non-destructive iterators above
+
+            // end of current row
+            // ------------------
+            ++this->row_current;                          // go to beginning of next
+            if (!this->row_current->is_marked())          // col is irrelevant at end
+                this->col_current = this->row_current->ne_begin();
+            else
+                break;                                    // don't go past row_end
+        }
+    }
+
+    iterator& operator++()
+    {
+        // assert(!this->row_current->is_marked());         // how to ++ from there?
+        ++this->col_current;
+        advance_past_end();                              // in case col_current is at end()
+        return *this;
+    }
+
+private:
+    Two_d_destructive_iterator& operator=(const Two_d_destructive_iterator &o);
+
+    Alloc &_alloc;
+};
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+#if defined(SPP_POPCNT_CHECK)
+static inline bool spp_popcount_check()
+{
+    int cpuInfo[4] = { -1 };
+    spp_cpuid(cpuInfo, 1);
+    if (cpuInfo[2] & (1 << 23))
+        return true;   // means SPP_POPCNT supported
+    return false;
+}
+#endif
+
+#if defined(SPP_POPCNT_CHECK) && defined(SPP_POPCNT)
+
+static inline uint32_t spp_popcount(uint32_t i)
+{
+    static const bool s_ok = spp_popcount_check();
+    return s_ok ? SPP_POPCNT(i) : s_spp_popcount_default(i);
+}
+
+#else
+
+static inline uint32_t spp_popcount(uint32_t i)
+{
+#if defined(SPP_POPCNT)
+    return static_cast<uint32_t>(SPP_POPCNT(i));
+#else
+    return s_spp_popcount_default(i);
+#endif
+}
+
+#endif
+
+#if defined(SPP_POPCNT_CHECK) && defined(SPP_POPCNT64)
+
+static inline uint32_t spp_popcount(uint64_t i)
+{
+    static const bool s_ok = spp_popcount_check();
+    return s_ok ? (uint32_t)SPP_POPCNT64(i) : s_spp_popcount_default(i);
+}
+
+#else
+
+static inline uint32_t spp_popcount(uint64_t i)
+{
+#if defined(SPP_POPCNT64)
+    return static_cast<uint32_t>(SPP_POPCNT64(i));
+#elif 1
+    return s_spp_popcount_default(i);
+#endif
+}
+
+#endif
+
+// ---------------------------------------------------------------------------
+// SPARSE-TABLE
+// ------------
+// The idea is that a table with (logically) t buckets is divided
+// into t/M *groups* of M buckets each.  (M is a constant, typically
+// 32)  Each group is stored sparsely.
+// Thus, inserting into the table causes some array to grow, which is
+// slow but still constant time.  Lookup involves doing a
+// logical-position-to-sparse-position lookup, which is also slow but
+// constant time.  The larger M is, the slower these operations are
+// but the less overhead (slightly).
+//
+// To store the sparse array, we store a bitmap B, where B[i] = 1 iff
+// bucket i is non-empty.  Then to look up bucket i we really look up
+// array[# of 1s before i in B].  This is constant time for fixed M.
+//
+// Terminology: the position of an item in the overall table (from
+// 1 .. t) is called its "location."  The logical position in a group
+// (from 1 .. M) is called its "position."  The actual location in
+// the array (from 1 .. # of non-empty buckets in the group) is
+// called its "offset."
+// ---------------------------------------------------------------------------
+
+template <class T, class Alloc>
+class sparsegroup
+{
+public:
+    // Basic types
+    typedef T                                              value_type;
+    typedef Alloc                                          allocator_type;
+    typedef value_type&                                    reference;
+    typedef const value_type&                              const_reference;
+    typedef value_type*                                    pointer;
+    typedef const value_type*                              const_pointer;
+
+    typedef uint8_t                                        size_type;        // max # of buckets
+
+    // These are our special iterators, that go over non-empty buckets in a
+    // group.  These aren't const-only because you can change non-empty bcks.
+    // ---------------------------------------------------------------------
+    typedef pointer                                        ne_iterator;
+    typedef const_pointer                                  const_ne_iterator;
+    typedef std::reverse_iterator<ne_iterator>             reverse_ne_iterator;
+    typedef std::reverse_iterator<const_ne_iterator>       const_reverse_ne_iterator;
+
+    // We'll have versions for our special non-empty iterator too
+    // ----------------------------------------------------------
+    ne_iterator               ne_begin()         { return reinterpret_cast<pointer>(_group); }
+    const_ne_iterator         ne_begin() const   { return reinterpret_cast<pointer>(_group); }
+    const_ne_iterator         ne_cbegin() const  { return reinterpret_cast<pointer>(_group); }
+    ne_iterator               ne_end()           { return reinterpret_cast<pointer>(_group + _num_items()); }
+    const_ne_iterator         ne_end() const     { return reinterpret_cast<pointer>(_group + _num_items()); }
+    const_ne_iterator         ne_cend() const    { return reinterpret_cast<pointer>(_group + _num_items()); }
+    reverse_ne_iterator       ne_rbegin()        { return reverse_ne_iterator(ne_end()); }
+    const_reverse_ne_iterator ne_rbegin() const  { return const_reverse_ne_iterator(ne_cend());  }
+    const_reverse_ne_iterator ne_crbegin() const { return const_reverse_ne_iterator(ne_cend());  }
+    reverse_ne_iterator       ne_rend()          { return reverse_ne_iterator(ne_begin()); }
+    const_reverse_ne_iterator ne_rend() const    { return const_reverse_ne_iterator(ne_cbegin());  }
+    const_reverse_ne_iterator ne_crend() const   { return const_reverse_ne_iterator(ne_cbegin());  }
+
+private:
+    // T can be std::pair<const K, V>, but sometime we need to cast to a mutable type
+    // ------------------------------------------------------------------------------
+    typedef typename spp_::cvt<T>::type                    mutable_value_type;
+    typedef mutable_value_type &                           mutable_reference;
+    typedef mutable_value_type *                           mutable_pointer;
+    typedef const mutable_value_type *                     const_mutable_pointer;
+
+    bool _bmtest(size_type i) const   { return !!(_bitmap & (static_cast<group_bm_type>(1) << i)); }
+    void _bmset(size_type i)          { _bitmap |= static_cast<group_bm_type>(1) << i; }
+    void _bmclear(size_type i)        { _bitmap &= ~(static_cast<group_bm_type>(1) << i); }
+
+    bool _bme_test(size_type i) const { return !!(_bm_erased & (static_cast<group_bm_type>(1) << i)); }
+    void _bme_set(size_type i)        { _bm_erased |= static_cast<group_bm_type>(1) << i; }
+    void _bme_clear(size_type i)      { _bm_erased &= ~(static_cast<group_bm_type>(1) << i); }
+
+    bool _bmtest_strict(size_type i) const
+    { return !!((_bitmap | _bm_erased) & (static_cast<group_bm_type>(1) << i)); }
+
+
+    static uint32_t _sizing(uint32_t n)
+    {
+#if !defined(SPP_ALLOC_SZ) || (SPP_ALLOC_SZ == 0)
+        // aggressive allocation first, then decreasing as sparsegroups fill up
+        // --------------------------------------------------------------------
+        struct alloc_batch_size
+        {
+            // 32 bit bitmap
+            // ........ .... .... .. .. .. .. .  .  .  .  .  .  .  .
+            //     8     12   16  18 20 22 24 25 26   ...          32
+            // ------------------------------------------------------
+            SPP_CXX14_CONSTEXPR alloc_batch_size()
+                : data()
+            {
+                uint8_t group_sz          = SPP_GROUP_SIZE / 4;
+                uint8_t group_start_alloc = SPP_GROUP_SIZE / 8; //4;
+                uint8_t alloc_sz          = group_start_alloc;
+                for (int i=0; i<4; ++i)
+                {
+                    for (int j=0; j<group_sz; ++j)
+                    {
+                        if (j && j % group_start_alloc == 0)
+                            alloc_sz += group_start_alloc;
+                        data[i * group_sz + j] = alloc_sz;
+                    }
+                    if (group_start_alloc > 2)
+                        group_start_alloc /= 2;
+                    alloc_sz += group_start_alloc;
+                }
+            }
+            uint8_t data[SPP_GROUP_SIZE];
+        };
+
+        static alloc_batch_size s_alloc_batch_sz;
+        return n ? static_cast<uint32_t>(s_alloc_batch_sz.data[n-1]) : 0; // more aggressive alloc at the beginning
+
+#elif (SPP_ALLOC_SZ == 1)
+        // use as little memory as possible - slowest insert/delete in table
+        // -----------------------------------------------------------------
+        return n;
+#else
+        // decent compromise when SPP_ALLOC_SZ == 2
+        // ----------------------------------------
+        static size_type sz_minus_1 = SPP_ALLOC_SZ - 1;
+        return (n + sz_minus_1) & ~sz_minus_1;
+#endif
+    }
+
+    pointer _allocate_group(allocator_type &alloc, uint32_t n /* , bool tight = false */)
+    {
+        // ignore tight since we don't store num_alloc
+        // num_alloc = (uint8_t)(tight ? n : _sizing(n));
+
+        uint32_t num_alloc = (uint8_t)_sizing(n);
+        _set_num_alloc(num_alloc);
+        pointer retval = alloc.allocate(static_cast<size_type>(num_alloc));
+        if (retval == NULL)
+        {
+            // the allocator is supposed to throw an exception if the allocation fails.
+            throw_exception(std::bad_alloc());
+        }
+        return retval;
+    }
+
+    void _free_group(allocator_type &alloc, uint32_t num_alloc)
+    {
+        if (_group)
+        {
+            uint32_t num_buckets = _num_items();
+            if (num_buckets)
+            {
+                mutable_pointer end_it = (mutable_pointer)(_group + num_buckets);
+                for (mutable_pointer p = (mutable_pointer)_group; p != end_it; ++p)
+                    p->~mutable_value_type();
+            }
+            alloc.deallocate(_group, (typename allocator_type::size_type)num_alloc);
+            _group = NULL;
+        }
+    }
+
+    // private because should not be called - no allocator!
+    sparsegroup &operator=(const sparsegroup& x);
+
+    static size_type _pos_to_offset(group_bm_type bm, size_type pos)
+    {
+        //return (size_type)((uint32_t)~((int32_t(-1) + pos) >> 31) & spp_popcount(bm << (SPP_GROUP_SIZE - pos)));
+        //return (size_type)(pos ? spp_popcount(bm << (SPP_GROUP_SIZE - pos)) : 0);
+        return static_cast<size_type>(spp_popcount(bm & ((static_cast<group_bm_type>(1) << pos) - 1)));
+    }
+
+public:
+
+    // get_iter() in sparsetable needs it
+    size_type pos_to_offset(size_type pos) const
+    {
+        return _pos_to_offset(_bitmap, pos);
+    }
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4146)
+#endif
+
+    // Returns the (logical) position in the bm[] array, i, such that
+    // bm[i] is the offset-th set bit in the array.  It is the inverse
+    // of pos_to_offset.  get_pos() uses this function to find the index
+    // of an ne_iterator in the table.  Bit-twiddling from
+    // http://hackersdelight.org/basics.pdf
+    // -----------------------------------------------------------------
+    static size_type offset_to_pos(group_bm_type bm, size_type offset)
+    {
+        for (; offset > 0; offset--)
+            bm &= (bm-1);  // remove right-most set bit
+
+        // Clear all bits to the left of the rightmost bit (the &),
+        // and then clear the rightmost bit but set all bits to the
+        // right of it (the -1).
+        // --------------------------------------------------------
+        bm = (bm & -bm) - 1;
+        return  static_cast<size_type>(spp_popcount(bm));
+    }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    size_type offset_to_pos(size_type offset) const
+    {
+        return offset_to_pos(_bitmap, offset);
+    }
+
+public:
+    // Constructors -- default and copy -- and destructor
+    explicit sparsegroup() :
+        _group(0), _bitmap(0), _bm_erased(0)
+    {
+        _set_num_items(0);
+        _set_num_alloc(0);
+    }
+
+    sparsegroup(const sparsegroup& x) :
+        _group(0), _bitmap(x._bitmap), _bm_erased(x._bm_erased)
+    {
+        _set_num_items(0);
+        _set_num_alloc(0);
+         assert(_group == 0); 
+    }
+
+    sparsegroup(const sparsegroup& x, allocator_type& a) :
+        _group(0), _bitmap(x._bitmap), _bm_erased(x._bm_erased)
+    {
+        _set_num_items(0);
+        _set_num_alloc(0);
+
+        uint32_t num_items = x._num_items();
+        if (num_items)
+        {
+            _group = _allocate_group(a, num_items /* , true */);
+            _set_num_items(num_items);
+            std::uninitialized_copy(x._group, x._group + num_items, _group);
+        }
+    }
+
+    ~sparsegroup() { assert(_group == 0); }
+
+    void destruct(allocator_type& a) { _free_group(a, _num_alloc()); }
+
+    // Many STL algorithms use swap instead of copy constructors
+    void swap(sparsegroup& x)
+    {
+        using std::swap;
+
+        swap(_group, x._group);
+        swap(_bitmap, x._bitmap);
+        swap(_bm_erased, x._bm_erased);
+#ifdef SPP_STORE_NUM_ITEMS
+        swap(_num_buckets,   x._num_buckets);
+        swap(_num_allocated, x._num_allocated);
+#endif
+    }
+
+    // It's always nice to be able to clear a table without deallocating it
+    void clear(allocator_type &alloc, bool erased)
+    {
+        _free_group(alloc, _num_alloc());
+        _bitmap = 0;
+        if (erased)
+            _bm_erased = 0;
+        _set_num_items(0);
+        _set_num_alloc(0);
+    }
+
+    // Functions that tell you about size.  Alas, these aren't so useful
+    // because our table is always fixed size.
+    size_type size() const           { return static_cast<size_type>(SPP_GROUP_SIZE); }
+    size_type max_size() const       { return static_cast<size_type>(SPP_GROUP_SIZE); }
+
+    bool empty() const               { return false; }
+
+    // We also may want to know how many *used* buckets there are
+    size_type num_nonempty() const   { return (size_type)_num_items(); }
+
+    // TODO(csilvers): make protected + friend
+    // This is used by sparse_hashtable to get an element from the table
+    // when we know it exists.
+    reference unsafe_get(size_type i) const
+    {
+        // assert(_bmtest(i));
+        return (reference)_group[pos_to_offset(i)];
+    }
+
+    typedef std::pair<pointer, bool> SetResult;
+
+private:
+    //typedef spp_::integral_constant<bool, spp_::is_relocatable<value_type>::value> check_relocatable;
+    typedef spp_::true_type  realloc_ok_type;
+    typedef spp_::false_type realloc_not_ok_type;
+
+    //typedef spp_::zero_type  libc_reloc_type;
+    //typedef spp_::one_type   spp_reloc_type;
+    //typedef spp_::two_type   spp_not_reloc_type;
+    //typedef spp_::three_type generic_alloc_type;
+
+#if 1
+    typedef typename if_<((spp_::is_same<allocator_type, libc_allocator<value_type> >::value ||
+                           spp_::is_same<allocator_type,  spp_allocator<value_type> >::value) &&
+                          spp_::is_relocatable<value_type>::value), realloc_ok_type, realloc_not_ok_type>::type
+             check_alloc_type;
+#else
+    typedef typename if_<spp_::is_same<allocator_type, spp_allocator<value_type> >::value,
+                         typename if_<spp_::is_relocatable<value_type>::value, spp_reloc_type, spp_not_reloc_type>::type,
+                         typename if_<(spp_::is_same<allocator_type, libc_allocator<value_type> >::value &&
+                                       spp_::is_relocatable<value_type>::value), libc_reloc_type, generic_alloc_type>::type >::type 
+        check_alloc_type;
+#endif
+
+
+    //typedef if_<spp_::is_same<allocator_type, libc_allocator<value_type> >::value,
+    //            libc_alloc_type,
+    //            if_<spp_::is_same<allocator_type, spp_allocator<value_type> >::value,
+    //                spp_alloc_type, user_alloc_type> > check_alloc_type;
+
+    //typedef spp_::integral_constant<bool,
+    //            (spp_::is_relocatable<value_type>::value &&
+    //             (spp_::is_same<allocator_type, spp_allocator<value_type> >::value ||
+    //              spp_::is_same<allocator_type, libc_allocator<value_type> >::value)) >
+    //        realloc_and_memmove_ok;
+
+    // ------------------------- memory at *p is uninitialized => need to construct
+    void _init_val(mutable_value_type *p, reference val)
+    {
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+        ::new (p) value_type(std::move((mutable_reference)val));
+#else
+        ::new (p) value_type((mutable_reference)val);
+#endif
+    }
+
+    // ------------------------- memory at *p is uninitialized => need to construct
+    void _init_val(mutable_value_type *p, const_reference val)
+    {
+        ::new (p) value_type(val);
+    }
+
+    // ------------------------------------------------ memory at *p is initialized
+    void _set_val(value_type *p, reference val)
+    {
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+        *(mutable_pointer)p = std::move((mutable_reference)val);
+#else
+        using std::swap;
+        swap(*(mutable_pointer)p, *(mutable_pointer)&val);
+#endif
+    }
+
+    // ------------------------------------------------ memory at *p is initialized
+    void _set_val(value_type *p, const_reference val)
+    {
+        *(mutable_pointer)p = *(const_mutable_pointer)&val;
+    }
+
+    // Create space at _group[offset], assuming value_type is relocatable, and the 
+    // allocator_type is the spp allocator.
+    // return true if the slot was constructed (i.e. contains a valid value_type
+    // ---------------------------------------------------------------------------------
+    template <class Val>
+    void _set_aux(allocator_type &alloc, size_type offset, Val &val, realloc_ok_type)
+    {
+        //static int x=0;  if (++x < 10) printf("x\n"); // check we are getting here
+
+        uint32_t  num_items = _num_items();
+        uint32_t  num_alloc = _sizing(num_items);
+
+        if (num_items == num_alloc)
+        {
+            num_alloc = _sizing(num_items + 1);
+            _group = alloc.reallocate(_group, num_alloc);
+            _set_num_alloc(num_alloc);
+        }
+
+        for (uint32_t i = num_items; i > offset; --i)
+            memcpy(static_cast<void *>(_group + i), _group + i-1, sizeof(*_group));
+
+        _init_val((mutable_pointer)(_group + offset), val);
+    }
+
+    // Create space at _group[offset], assuming value_type is *not* relocatable, and the 
+    // allocator_type is the spp allocator.
+    // return true if the slot was constructed (i.e. contains a valid value_type
+    // ---------------------------------------------------------------------------------
+    template <class Val>
+    void _set_aux(allocator_type &alloc, size_type offset, Val &val, realloc_not_ok_type)
+    {
+        uint32_t  num_items = _num_items();
+        uint32_t  num_alloc = _sizing(num_items);
+
+        //assert(num_alloc == (uint32_t)_num_allocated);
+        if (num_items < num_alloc)
+        {
+            // create new object at end and rotate it to position
+            _init_val((mutable_pointer)&_group[num_items], val);
+            std::rotate((mutable_pointer)(_group + offset),
+                        (mutable_pointer)(_group + num_items),
+                        (mutable_pointer)(_group + num_items + 1));
+            return;
+        }
+
+        // This is valid because 0 <= offset <= num_items
+        pointer p = _allocate_group(alloc, _sizing(num_items + 1));
+        if (offset)
+            std::uninitialized_copy(MK_MOVE_IT((mutable_pointer)_group),
+                                    MK_MOVE_IT((mutable_pointer)(_group + offset)),
+                                    (mutable_pointer)p);
+        if (num_items > offset)
+            std::uninitialized_copy(MK_MOVE_IT((mutable_pointer)(_group + offset)),
+                                    MK_MOVE_IT((mutable_pointer)(_group + num_items)),
+                                    (mutable_pointer)(p + offset + 1));
+        _init_val((mutable_pointer)(p + offset), val);
+        _free_group(alloc, num_alloc);
+        _group = p;
+    }
+
+    // ----------------------------------------------------------------------------------
+    template <class Val>
+    void _set(allocator_type &alloc, size_type i, size_type offset, Val &val)
+    {
+        if (!_bmtest(i))
+        {
+            _set_aux(alloc, offset, val, check_alloc_type());
+            _incr_num_items();
+            _bmset(i);
+        }
+        else
+            _set_val(&_group[offset], val);
+    }
+
+public:
+
+    // This returns the pointer to the inserted item
+    // ---------------------------------------------
+    template <class Val>
+    pointer set(allocator_type &alloc, size_type i, Val &val)
+    {
+        _bme_clear(i); // in case this was an "erased" location
+
+        size_type offset = pos_to_offset(i);
+        _set(alloc, i, offset, val);            // may change _group pointer
+        return (pointer)(_group + offset);
+    }
+
+    // We let you see if a bucket is non-empty without retrieving it
+    // -------------------------------------------------------------
+    bool test(size_type i) const
+    {
+        return _bmtest(i);
+    }
+
+    // also tests for erased values
+    // ----------------------------
+    bool test_strict(size_type i) const
+    {
+        return _bmtest_strict(i);
+    }
+
+private:
+    // Shrink the array, assuming value_type is relocatable, and the 
+    // allocator_type is the libc allocator (supporting reallocate).
+    // -------------------------------------------------------------
+    void _group_erase_aux(allocator_type &alloc, size_type offset, realloc_ok_type)
+    {
+        // static int x=0;  if (++x < 10) printf("Y\n"); // check we are getting here
+        uint32_t  num_items = _num_items();
+        uint32_t  num_alloc = _sizing(num_items);
+
+        if (num_items == 1)
+        {
+            assert(offset == 0);
+            _free_group(alloc, num_alloc);
+            _set_num_alloc(0);
+            return;
+        }
+
+        _group[offset].~value_type();
+
+        for (size_type i = offset; i < num_items - 1; ++i)
+            memcpy(static_cast<void *>(_group + i), _group + i + 1, sizeof(*_group));
+
+        if (_sizing(num_items - 1) != num_alloc)
+        {
+            num_alloc = _sizing(num_items - 1);
+            assert(num_alloc);            // because we have at least 1 item left
+            _set_num_alloc(num_alloc);
+            _group = alloc.reallocate(_group, num_alloc);
+        }
+    }
+
+    // Shrink the array, without any special assumptions about value_type and
+    // allocator_type.
+    // --------------------------------------------------------------------------
+    void _group_erase_aux(allocator_type &alloc, size_type offset, realloc_not_ok_type)
+    {
+        uint32_t  num_items = _num_items();
+        uint32_t  num_alloc   = _sizing(num_items);
+
+        if (_sizing(num_items - 1) != num_alloc)
+        {
+            pointer p = 0;
+            if (num_items > 1)
+            {
+                p = _allocate_group(alloc, num_items - 1);
+                if (offset)
+                    std::uninitialized_copy(MK_MOVE_IT((mutable_pointer)(_group)),
+                                            MK_MOVE_IT((mutable_pointer)(_group + offset)),
+                                            (mutable_pointer)(p));
+                if (static_cast<uint32_t>(offset + 1) < num_items)
+                    std::uninitialized_copy(MK_MOVE_IT((mutable_pointer)(_group + offset + 1)),
+                                            MK_MOVE_IT((mutable_pointer)(_group + num_items)),
+                                            (mutable_pointer)(p + offset));
+            }
+            else
+            {
+                assert(offset == 0);
+                _set_num_alloc(0);
+            }
+            _free_group(alloc, num_alloc);
+            _group = p;
+        }
+        else
+        {
+            std::rotate((mutable_pointer)(_group + offset),
+                        (mutable_pointer)(_group + offset + 1),
+                        (mutable_pointer)(_group + num_items));
+            ((mutable_pointer)(_group + num_items - 1))->~mutable_value_type();
+        }
+    }
+
+    void _group_erase(allocator_type &alloc, size_type offset)
+    {
+        _group_erase_aux(alloc, offset, check_alloc_type());
+    }
+
+public:
+    template <class twod_iter>
+    bool erase_ne(allocator_type &alloc, twod_iter &it)
+    {
+        assert(_group && it.col_current != ne_end());
+        size_type offset = (size_type)(it.col_current - ne_begin());
+        size_type pos    = offset_to_pos(offset);
+
+        if (_num_items() <= 1)
+        {
+            clear(alloc, false);
+            it.col_current = 0;
+        }
+        else
+        {
+            _group_erase(alloc, offset);
+            _decr_num_items();
+            _bmclear(pos);
+
+            // in case _group_erase reallocated the buffer
+            it.col_current = reinterpret_cast<pointer>(_group) + offset;
+        }
+        _bme_set(pos);  // remember that this position has been erased
+        it.advance_past_end();
+        return true;
+    }
+
+
+    // This takes the specified elements out of the group.  This is
+    // "undefining", rather than "clearing".
+    // TODO(austern): Make this exception safe: handle exceptions from
+    // value_type's copy constructor.
+    // ---------------------------------------------------------------
+    void erase(allocator_type &alloc, size_type i)
+    {
+        if (_bmtest(i))
+        {
+            // trivial to erase empty bucket
+            if (_num_items() == 1)
+                clear(alloc, false);
+            else
+            {
+                _group_erase(alloc, pos_to_offset(i));
+                _decr_num_items();
+                _bmclear(i);
+            }
+            _bme_set(i); // remember that this position has been erased
+        }
+    }
+
+    // I/O
+    // We support reading and writing groups to disk.  We don't store
+    // the actual array contents (which we don't know how to store),
+    // just the bitmap and size.  Meant to be used with table I/O.
+    // --------------------------------------------------------------
+    template <typename OUTPUT> bool write_metadata(OUTPUT *fp) const
+    {
+        // warning: we write 4 or 8 bytes for the bitmap, instead of 6 in the
+        //          original google sparsehash
+        // ------------------------------------------------------------------
+        if (!sparsehash_internal::write_data(fp, &_bitmap, sizeof(_bitmap)))
+            return false;
+
+        return true;
+    }
+
+    // Reading destroys the old group contents!  Returns true if all was ok.
+    template <typename INPUT> bool read_metadata(allocator_type &alloc, INPUT *fp)
+    {
+        clear(alloc, true);
+
+        if (!sparsehash_internal::read_data(fp, &_bitmap, sizeof(_bitmap)))
+            return false;
+
+        // We'll allocate the space, but we won't fill it: it will be
+        // left as uninitialized raw memory.
+        uint32_t num_items = spp_popcount(_bitmap); // yes, _num_buckets not set
+        _set_num_items(num_items);
+        _group = num_items ? _allocate_group(alloc, num_items/* , true */) : 0;
+        return true;
+    }
+
+    // Again, only meaningful if value_type is a POD.
+    template <typename INPUT> bool read_nopointer_data(INPUT *fp)
+    {
+        for (ne_iterator it = ne_begin(); it != ne_end(); ++it)
+            if (!sparsehash_internal::read_data(fp, &(*it), sizeof(*it)))
+                return false;
+        return true;
+    }
+
+    // If your keys and values are simple enough, we can write them
+    // to disk for you.  "simple enough" means POD and no pointers.
+    // However, we don't try to normalize endianness.
+    // ------------------------------------------------------------
+    template <typename OUTPUT> bool write_nopointer_data(OUTPUT *fp) const
+    {
+        for (const_ne_iterator it = ne_begin(); it != ne_end(); ++it)
+            if (!sparsehash_internal::write_data(fp, &(*it), sizeof(*it)))
+                return false;
+        return true;
+    }
+
+
+    // Comparisons.  We only need to define == and < -- we get
+    // != > <= >= via relops.h (which we happily included above).
+    // Note the comparisons are pretty arbitrary: we compare
+    // values of the first index that isn't equal (using default
+    // value for empty buckets).
+    // ---------------------------------------------------------
+    bool operator==(const sparsegroup& x) const
+    {
+        return (_bitmap == x._bitmap &&
+                _bm_erased == x._bm_erased &&
+                std::equal(_group, _group + _num_items(), x._group));
+    }
+
+    bool operator<(const sparsegroup& x) const
+    {
+        // also from <algorithm>
+        return std::lexicographical_compare(_group, _group + _num_items(),
+                                            x._group, x._group + x._num_items());
+    }
+
+    bool operator!=(const sparsegroup& x) const { return !(*this == x); }
+    bool operator<=(const sparsegroup& x) const { return !(x < *this); }
+    bool operator> (const sparsegroup& x) const { return x < *this; }
+    bool operator>=(const sparsegroup& x) const { return !(*this < x); }
+
+    void mark()            { _group = (value_type *)static_cast<uintptr_t>(-1); }
+    bool is_marked() const { return _group == (value_type *)static_cast<uintptr_t>(-1); }
+
+private:
+    // ---------------------------------------------------------------------------
+    template <class A>
+    class alloc_impl : public A
+    {
+    public:
+        typedef typename A::pointer pointer;
+        typedef typename A::size_type size_type;
+
+        // Convert a normal allocator to one that has realloc_or_die()
+        explicit alloc_impl(const A& a) : A(a) { }
+
+        // realloc_or_die should only be used when using the default
+        // allocator (spp::spp_allocator).
+        pointer realloc_or_die(pointer /*ptr*/, size_type /*n*/)
+        {
+            throw_exception(std::runtime_error("realloc_or_die is only supported for spp::spp_allocator\n"));
+            return NULL;
+        }
+    };
+
+    // A template specialization of alloc_impl for
+    // spp::libc_allocator that can handle realloc_or_die.
+    // -----------------------------------------------------------
+    template <class A>
+    class alloc_impl<spp_::libc_allocator<A> > : public spp_::libc_allocator<A>
+    {
+    public:
+        typedef typename spp_::libc_allocator<A>::pointer pointer;
+        typedef typename spp_::libc_allocator<A>::size_type size_type;
+
+        explicit alloc_impl(const spp_::libc_allocator<A>& a)
+            : spp_::libc_allocator<A>(a)
+        { }
+
+        pointer realloc_or_die(pointer ptr, size_type n)
+        {
+            pointer retval = this->reallocate(ptr, n);
+            if (retval == NULL) 
+            {
+                // the allocator is supposed to throw an exception if the allocation fails.
+                throw_exception(std::bad_alloc());
+            }
+            return retval;
+        }
+    };
+
+    // A template specialization of alloc_impl for
+    // spp::spp_allocator that can handle realloc_or_die.
+    // -----------------------------------------------------------
+    template <class A>
+    class alloc_impl<spp_::spp_allocator<A> > : public spp_::spp_allocator<A>
+    {
+    public:
+        typedef typename spp_::spp_allocator<A>::pointer pointer;
+        typedef typename spp_::spp_allocator<A>::size_type size_type;
+
+        explicit alloc_impl(const spp_::spp_allocator<A>& a)
+            : spp_::spp_allocator<A>(a)
+        { }
+
+        pointer realloc_or_die(pointer ptr, size_type n)
+        {
+            pointer retval = this->reallocate(ptr, n);
+            if (retval == NULL) 
+            {
+                // the allocator is supposed to throw an exception if the allocation fails.
+                throw_exception(std::bad_alloc());
+            }
+            return retval;
+        }
+    };
+
+
+#ifdef SPP_STORE_NUM_ITEMS
+    uint32_t _num_items() const           { return (uint32_t)_num_buckets; }
+    void     _set_num_items(uint32_t val) { _num_buckets = static_cast<size_type>(val); }
+    void     _incr_num_items()            { ++_num_buckets; }
+    void     _decr_num_items()            { --_num_buckets; }
+    uint32_t _num_alloc() const           { return (uint32_t)_num_allocated; }
+    void     _set_num_alloc(uint32_t val) { _num_allocated = static_cast<size_type>(val); }
+#else
+    uint32_t _num_items() const           { return spp_popcount(_bitmap); }
+    void     _set_num_items(uint32_t )    { }
+    void     _incr_num_items()            { }
+    void     _decr_num_items()            { }
+    uint32_t _num_alloc() const           { return _sizing(_num_items()); }
+    void     _set_num_alloc(uint32_t val) { }
+#endif
+
+    // The actual data
+    // ---------------
+    value_type *         _group;                             // (small) array of T's
+    group_bm_type        _bitmap;
+    group_bm_type        _bm_erased;                         // ones where items have been erased
+
+#ifdef SPP_STORE_NUM_ITEMS
+    size_type            _num_buckets;
+    size_type            _num_allocated;
+#endif
+};
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+template <class T, class Alloc>
+class sparsetable
+{
+public:
+    typedef T                                             value_type;
+    typedef Alloc                                         allocator_type;
+    typedef sparsegroup<value_type, allocator_type>       group_type;
+
+private:
+    typedef typename Alloc::template rebind<group_type>::other group_alloc_type;
+    typedef typename group_alloc_type::size_type          group_size_type;
+
+public:
+    // Basic types
+    // -----------
+    typedef typename allocator_type::size_type            size_type;
+    typedef typename allocator_type::difference_type      difference_type;
+    typedef value_type&                                   reference;
+    typedef const value_type&                             const_reference;
+    typedef value_type*                                   pointer;
+    typedef const value_type*                             const_pointer;
+
+    typedef group_type&                                   GroupsReference;
+    typedef const group_type&                             GroupsConstReference;
+
+    typedef typename group_type::ne_iterator              ColIterator;
+    typedef typename group_type::const_ne_iterator        ColConstIterator;
+
+    typedef table_iterator<sparsetable<T, allocator_type> >        iterator;       // defined with index
+    typedef const_table_iterator<sparsetable<T, allocator_type> >  const_iterator; // defined with index
+    typedef std::reverse_iterator<const_iterator>         const_reverse_iterator;
+    typedef std::reverse_iterator<iterator>               reverse_iterator;
+
+    // These are our special iterators, that go over non-empty buckets in a
+    // table.  These aren't const only because you can change non-empty bcks.
+    // ----------------------------------------------------------------------
+    typedef Two_d_iterator<T,
+                           group_type *,
+                           ColIterator,
+                           std::bidirectional_iterator_tag> ne_iterator;
+
+    typedef Two_d_iterator<const T,
+                           const group_type *,
+                           ColConstIterator,
+                           std::bidirectional_iterator_tag> const_ne_iterator;
+
+    // Another special iterator: it frees memory as it iterates (used to resize).
+    // Obviously, you can only iterate over it once, which is why it's an input iterator
+    // ---------------------------------------------------------------------------------
+    typedef Two_d_destructive_iterator<T,
+                                       group_type *,
+                                       ColIterator,
+                                       std::input_iterator_tag,
+                                       allocator_type>     destructive_iterator;
+
+    typedef std::reverse_iterator<ne_iterator>               reverse_ne_iterator;
+    typedef std::reverse_iterator<const_ne_iterator>         const_reverse_ne_iterator;
+
+
+    // Iterator functions
+    // ------------------
+    iterator               begin()         { return iterator(this, 0); }
+    const_iterator         begin() const   { return const_iterator(this, 0); }
+    const_iterator         cbegin() const  { return const_iterator(this, 0); }
+    iterator               end()           { return iterator(this, size()); }
+    const_iterator         end() const     { return const_iterator(this, size()); }
+    const_iterator         cend() const    { return const_iterator(this, size()); }
+    reverse_iterator       rbegin()        { return reverse_iterator(end()); }
+    const_reverse_iterator rbegin() const  { return const_reverse_iterator(cend()); }
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
+    reverse_iterator       rend()          { return reverse_iterator(begin()); }
+    const_reverse_iterator rend() const    { return const_reverse_iterator(cbegin()); }
+    const_reverse_iterator crend() const   { return const_reverse_iterator(cbegin()); }
+
+    // Versions for our special non-empty iterator
+    // ------------------------------------------
+    ne_iterator       ne_begin()           { return ne_iterator      (_first_group); }
+    const_ne_iterator ne_begin() const     { return const_ne_iterator(_first_group); }
+    const_ne_iterator ne_cbegin() const    { return const_ne_iterator(_first_group); }
+    ne_iterator       ne_end()             { return ne_iterator      (_last_group); }
+    const_ne_iterator ne_end() const       { return const_ne_iterator(_last_group); }
+    const_ne_iterator ne_cend() const      { return const_ne_iterator(_last_group); }
+
+    reverse_ne_iterator       ne_rbegin()        { return reverse_ne_iterator(ne_end()); }
+    const_reverse_ne_iterator ne_rbegin() const  { return const_reverse_ne_iterator(ne_end());  }
+    const_reverse_ne_iterator ne_crbegin() const { return const_reverse_ne_iterator(ne_end());  }
+    reverse_ne_iterator       ne_rend()          { return reverse_ne_iterator(ne_begin()); }
+    const_reverse_ne_iterator ne_rend() const    { return const_reverse_ne_iterator(ne_begin()); }
+    const_reverse_ne_iterator ne_crend() const   { return const_reverse_ne_iterator(ne_begin()); }
+
+    destructive_iterator destructive_begin()
+    {
+        return destructive_iterator(_alloc, _first_group);
+    }
+
+    destructive_iterator destructive_end()
+    {
+        return destructive_iterator(_alloc, _last_group);
+    }
+
+    // How to deal with the proper group
+    static group_size_type num_groups(size_type num)
+    {
+        // how many to hold num buckets
+        return num == 0 ? (group_size_type)0 :
+            (group_size_type)(((num-1) / SPP_GROUP_SIZE) + 1);
+    }
+
+    typename group_type::size_type pos_in_group(size_type i) const
+    {
+        return static_cast<typename group_type::size_type>(i & SPP_MASK_);
+    }
+
+    size_type group_num(size_type i) const
+    {
+        return (size_type)(i >> SPP_SHIFT_);
+    }
+
+    GroupsReference which_group(size_type i)
+    {
+        return _first_group[group_num(i)];
+    }
+
+    GroupsConstReference which_group(size_type i) const
+    {
+        return _first_group[group_num(i)];
+    }
+
+    void _alloc_group_array(group_size_type sz, group_type *&first, group_type *&last)
+    {
+        if (sz)
+        {
+            first = _group_alloc.allocate((size_type)(sz + 1)); // + 1 for end marker
+            first[sz].mark();                      // for the ne_iterator
+            last = first + sz;
+        }
+    }
+
+    void _free_group_array(group_type *&first, group_type *&last)
+    {
+        if (first)
+        {
+            _group_alloc.deallocate(first, (group_size_type)(last - first + 1)); // + 1 for end marker
+            first = last = 0;
+        }
+    }
+
+    void _allocate_groups(size_type sz)
+    {
+        if (sz)
+        {
+            _alloc_group_array(sz, _first_group, _last_group);
+            std::uninitialized_fill(_first_group, _last_group, group_type());
+        }
+    }
+
+    void _free_groups()
+    {
+        if (_first_group)
+        {
+            for (group_type *g = _first_group; g != _last_group; ++g)
+                g->destruct(_alloc);
+            _free_group_array(_first_group, _last_group);
+        }
+    }
+
+    void _cleanup()
+    {
+        _free_groups();    // sets _first_group = _last_group = 0
+        _table_size  = 0;
+        _num_buckets = 0;
+    }
+
+    void _init()
+    {
+        _first_group = 0;
+        _last_group  = 0;
+        _table_size  = 0;
+        _num_buckets = 0;
+    }
+
+    void _copy(const sparsetable &o)
+    {
+        _table_size = o._table_size;
+        _num_buckets = o._num_buckets;
+        _alloc = o._alloc;                // todo - copy or move allocator according to...
+        _group_alloc = o._group_alloc;    // http://en.cppreference.com/w/cpp/container/unordered_map/unordered_map
+
+        group_size_type sz = (group_size_type)(o._last_group - o._first_group);
+        if (sz)
+        {
+            _alloc_group_array(sz, _first_group, _last_group);
+            for (group_size_type i=0; i<sz; ++i)
+                new (_first_group + i) group_type(o._first_group[i], _alloc);
+        }
+    }
+
+public:
+    // Constructors -- default, normal (when you specify size), and copy
+    explicit sparsetable(size_type sz = 0, const allocator_type &alloc = allocator_type()) :
+        _first_group(0),
+        _last_group(0),
+        _table_size(sz),
+        _num_buckets(0),
+        _group_alloc(alloc),
+        _alloc(alloc)
+                       // todo - copy or move allocator according to
+                       // http://en.cppreference.com/w/cpp/container/unordered_map/unordered_map
+    {
+        _allocate_groups(num_groups(sz));
+    }
+
+    ~sparsetable()
+    {
+        _free_groups();
+    }
+
+    sparsetable(const sparsetable &o)
+    {
+        _init();
+        _copy(o);
+    }
+
+    sparsetable& operator=(const sparsetable &o)
+    {
+        _cleanup();
+        _copy(o);
+        return *this;
+    }
+
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+    sparsetable(sparsetable&& o)
+    {
+        _init();
+        this->swap(o);
+    }
+
+    sparsetable(sparsetable&& o, const allocator_type &alloc)
+    {
+        _init();
+        this->swap(o);
+        _alloc = alloc; // [gp todo] is this correct?
+    }
+
+    sparsetable& operator=(sparsetable&& o)
+    {
+        _cleanup();
+        this->swap(o);
+        return *this;
+    }
+#endif
+
+    // Many STL algorithms use swap instead of copy constructors
+    void swap(sparsetable& o)
+    {
+        using std::swap;
+
+        swap(_first_group, o._first_group);
+        swap(_last_group,  o._last_group);
+        swap(_table_size,  o._table_size);
+        swap(_num_buckets, o._num_buckets);
+        if (_alloc != o._alloc)
+            swap(_alloc, o._alloc);
+        if (_group_alloc != o._group_alloc)
+            swap(_group_alloc, o._group_alloc);
+    }
+
+    // It's always nice to be able to clear a table without deallocating it
+    void clear()
+    {
+        _free_groups();
+        _num_buckets = 0;
+        _table_size = 0;
+    }
+
+    inline allocator_type get_allocator() const
+    {
+        return _alloc;
+    }
+
+
+    // Functions that tell you about size.
+    // NOTE: empty() is non-intuitive!  It does not tell you the number
+    // of not-empty buckets (use num_nonempty() for that).  Instead
+    // it says whether you've allocated any buckets or not.
+    // ----------------------------------------------------------------
+    size_type size() const           { return _table_size; }
+    size_type max_size() const       { return _alloc.max_size(); }
+    bool empty() const               { return _table_size == 0; }
+    size_type num_nonempty() const   { return _num_buckets; }
+
+    // OK, we'll let you resize one of these puppies
+    void resize(size_type new_size)
+    {
+        group_size_type sz = num_groups(new_size);
+        group_size_type old_sz = (group_size_type)(_last_group - _first_group);
+
+        if (sz != old_sz)
+        {
+            // resize group array
+            // ------------------
+            group_type *first = 0, *last = 0;
+            if (sz)
+            {
+                _alloc_group_array(sz, first, last);
+                if (old_sz)
+                    memcpy(static_cast<void *>(first), _first_group, sizeof(*first) * (std::min)(sz, old_sz));
+            }
+
+            if (sz < old_sz)
+            {
+                for (group_type *g = _first_group + sz; g != _last_group; ++g)
+                    g->destruct(_alloc);
+            }
+            else
+                std::uninitialized_fill(first + old_sz, last, group_type());
+
+            _free_group_array(_first_group, _last_group);
+            _first_group = first;
+            _last_group  = last;
+        }
+#if 0
+        // used only in test program
+        // todo: fix if sparsetable to be used directly
+        // --------------------------------------------
+        if (new_size < _table_size)
+        {
+            // lower num_buckets, clear last group
+            if (pos_in_group(new_size) > 0)     // need to clear inside last group
+                groups.back().erase(_alloc, groups.back().begin() + pos_in_group(new_size),
+                                    groups.back().end());
+            _num_buckets = 0;                   // refigure # of used buckets
+            for (const group_type *group = _first_group; group != _last_group; ++group)
+                _num_buckets += group->num_nonempty();
+        }
+#endif
+        _table_size = new_size;
+    }
+
+    // We let you see if a bucket is non-empty without retrieving it
+    // -------------------------------------------------------------
+    bool test(size_type i) const
+    {
+        // assert(i < _table_size);
+        return which_group(i).test(pos_in_group(i));
+    }
+
+    // also tests for erased values
+    // ----------------------------
+    bool test_strict(size_type i) const
+    {
+        // assert(i < _table_size);
+        return which_group(i).test_strict(pos_in_group(i));
+    }
+
+    friend struct GrpPos;
+
+    struct GrpPos
+    {
+        typedef typename sparsetable::ne_iterator ne_iter;
+        GrpPos(const sparsetable &table, size_type i) :
+            grp(table.which_group(i)), pos(table.pos_in_group(i)) {}
+
+        bool test_strict() const { return grp.test_strict(pos); }
+        bool test() const        { return grp.test(pos); }
+        typename sparsetable::reference unsafe_get() const { return  grp.unsafe_get(pos); }
+        ne_iter get_iter(typename sparsetable::reference ref)
+        {
+            return ne_iter((group_type *)&grp, &ref);
+        }
+
+        void erase(sparsetable &table) // item *must* be present
+        {
+            assert(table._num_buckets);
+            ((group_type &)grp).erase(table._alloc, pos);
+            --table._num_buckets;
+        }
+
+    private:
+        GrpPos* operator=(const GrpPos&);
+
+        const group_type &grp;
+        typename group_type::size_type pos;
+    };
+
+    bool test(iterator pos) const
+    {
+        return which_group(pos.pos).test(pos_in_group(pos.pos));
+    }
+
+    bool test(const_iterator pos) const
+    {
+        return which_group(pos.pos).test(pos_in_group(pos.pos));
+    }
+
+    // TODO(csilvers): make protected + friend
+    // This is used by sparse_hashtable to get an element from the table
+    // when we know it exists (because the caller has called test(i)).
+    // -----------------------------------------------------------------
+    reference unsafe_get(size_type i) const
+    {
+        assert(i < _table_size);
+        // assert(test(i));
+        return which_group(i).unsafe_get(pos_in_group(i));
+    }
+
+    // Needed for hashtables, gets as a ne_iterator.  Crashes for empty bcks
+    const_ne_iterator get_iter(size_type i) const
+    {
+        //assert(test(i));    // how can a ne_iterator point to an empty bucket?
+
+        size_type grp_idx = group_num(i);
+
+        return const_ne_iterator(_first_group + grp_idx,
+                                 (_first_group[grp_idx].ne_begin() +
+                                  _first_group[grp_idx].pos_to_offset(pos_in_group(i))));
+    }
+
+    const_ne_iterator get_iter(size_type i, ColIterator col_it) const
+    {
+        return const_ne_iterator(_first_group + group_num(i), col_it);
+    }
+
+    // For nonempty we can return a non-const version
+    ne_iterator get_iter(size_type i)
+    {
+        //assert(test(i));    // how can a nonempty_iterator point to an empty bucket?
+
+        size_type grp_idx = group_num(i);
+
+        return ne_iterator(_first_group + grp_idx,
+                           (_first_group[grp_idx].ne_begin() +
+                            _first_group[grp_idx].pos_to_offset(pos_in_group(i))));
+    }
+
+    ne_iterator get_iter(size_type i, ColIterator col_it)
+    {
+        return ne_iterator(_first_group + group_num(i), col_it);
+    }
+
+    // And the reverse transformation.
+    size_type get_pos(const const_ne_iterator& it) const
+    {
+        difference_type current_row = it.row_current - _first_group;
+        difference_type current_col = (it.col_current - _first_group[current_row].ne_begin());
+        return ((current_row * SPP_GROUP_SIZE) +
+                _first_group[current_row].offset_to_pos(current_col));
+    }
+
+    // Val can be reference or const_reference
+    // ---------------------------------------
+    template <class Val>
+    reference set(size_type i, Val &val)
+    {
+        assert(i < _table_size);
+        group_type &group = which_group(i);
+        typename group_type::size_type old_numbuckets = group.num_nonempty();
+        pointer p(group.set(_alloc, pos_in_group(i), val));
+        _num_buckets += group.num_nonempty() - old_numbuckets;
+        return *p;
+    }
+
+    // used in _move_from (where we can move the old value instead of copying it
+    void move(size_type i, reference val)
+    {
+        assert(i < _table_size);
+        which_group(i).set(_alloc, pos_in_group(i), val);
+        ++_num_buckets;
+    }
+
+    // This takes the specified elements out of the table.
+    // --------------------------------------------------
+    void erase(size_type i)
+    {
+        assert(i < _table_size);
+
+        GroupsReference grp(which_group(i));
+        typename group_type::size_type old_numbuckets = grp.num_nonempty();
+        grp.erase(_alloc, pos_in_group(i));
+        _num_buckets += grp.num_nonempty() - old_numbuckets;
+    }
+
+    void erase(iterator pos)
+    {
+        erase(pos.pos);
+    }
+
+    void erase(iterator start_it, iterator end_it)
+    {
+        // This could be more efficient, but then we'd need to figure
+        // out if we spanned groups or not.  Doesn't seem worth it.
+        for (; start_it != end_it; ++start_it)
+            erase(start_it);
+    }
+
+    const_ne_iterator erase(const_ne_iterator it)
+    {
+        ne_iterator res(it);
+        if (res.row_current->erase_ne(_alloc, res))
+            _num_buckets--;
+        return res;
+    }
+
+    const_ne_iterator erase(const_ne_iterator f, const_ne_iterator l)
+    {
+        size_t diff = l - f;
+        while (diff--)
+            f = erase(f);
+        return f;
+    }
+
+    // We support reading and writing tables to disk.  We don't store
+    // the actual array contents (which we don't know how to store),
+    // just the groups and sizes.  Returns true if all went ok.
+
+private:
+    // Every time the disk format changes, this should probably change too
+    typedef unsigned long MagicNumberType;
+    static const MagicNumberType MAGIC_NUMBER = 0x24687531;
+
+    // Old versions of this code write all data in 32 bits.  We need to
+    // support these files as well as having support for 64-bit systems.
+    // So we use the following encoding scheme: for values < 2^32-1, we
+    // store in 4 bytes in big-endian order.  For values > 2^32, we
+    // store 0xFFFFFFF followed by 8 bytes in big-endian order.  This
+    // causes us to mis-read old-version code that stores exactly
+    // 0xFFFFFFF, but I don't think that is likely to have happened for
+    // these particular values.
+    template <typename OUTPUT, typename IntType>
+    static bool write_32_or_64(OUTPUT* fp, IntType value)
+    {
+        if (value < 0xFFFFFFFFULL)        // fits in 4 bytes
+        {
+            if (!sparsehash_internal::write_bigendian_number(fp, value, 4))
+                return false;
+        }
+        else
+        {
+            if (!sparsehash_internal::write_bigendian_number(fp, 0xFFFFFFFFUL, 4))
+                return false;
+            if (!sparsehash_internal::write_bigendian_number(fp, value, 8))
+                return false;
+        }
+        return true;
+    }
+
+    template <typename INPUT, typename IntType>
+    static bool read_32_or_64(INPUT* fp, IntType *value)
+    {
+        // reads into value
+        MagicNumberType first4 = 0;   // a convenient 32-bit unsigned type
+        if (!sparsehash_internal::read_bigendian_number(fp, &first4, 4))
+            return false;
+
+        if (first4 < 0xFFFFFFFFULL)
+        {
+            *value = first4;
+        }
+        else
+        {
+            if (!sparsehash_internal::read_bigendian_number(fp, value, 8))
+                return false;
+        }
+        return true;
+    }
+
+public:
+    // read/write_metadata() and read_write/nopointer_data() are DEPRECATED.
+    // Use serialize() and unserialize(), below, for new code.
+
+    template <typename OUTPUT>
+    bool write_metadata(OUTPUT *fp) const
+    {
+        if (!write_32_or_64(fp, MAGIC_NUMBER))  return false;
+        if (!write_32_or_64(fp, _table_size))  return false;
+        if (!write_32_or_64(fp, _num_buckets))  return false;
+
+        for (const group_type *group = _first_group; group != _last_group; ++group)
+            if (group->write_metadata(fp) == false)
+                return false;
+        return true;
+    }
+
+    // Reading destroys the old table contents!  Returns true if read ok.
+    template <typename INPUT>
+    bool read_metadata(INPUT *fp)
+    {
+        size_type magic_read = 0;
+        if (!read_32_or_64(fp, &magic_read))  return false;
+        if (magic_read != MAGIC_NUMBER)
+        {
+            clear();                        // just to be consistent
+            return false;
+        }
+
+        if (!read_32_or_64(fp, &_table_size))  return false;
+        if (!read_32_or_64(fp, &_num_buckets))  return false;
+
+        resize(_table_size);                    // so the vector's sized ok
+        for (group_type *group = _first_group; group != _last_group; ++group)
+            if (group->read_metadata(_alloc, fp) == false)
+                return false;
+        return true;
+    }
+
+    // This code is identical to that for SparseGroup
+    // If your keys and values are simple enough, we can write them
+    // to disk for you.  "simple enough" means no pointers.
+    // However, we don't try to normalize endianness
+    bool write_nopointer_data(FILE *fp) const
+    {
+        for (const_ne_iterator it = ne_begin(); it != ne_end(); ++it)
+            if (!fwrite(&*it, sizeof(*it), 1, fp))
+                return false;
+        return true;
+    }
+
+    // When reading, we have to override the potential const-ness of *it
+    bool read_nopointer_data(FILE *fp)
+    {
+        for (ne_iterator it = ne_begin(); it != ne_end(); ++it)
+            if (!fread(reinterpret_cast<void*>(&(*it)), sizeof(*it), 1, fp))
+                return false;
+        return true;
+    }
+
+    // INPUT and OUTPUT must be either a FILE, *or* a C++ stream
+    //    (istream, ostream, etc) *or* a class providing
+    //    Read(void*, size_t) and Write(const void*, size_t)
+    //    (respectively), which writes a buffer into a stream
+    //    (which the INPUT/OUTPUT instance presumably owns).
+
+    typedef sparsehash_internal::pod_serializer<value_type> NopointerSerializer;
+
+    // ValueSerializer: a functor.  operator()(OUTPUT*, const value_type&)
+    template <typename ValueSerializer, typename OUTPUT>
+    bool serialize(ValueSerializer serializer, OUTPUT *fp)
+    {
+        if (!write_metadata(fp))
+            return false;
+        for (const_ne_iterator it = ne_begin(); it != ne_end(); ++it)
+            if (!serializer(fp, *it))
+                return false;
+        return true;
+    }
+
+    // ValueSerializer: a functor.  operator()(INPUT*, value_type*)
+    template <typename ValueSerializer, typename INPUT>
+    bool unserialize(ValueSerializer serializer, INPUT *fp)
+    {
+        clear();
+        if (!read_metadata(fp))
+            return false;
+        for (ne_iterator it = ne_begin(); it != ne_end(); ++it)
+            if (!serializer(fp, &*it))
+                return false;
+        return true;
+    }
+
+    // Comparisons.  Note the comparisons are pretty arbitrary: we
+    // compare values of the first index that isn't equal (using default
+    // value for empty buckets).
+    bool operator==(const sparsetable& x) const
+    {
+        return (_table_size == x._table_size &&
+                _num_buckets == x._num_buckets &&
+                _first_group == x._first_group);
+    }
+
+    bool operator<(const sparsetable& x) const
+    {
+        return std::lexicographical_compare(begin(), end(), x.begin(), x.end());
+    }
+    bool operator!=(const sparsetable& x) const { return !(*this == x); }
+    bool operator<=(const sparsetable& x) const { return !(x < *this); }
+    bool operator>(const sparsetable& x)  const { return x < *this; }
+    bool operator>=(const sparsetable& x) const { return !(*this < x); }
+
+
+private:
+    // The actual data
+    // ---------------
+    group_type *     _first_group;
+    group_type *     _last_group;
+    size_type        _table_size;          // how many buckets they want
+    size_type        _num_buckets;         // number of non-empty buckets
+    group_alloc_type _group_alloc;
+    allocator_type   _alloc;
+};
+
+//  ----------------------------------------------------------------------
+//                  S P A R S E _ H A S H T A B L E
+//  ----------------------------------------------------------------------
+// Hashtable class, used to implement the hashed associative containers
+// hash_set and hash_map.
+//
+// Value: what is stored in the table (each bucket is a Value).
+// Key: something in a 1-to-1 correspondence to a Value, that can be used
+//      to search for a Value in the table (find() takes a Key).
+// HashFcn: Takes a Key and returns an integer, the more unique the better.
+// ExtractKey: given a Value, returns the unique Key associated with it.
+//             Must inherit from unary_function, or at least have a
+//             result_type enum indicating the return type of operator().
+// EqualKey: Given two Keys, says whether they are the same (that is,
+//           if they are both associated with the same Value).
+// Alloc: STL allocator to use to allocate memory.
+//
+//  ----------------------------------------------------------------------
+
+// The probing method
+// ------------------
+// Linear probing
+// #define JUMP_(key, num_probes)    ( 1 )
+// Quadratic probing
+#define JUMP_(key, num_probes)    ( num_probes )
+
+
+// -------------------------------------------------------------------
+// -------------------------------------------------------------------
+template <class Value, class Key, class HashFcn,
+          class ExtractKey, class SetKey, class EqualKey, class Alloc>
+class sparse_hashtable
+{
+public:
+    typedef Key                                        key_type;
+    typedef Value                                      value_type;
+    typedef HashFcn                                    hasher; // user provided or spp_hash<Key>
+    typedef EqualKey                                   key_equal;
+    typedef Alloc                                      allocator_type;
+
+    typedef typename allocator_type::size_type         size_type;
+    typedef typename allocator_type::difference_type   difference_type;
+    typedef value_type&                                reference;
+    typedef const value_type&                          const_reference;
+    typedef value_type*                                pointer;
+    typedef const value_type*                          const_pointer;
+
+    // Table is the main storage class.
+    typedef sparsetable<value_type, allocator_type>   Table;
+    typedef typename Table::ne_iterator               ne_it;
+    typedef typename Table::const_ne_iterator         cne_it;
+    typedef typename Table::destructive_iterator      dest_it;
+    typedef typename Table::ColIterator               ColIterator;
+
+    typedef ne_it                                     iterator;
+    typedef cne_it                                    const_iterator;
+    typedef dest_it                                   destructive_iterator;
+
+    // These come from tr1.  For us they're the same as regular iterators.
+    // -------------------------------------------------------------------
+    typedef iterator                                  local_iterator;
+    typedef const_iterator                            const_local_iterator;
+
+    // How full we let the table get before we resize
+    // ----------------------------------------------
+    static const int HT_OCCUPANCY_PCT; // = 80 (out of 100);
+
+    // How empty we let the table get before we resize lower, by default.
+    // (0.0 means never resize lower.)
+    // It should be less than OCCUPANCY_PCT / 2 or we thrash resizing
+    // ------------------------------------------------------------------
+    static const int HT_EMPTY_PCT; // = 0.4 * HT_OCCUPANCY_PCT;
+
+    // Minimum size we're willing to let hashtables be.
+    // Must be a power of two, and at least 4.
+    // Note, however, that for a given hashtable, the initial size is a
+    // function of the first constructor arg, and may be >HT_MIN_BUCKETS.
+    // ------------------------------------------------------------------
+    static const size_type HT_MIN_BUCKETS = 4;
+
+    // By default, if you don't specify a hashtable size at
+    // construction-time, we use this size.  Must be a power of two, and
+    // at least HT_MIN_BUCKETS.
+    // -----------------------------------------------------------------
+    static const size_type HT_DEFAULT_STARTING_BUCKETS = 32;
+
+    // iterators
+    // ---------
+    iterator       begin()        { return _mk_iterator(table.ne_begin());  }
+    iterator       end()          { return _mk_iterator(table.ne_end());    }
+    const_iterator begin() const  { return _mk_const_iterator(table.ne_cbegin()); }
+    const_iterator end() const    { return _mk_const_iterator(table.ne_cend());   }
+    const_iterator cbegin() const { return _mk_const_iterator(table.ne_cbegin()); }
+    const_iterator cend() const   { return _mk_const_iterator(table.ne_cend());   }
+
+    // These come from tr1 unordered_map.  They iterate over 'bucket' n.
+    // For sparsehashtable, we could consider each 'group' to be a bucket,
+    // I guess, but I don't really see the point.  We'll just consider
+    // bucket n to be the n-th element of the sparsetable, if it's occupied,
+    // or some empty element, otherwise.
+    // ---------------------------------------------------------------------
+    local_iterator begin(size_type i)
+    {
+        return _mk_iterator(table.test(i) ? table.get_iter(i) : table.ne_end());
+    }
+
+    local_iterator end(size_type i)
+    {
+        local_iterator it = begin(i);
+        if (table.test(i))
+            ++it;
+        return _mk_iterator(it);
+    }
+
+    const_local_iterator begin(size_type i) const
+    {
+        return _mk_const_iterator(table.test(i) ? table.get_iter(i) : table.ne_cend());
+    }
+
+    const_local_iterator end(size_type i) const
+    {
+        const_local_iterator it = begin(i);
+        if (table.test(i))
+            ++it;
+        return _mk_const_iterator(it);
+    }
+
+    const_local_iterator cbegin(size_type i) const { return begin(i); }
+    const_local_iterator cend(size_type i)   const { return end(i); }
+
+    // This is used when resizing
+    // --------------------------
+    destructive_iterator destructive_begin()       { return _mk_destructive_iterator(table.destructive_begin()); }
+    destructive_iterator destructive_end()         { return _mk_destructive_iterator(table.destructive_end());   }
+
+
+    // accessor functions for the things we templatize on, basically
+    // -------------------------------------------------------------
+    hasher hash_funct() const               { return settings; }
+    key_equal key_eq() const                { return key_info; }
+    allocator_type get_allocator() const    { return table.get_allocator(); }
+
+    // Accessor function for statistics gathering.
+    unsigned int num_table_copies() const { return settings.num_ht_copies(); }
+
+private:
+    // This is used as a tag for the copy constructor, saying to destroy its
+    // arg We have two ways of destructively copying: with potentially growing
+    // the hashtable as we copy, and without.  To make sure the outside world
+    // can't do a destructive copy, we make the typename private.
+    // -----------------------------------------------------------------------
+    enum MoveDontCopyT {MoveDontCopy, MoveDontGrow};
+
+    // creating iterators from sparsetable::ne_iterators
+    // -------------------------------------------------
+    iterator             _mk_iterator(ne_it it) const               { return it; }
+    const_iterator       _mk_const_iterator(cne_it it) const        { return it; }
+    destructive_iterator _mk_destructive_iterator(dest_it it) const { return it; }
+
+public:
+    size_type size() const              { return table.num_nonempty(); }
+    size_type max_size() const          { return table.max_size(); }
+    bool empty() const                  { return size() == 0; }
+    size_type bucket_count() const      { return table.size(); }
+    size_type max_bucket_count() const  { return max_size(); }
+    // These are tr1 methods.  Their idea of 'bucket' doesn't map well to
+    // what we do.  We just say every bucket has 0 or 1 items in it.
+    size_type bucket_size(size_type i) const
+    {
+        return (size_type)(begin(i) == end(i) ? 0 : 1);
+    }
+
+private:
+    // Because of the above, size_type(-1) is never legal; use it for errors
+    // ---------------------------------------------------------------------
+    static const size_type ILLEGAL_BUCKET = size_type(-1);
+
+    // Used after a string of deletes.  Returns true if we actually shrunk.
+    // TODO(csilvers): take a delta so we can take into account inserts
+    // done after shrinking.  Maybe make part of the Settings class?
+    // --------------------------------------------------------------------
+    bool _maybe_shrink()
+    {
+        assert((bucket_count() & (bucket_count()-1)) == 0); // is a power of two
+        assert(bucket_count() >= HT_MIN_BUCKETS);
+        bool retval = false;
+
+        // If you construct a hashtable with < HT_DEFAULT_STARTING_BUCKETS,
+        // we'll never shrink until you get relatively big, and we'll never
+        // shrink below HT_DEFAULT_STARTING_BUCKETS.  Otherwise, something
+        // like "dense_hash_set<int> x; x.insert(4); x.erase(4);" will
+        // shrink us down to HT_MIN_BUCKETS buckets, which is too small.
+        // ---------------------------------------------------------------
+        const size_type num_remain = table.num_nonempty();
+        const size_type shrink_threshold = settings.shrink_threshold();
+        if (shrink_threshold > 0 && num_remain < shrink_threshold &&
+            bucket_count() > HT_DEFAULT_STARTING_BUCKETS)
+        {
+            const float shrink_factor = settings.shrink_factor();
+            size_type sz = (size_type)(bucket_count() / 2);    // find how much we should shrink
+            while (sz > HT_DEFAULT_STARTING_BUCKETS &&
+                   num_remain < static_cast<size_type>(sz * shrink_factor))
+            {
+                sz /= 2;                            // stay a power of 2
+            }
+            sparse_hashtable tmp(MoveDontCopy, *this, sz);
+            swap(tmp);                            // now we are tmp
+            retval = true;
+        }
+        settings.set_consider_shrink(false);   // because we just considered it
+        return retval;
+    }
+
+    // We'll let you resize a hashtable -- though this makes us copy all!
+    // When you resize, you say, "make it big enough for this many more elements"
+    // Returns true if we actually resized, false if size was already ok.
+    // --------------------------------------------------------------------------
+    bool _resize_delta(size_type delta)
+    {
+        bool did_resize = false;
+        if (settings.consider_shrink())
+        {
+            // see if lots of deletes happened
+            if (_maybe_shrink())
+                did_resize = true;
+        }
+        if (table.num_nonempty() >=
+            (std::numeric_limits<size_type>::max)() - delta)
+        {
+            throw_exception(std::length_error("resize overflow"));
+        }
+
+        size_type num_occupied = (size_type)(table.num_nonempty() + num_deleted);
+
+        if (bucket_count() >= HT_MIN_BUCKETS &&
+             (num_occupied + delta) <= settings.enlarge_threshold())
+            return did_resize;                       // we're ok as we are
+
+        // Sometimes, we need to resize just to get rid of all the
+        // "deleted" buckets that are clogging up the hashtable.  So when
+        // deciding whether to resize, count the deleted buckets (which
+        // are currently taking up room).
+        // -------------------------------------------------------------
+        const size_type needed_size =
+                  settings.min_buckets((size_type)(num_occupied + delta), (size_type)0);
+
+        if (needed_size <= bucket_count())      // we have enough buckets
+            return did_resize;
+
+        size_type resize_to = settings.min_buckets((size_type)(num_occupied + delta), bucket_count());
+
+        if (resize_to < needed_size &&    // may double resize_to
+            resize_to < (std::numeric_limits<size_type>::max)() / 2)
+        {
+            // This situation means that we have enough deleted elements,
+            // that once we purge them, we won't actually have needed to
+            // grow.  But we may want to grow anyway: if we just purge one
+            // element, say, we'll have to grow anyway next time we
+            // insert.  Might as well grow now, since we're already going
+            // through the trouble of copying (in order to purge the
+            // deleted elements).
+            const size_type target =
+                static_cast<size_type>(settings.shrink_size((size_type)(resize_to*2)));
+            if (table.num_nonempty() + delta >= target)
+            {
+                // Good, we won't be below the shrink threshhold even if we double.
+                resize_to *= 2;
+            }
+        }
+
+        sparse_hashtable tmp(MoveDontCopy, *this, resize_to);
+        swap(tmp);                             // now we are tmp
+        return true;
+    }
+
+    // Used to actually do the rehashing when we grow/shrink a hashtable
+    // -----------------------------------------------------------------
+    void _copy_from(const sparse_hashtable &ht, size_type min_buckets_wanted)
+    {
+        clear();            // clear table, set num_deleted to 0
+
+        // If we need to change the size of our table, do it now
+        const size_type resize_to = settings.min_buckets(ht.size(), min_buckets_wanted);
+
+        if (resize_to > bucket_count())
+        {
+            // we don't have enough buckets
+            table.resize(resize_to);               // sets the number of buckets
+            settings.reset_thresholds(bucket_count());
+        }
+
+        // We use a normal iterator to get bcks from ht
+        // We could use insert() here, but since we know there are
+        // no duplicates, we can be more efficient
+        assert((bucket_count() & (bucket_count()-1)) == 0);      // a power of two
+        for (const_iterator it = ht.begin(); it != ht.end(); ++it)
+        {
+            size_type num_probes = 0;              // how many times we've probed
+            size_type bucknum;
+            const size_type bucket_count_minus_one = bucket_count() - 1;
+            for (bucknum = hash(get_key(*it)) & bucket_count_minus_one;
+                 table.test(bucknum);                                   // table.test() OK since no erase()
+                 bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one)
+            {
+                ++num_probes;
+                assert(num_probes < bucket_count()
+                       && "Hashtable is full: an error in key_equal<> or hash<>");
+            }
+            table.set(bucknum, *it);               // copies the value to here
+        }
+        settings.inc_num_ht_copies();
+    }
+
+    // Implementation is like _copy_from, but it destroys the table of the
+    // "from" guy by freeing sparsetable memory as we iterate.  This is
+    // useful in resizing, since we're throwing away the "from" guy anyway.
+    // --------------------------------------------------------------------
+    void _move_from(MoveDontCopyT mover, sparse_hashtable &ht,
+                   size_type min_buckets_wanted)
+    {
+        clear();
+
+        // If we need to change the size of our table, do it now
+        size_type resize_to;
+        if (mover == MoveDontGrow)
+            resize_to = ht.bucket_count();       // keep same size as old ht
+        else                                     // MoveDontCopy
+            resize_to = settings.min_buckets(ht.size(), min_buckets_wanted);
+        if (resize_to > bucket_count())
+        {
+            // we don't have enough buckets
+            table.resize(resize_to);               // sets the number of buckets
+            settings.reset_thresholds(bucket_count());
+        }
+
+        // We use a normal iterator to get bcks from ht
+        // We could use insert() here, but since we know there are
+        // no duplicates, we can be more efficient
+        assert((bucket_count() & (bucket_count()-1)) == 0);      // a power of two
+        const size_type bucket_count_minus_one = (const size_type)(bucket_count() - 1);
+
+        // THIS IS THE MAJOR LINE THAT DIFFERS FROM COPY_FROM():
+        for (destructive_iterator it = ht.destructive_begin();
+              it != ht.destructive_end(); ++it)
+        {
+            size_type num_probes = 0;
+            size_type bucknum;
+            for (bucknum = hash(get_key(*it)) & bucket_count_minus_one;
+                 table.test(bucknum);                          // table.test() OK since no erase()
+                 bucknum = (size_type)((bucknum + JUMP_(key, num_probes)) & (bucket_count()-1)))
+            {
+                ++num_probes;
+                assert(num_probes < bucket_count()
+                       && "Hashtable is full: an error in key_equal<> or hash<>");
+            }
+            table.move(bucknum, *it);    // moves the value to here
+        }
+        settings.inc_num_ht_copies();
+    }
+
+
+    // Required by the spec for hashed associative container
+public:
+    // Though the docs say this should be num_buckets, I think it's much
+    // more useful as num_elements.  As a special feature, calling with
+    // req_elements==0 will cause us to shrink if we can, saving space.
+    // -----------------------------------------------------------------
+    void resize(size_type req_elements)
+    {
+        // resize to this or larger
+        if (settings.consider_shrink() || req_elements == 0)
+            _maybe_shrink();
+        if (req_elements > table.num_nonempty())    // we only grow
+            _resize_delta((size_type)(req_elements - table.num_nonempty()));
+    }
+
+    // Get and change the value of shrink_factor and enlarge_factor.  The
+    // description at the beginning of this file explains how to choose
+    // the values.  Setting the shrink parameter to 0.0 ensures that the
+    // table never shrinks.
+    // ------------------------------------------------------------------
+    void get_resizing_parameters(float* shrink, float* grow) const
+    {
+        *shrink = settings.shrink_factor();
+        *grow = settings.enlarge_factor();
+    }
+
+    float get_shrink_factor() const  { return settings.shrink_factor(); }
+    float get_enlarge_factor() const { return settings.enlarge_factor(); }
+
+    void set_resizing_parameters(float shrink, float grow) 
+    {
+        settings.set_resizing_parameters(shrink, grow);
+        settings.reset_thresholds(bucket_count());
+    }
+
+    void set_shrink_factor(float shrink)
+    {
+        set_resizing_parameters(shrink, get_enlarge_factor());
+    }
+
+    void set_enlarge_factor(float grow)
+    {
+        set_resizing_parameters(get_shrink_factor(), grow);
+    }
+
+    // CONSTRUCTORS -- as required by the specs, we take a size,
+    // but also let you specify a hashfunction, key comparator,
+    // and key extractor.  We also define a copy constructor and =.
+    // DESTRUCTOR -- the default is fine, surprisingly.
+    // ------------------------------------------------------------
+    explicit sparse_hashtable(size_type expected_max_items_in_table = 0,
+                              const HashFcn& hf = HashFcn(),
+                              const EqualKey& eql = EqualKey(),
+                              const ExtractKey& ext = ExtractKey(),
+                              const SetKey& set = SetKey(),
+                              const allocator_type& alloc = allocator_type())
+        : settings(hf),
+          key_info(ext, set, eql),
+          num_deleted(0),
+          table((expected_max_items_in_table == 0
+                 ? HT_DEFAULT_STARTING_BUCKETS
+                 : settings.min_buckets(expected_max_items_in_table, 0)),
+                alloc)
+    {
+        settings.reset_thresholds(bucket_count());
+    }
+
+    // As a convenience for resize(), we allow an optional second argument
+    // which lets you make this new hashtable a different size than ht.
+    // We also provide a mechanism of saying you want to "move" the ht argument
+    // into us instead of copying.
+    // ------------------------------------------------------------------------
+    sparse_hashtable(const sparse_hashtable& ht,
+                     size_type min_buckets_wanted = HT_DEFAULT_STARTING_BUCKETS)
+        : settings(ht.settings),
+          key_info(ht.key_info),
+          num_deleted(0),
+          table(0)
+    {
+        settings.reset_thresholds(bucket_count());
+        _copy_from(ht, min_buckets_wanted);
+    }
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+
+    sparse_hashtable(sparse_hashtable&& o, const allocator_type& alloc = allocator_type()) :
+        settings(o.settings),
+        key_info(o.key_info),
+        num_deleted(0),
+        table(HT_DEFAULT_STARTING_BUCKETS, alloc)
+    {
+        settings.reset_thresholds(bucket_count());
+        this->swap(o);
+    }
+
+    sparse_hashtable& operator=(sparse_hashtable&& o)
+    {
+        this->swap(o);
+        return *this;
+    }
+#endif
+
+    sparse_hashtable(MoveDontCopyT mover,
+                     sparse_hashtable& ht,
+                     size_type min_buckets_wanted = HT_DEFAULT_STARTING_BUCKETS)
+        : settings(ht.settings),
+          key_info(ht.key_info),
+          num_deleted(0),
+          table(min_buckets_wanted, ht.table.get_allocator())
+          //table(min_buckets_wanted)
+    {
+        settings.reset_thresholds(bucket_count());
+        _move_from(mover, ht, min_buckets_wanted);
+    }
+
+    sparse_hashtable& operator=(const sparse_hashtable& ht)
+    {
+        if (&ht == this)
+            return *this;        // don't copy onto ourselves
+        settings = ht.settings;
+        key_info = ht.key_info;
+        num_deleted = ht.num_deleted;
+
+        // _copy_from() calls clear and sets num_deleted to 0 too
+        _copy_from(ht, HT_MIN_BUCKETS);
+
+        // we purposefully don't copy the allocator, which may not be copyable
+        return *this;
+    }
+
+    // Many STL algorithms use swap instead of copy constructors
+    void swap(sparse_hashtable& ht)
+    {
+        using std::swap;
+
+        swap(settings, ht.settings);
+        swap(key_info, ht.key_info);
+        swap(num_deleted, ht.num_deleted);
+        table.swap(ht.table);
+        settings.reset_thresholds(bucket_count());  // also resets consider_shrink
+        ht.settings.reset_thresholds(ht.bucket_count());
+        // we purposefully don't swap the allocator, which may not be swap-able
+    }
+
+    // It's always nice to be able to clear a table without deallocating it
+    void clear()
+    {
+        if (!empty() || num_deleted != 0)
+        {
+            table.clear();
+            table = Table(HT_DEFAULT_STARTING_BUCKETS, table.get_allocator());
+        }
+        settings.reset_thresholds(bucket_count());
+        num_deleted = 0;
+    }
+
+    // LOOKUP ROUTINES
+private:
+
+    enum pos_type { pt_empty = 0, pt_erased, pt_full };
+    // -------------------------------------------------------------------
+    class Position
+    {
+    public:
+
+        Position() : _t(pt_empty) {}
+        Position(pos_type t, size_type idx) : _t(t), _idx(idx) {}
+
+        pos_type  _t;
+        size_type _idx;
+    };
+
+    // Returns a pair:
+    //   - 'first' is a code, 2 if key already present, 0 or 1 otherwise.
+    //   - 'second' is a position, where the key should go
+    // Note: because of deletions where-to-insert is not trivial: it's the
+    // first deleted bucket we see, as long as we don't find the key later
+    // -------------------------------------------------------------------
+    Position _find_position(const key_type &key) const
+    {
+        size_type num_probes = 0;                    // how many times we've probed
+        const size_type bucket_count_minus_one = (const size_type)(bucket_count() - 1);
+        size_type bucknum = hash(key) & bucket_count_minus_one;
+        Position pos;
+
+        while (1)
+        {
+            // probe until something happens
+            // -----------------------------
+            typename Table::GrpPos grp_pos(table, bucknum);
+
+            if (!grp_pos.test_strict())
+            {
+                // bucket is empty => key not present
+                return pos._t ? pos : Position(pt_empty, bucknum);
+            }
+            else if (grp_pos.test())
+            {
+                reference ref(grp_pos.unsafe_get());
+
+                if (equals(key, get_key(ref)))
+                    return Position(pt_full, bucknum);
+            }
+            else if (pos._t == pt_empty)
+            {
+                // first erased position
+                pos._t   = pt_erased;
+                pos._idx = bucknum;
+            }
+
+            ++num_probes;                        // we're doing another probe
+            bucknum = (size_type)((bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one);
+            assert(num_probes < bucket_count()
+                   && "Hashtable is full: an error in key_equal<> or hash<>");
+        }
+    }
+
+public:
+    // I hate to duplicate find() like that, but it is
+    // significantly faster to not have the intermediate pair
+    // ------------------------------------------------------------------
+    iterator find(const key_type& key)
+    {
+        size_type num_probes = 0;              // how many times we've probed
+        const size_type bucket_count_minus_one = bucket_count() - 1;
+        size_type bucknum = hash(key) & bucket_count_minus_one;
+
+        while (1)                        // probe until something happens
+        {
+            typename Table::GrpPos grp_pos(table, bucknum);
+
+            if (!grp_pos.test_strict())
+                return end();            // bucket is empty
+            if (grp_pos.test())
+            {
+                reference ref(grp_pos.unsafe_get());
+
+                if (equals(key, get_key(ref)))
+                    return grp_pos.get_iter(ref);
+            }
+            ++num_probes;                        // we're doing another probe
+            bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
+            assert(num_probes < bucket_count()
+                   && "Hashtable is full: an error in key_equal<> or hash<>");
+        }
+    }
+
+    // Wish I could avoid the duplicate find() const and non-const.
+    // ------------------------------------------------------------
+    const_iterator find(const key_type& key) const
+    {
+        size_type num_probes = 0;              // how many times we've probed
+        const size_type bucket_count_minus_one = bucket_count() - 1;
+        size_type bucknum = hash(key) & bucket_count_minus_one;
+
+        while (1)                        // probe until something happens
+        {
+            typename Table::GrpPos grp_pos(table, bucknum);
+
+            if (!grp_pos.test_strict())
+                return end();            // bucket is empty
+            else if (grp_pos.test())
+            {
+                reference ref(grp_pos.unsafe_get());
+
+                if (equals(key, get_key(ref)))
+                    return _mk_const_iterator(table.get_iter(bucknum, &ref));
+            }
+            ++num_probes;                        // we're doing another probe
+            bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
+            assert(num_probes < bucket_count()
+                   && "Hashtable is full: an error in key_equal<> or hash<>");
+        }
+    }
+
+    // This is a tr1 method: the bucket a given key is in, or what bucket
+    // it would be put in, if it were to be inserted.  Shrug.
+    // ------------------------------------------------------------------
+    size_type bucket(const key_type& key) const
+    {
+        Position pos = _find_position(key);
+        return pos._idx;
+    }
+
+    // Counts how many elements have key key.  For maps, it's either 0 or 1.
+    // ---------------------------------------------------------------------
+    size_type count(const key_type &key) const
+    {
+        Position pos = _find_position(key);
+        return (size_type)(pos._t == pt_full ? 1 : 0);
+    }
+
+    // Likewise, equal_range doesn't really make sense for us.  Oh well.
+    // -----------------------------------------------------------------
+    std::pair<iterator,iterator> equal_range(const key_type& key)
+    {
+        iterator pos = find(key);      // either an iterator or end
+        if (pos == end())
+            return std::pair<iterator,iterator>(pos, pos);
+        else
+        {
+            const iterator startpos = pos++;
+            return std::pair<iterator,iterator>(startpos, pos);
+        }
+    }
+
+    std::pair<const_iterator,const_iterator> equal_range(const key_type& key) const
+    {
+        const_iterator pos = find(key);      // either an iterator or end
+        if (pos == end())
+            return std::pair<const_iterator,const_iterator>(pos, pos);
+        else
+        {
+            const const_iterator startpos = pos++;
+            return std::pair<const_iterator,const_iterator>(startpos, pos);
+        }
+    }
+
+
+    // INSERTION ROUTINES
+private:
+    // Private method used by insert_noresize and find_or_insert.
+    template <class T>
+    reference _insert_at(T& obj, size_type pos, bool erased)
+    {
+        if (size() >= max_size())
+        {
+            throw_exception(std::length_error("insert overflow"));
+        }
+        if (erased)
+        {
+            assert(num_deleted);
+            --num_deleted;
+        }
+        return table.set(pos, obj);
+    }
+
+    // If you know *this is big enough to hold obj, use this routine
+    template <class T>
+    std::pair<iterator, bool> _insert_noresize(T& obj)
+    {
+        Position pos = _find_position(get_key(obj));
+        bool already_there = (pos._t == pt_full);
+
+        if (!already_there)
+        {
+            reference ref(_insert_at(obj, pos._idx, pos._t == pt_erased));
+            return std::pair<iterator, bool>(_mk_iterator(table.get_iter(pos._idx, &ref)), true);
+        }
+        return std::pair<iterator,bool>(_mk_iterator(table.get_iter(pos._idx)), false);
+    }
+
+    // Specializations of insert(it, it) depending on the power of the iterator:
+    // (1) Iterator supports operator-, resize before inserting
+    template <class ForwardIterator>
+    void _insert(ForwardIterator f, ForwardIterator l, std::forward_iterator_tag /*unused*/)
+    {
+        int64_t dist = std::distance(f, l);
+        if (dist < 0 ||  static_cast<size_t>(dist) >= (std::numeric_limits<size_type>::max)())
+            throw_exception(std::length_error("insert-range overflow"));
+
+        _resize_delta(static_cast<size_type>(dist));
+
+        for (; dist > 0; --dist, ++f)
+            _insert_noresize(*f);
+    }
+
+    // (2) Arbitrary iterator, can't tell how much to resize
+    template <class InputIterator>
+    void _insert(InputIterator f, InputIterator l, std::input_iterator_tag /*unused*/)
+    {
+        for (; f != l; ++f)
+            _insert(*f);
+    }
+
+public:
+
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class... Args>
+    std::pair<iterator, bool> emplace(Args&&... args)
+    {
+        _resize_delta(1);
+        value_type obj(std::forward<Args>(args)...);
+        return _insert_noresize(obj);
+    }
+#endif
+
+    // This is the normal insert routine, used by the outside world
+    std::pair<iterator, bool> insert(const_reference obj)
+    {
+        _resize_delta(1);                      // adding an object, grow if need be
+        return _insert_noresize(obj);
+    }
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+    template< class P >
+    std::pair<iterator, bool> insert(P &&obj)
+    {
+        _resize_delta(1);                      // adding an object, grow if need be
+        value_type val(std::forward<P>(obj));
+        return _insert_noresize(val);
+    }
+#endif
+
+    // When inserting a lot at a time, we specialize on the type of iterator
+    template <class InputIterator>
+    void insert(InputIterator f, InputIterator l)
+    {
+        // specializes on iterator type
+        _insert(f, l,
+               typename std::iterator_traits<InputIterator>::iterator_category());
+    }
+
+    // DefaultValue is a functor that takes a key and returns a value_type
+    // representing the default value to be inserted if none is found.
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class DefaultValue, class KT>
+    value_type& find_or_insert(KT&& key)
+#else
+    template <class DefaultValue>
+    value_type& find_or_insert(const key_type& key)
+#endif
+    {
+        size_type num_probes = 0;              // how many times we've probed
+        const size_type bucket_count_minus_one = bucket_count() - 1;
+        size_type bucknum = hash(key) & bucket_count_minus_one;
+        DefaultValue default_value;
+        size_type erased_pos = 0;
+        bool erased = false;
+
+        while (1)                        // probe until something happens
+        {
+            typename Table::GrpPos grp_pos(table, bucknum);
+
+            if (!grp_pos.test_strict())
+            {
+                // not found
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+                auto&& def(default_value(std::forward<KT>(key)));
+#else
+                value_type def(default_value(key));
+#endif                
+                if (_resize_delta(1))
+                {
+                    // needed to rehash to make room
+                    // Since we resized, we can't use pos, so recalculate where to insert.
+                    return *(_insert_noresize(def).first);
+                }
+                else
+                {
+                    // no need to rehash, insert right here
+                    return _insert_at(def, erased ? erased_pos : bucknum, erased);
+                }
+            }
+            if (grp_pos.test())
+            {
+                reference ref(grp_pos.unsafe_get());
+
+                if (equals(key, get_key(ref)))
+                    return ref;
+            }
+            else if (!erased)
+            {
+                // first erased position
+                erased_pos = bucknum;
+                erased = true;
+            }
+
+            ++num_probes;                        // we're doing another probe
+            bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
+            assert(num_probes < bucket_count()
+                   && "Hashtable is full: an error in key_equal<> or hash<>");
+        }
+    }
+
+    size_type erase(const key_type& key)
+    {
+        size_type num_probes = 0;              // how many times we've probed
+        const size_type bucket_count_minus_one = bucket_count() - 1;
+        size_type bucknum = hash(key) & bucket_count_minus_one;
+
+        while (1)                        // probe until something happens
+        {
+            typename Table::GrpPos grp_pos(table, bucknum);
+
+            if (!grp_pos.test_strict())
+                return 0;            // bucket is empty, we deleted nothing
+            if (grp_pos.test())
+            {
+                reference ref(grp_pos.unsafe_get());
+
+                if (equals(key, get_key(ref)))
+                {
+                    grp_pos.erase(table);
+                    ++num_deleted;
+                    settings.set_consider_shrink(true); // will think about shrink after next insert
+                    return 1;                           // because we deleted one thing
+                }
+            }
+            ++num_probes;                        // we're doing another probe
+            bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
+            assert(num_probes < bucket_count()
+                   && "Hashtable is full: an error in key_equal<> or hash<>");
+        }
+    }
+
+    const_iterator erase(const_iterator pos)
+    {
+        if (pos == cend())
+            return cend();                 // sanity check
+
+        const_iterator nextpos = table.erase(pos);
+        ++num_deleted;
+        settings.set_consider_shrink(true);
+        return nextpos;
+    }
+
+    const_iterator erase(const_iterator f, const_iterator l)
+    {
+        if (f == cend())
+            return cend();                // sanity check
+
+        size_type num_before = table.num_nonempty();
+        const_iterator nextpos = table.erase(f, l);
+        num_deleted += num_before - table.num_nonempty();
+        settings.set_consider_shrink(true);
+        return nextpos;
+    }
+
+    // Deleted key routines - just to keep google test framework happy
+    // we don't actually use the deleted key
+    // ---------------------------------------------------------------
+    void set_deleted_key(const key_type&)
+    {
+    }
+
+    void clear_deleted_key()
+    {
+    }
+
+    bool operator==(const sparse_hashtable& ht) const
+    {
+        if (this == &ht)
+            return true;
+
+        if (size() != ht.size())
+            return false;
+
+        for (const_iterator it = begin(); it != end(); ++it)
+        {
+            const_iterator it2 = ht.find(get_key(*it));
+            if ((it2 == ht.end()) || (*it != *it2))
+                return false;
+        }
+
+        return true;
+    }
+
+    bool operator!=(const sparse_hashtable& ht) const
+    {
+        return !(*this == ht);
+    }
+
+
+    // I/O
+    // We support reading and writing hashtables to disk.  NOTE that
+    // this only stores the hashtable metadata, not the stuff you've
+    // actually put in the hashtable!  Alas, since I don't know how to
+    // write a hasher or key_equal, you have to make sure everything
+    // but the table is the same.  We compact before writing.
+    //
+    // The OUTPUT type needs to support a Write() operation. File and
+    // OutputBuffer are appropriate types to pass in.
+    //
+    // The INPUT type needs to support a Read() operation. File and
+    // InputBuffer are appropriate types to pass in.
+    // -------------------------------------------------------------
+    template <typename OUTPUT>
+    bool write_metadata(OUTPUT *fp)
+    {
+        return table.write_metadata(fp);
+    }
+
+    template <typename INPUT>
+    bool read_metadata(INPUT *fp)
+    {
+        num_deleted = 0;            // since we got rid before writing
+        const bool result = table.read_metadata(fp);
+        settings.reset_thresholds(bucket_count());
+        return result;
+    }
+
+    // Only meaningful if value_type is a POD.
+    template <typename OUTPUT>
+    bool write_nopointer_data(OUTPUT *fp)
+    {
+        return table.write_nopointer_data(fp);
+    }
+
+    // Only meaningful if value_type is a POD.
+    template <typename INPUT>
+    bool read_nopointer_data(INPUT *fp)
+    {
+        return table.read_nopointer_data(fp);
+    }
+
+    // INPUT and OUTPUT must be either a FILE, *or* a C++ stream
+    //    (istream, ostream, etc) *or* a class providing
+    //    Read(void*, size_t) and Write(const void*, size_t)
+    //    (respectively), which writes a buffer into a stream
+    //    (which the INPUT/OUTPUT instance presumably owns).
+
+    typedef sparsehash_internal::pod_serializer<value_type> NopointerSerializer;
+
+    // ValueSerializer: a functor.  operator()(OUTPUT*, const value_type&)
+    template <typename ValueSerializer, typename OUTPUT>
+    bool serialize(ValueSerializer serializer, OUTPUT *fp)
+    {
+        return table.serialize(serializer, fp);
+    }
+
+    // ValueSerializer: a functor.  operator()(INPUT*, value_type*)
+    template <typename ValueSerializer, typename INPUT>
+    bool unserialize(ValueSerializer serializer, INPUT *fp)
+    {
+        num_deleted = 0;            // since we got rid before writing
+        const bool result = table.unserialize(serializer, fp);
+        settings.reset_thresholds(bucket_count());
+        return result;
+    }
+
+private:
+
+    // Package templated functors with the other types to eliminate memory
+    // needed for storing these zero-size operators.  Since ExtractKey and
+    // hasher's operator() might have the same function signature, they
+    // must be packaged in different classes.
+    // -------------------------------------------------------------------------
+    struct Settings :
+        sparsehash_internal::sh_hashtable_settings<key_type, hasher,
+                                                   size_type, HT_MIN_BUCKETS>
+    {
+        explicit Settings(const hasher& hf)
+            : sparsehash_internal::sh_hashtable_settings<key_type, hasher, size_type,
+              HT_MIN_BUCKETS>
+              (hf, HT_OCCUPANCY_PCT / 100.0f, HT_EMPTY_PCT / 100.0f) {}
+    };
+
+    // KeyInfo stores delete key and packages zero-size functors:
+    // ExtractKey and SetKey.
+     // ---------------------------------------------------------
+    class KeyInfo : public ExtractKey, public SetKey, public EqualKey
+    {
+    public:
+        KeyInfo(const ExtractKey& ek, const SetKey& sk, const EqualKey& eq)
+            : ExtractKey(ek), SetKey(sk), EqualKey(eq)
+        {
+        }
+
+        // We want to return the exact same type as ExtractKey: Key or const Key&
+        typename ExtractKey::result_type get_key(const_reference v) const
+        {
+            return ExtractKey::operator()(v);
+        }
+
+        bool equals(const key_type& a, const key_type& b) const
+        {
+            return EqualKey::operator()(a, b);
+        }
+    };
+
+    // Utility functions to access the templated operators
+    size_t hash(const key_type& v) const
+    {
+        return settings.hash(v);
+    }
+
+    bool equals(const key_type& a, const key_type& b) const
+    {
+        return key_info.equals(a, b);
+    }
+
+    typename ExtractKey::result_type get_key(const_reference v) const
+    {
+        return key_info.get_key(v);
+    }
+
+private:
+    // Actual data
+    // -----------
+    Settings  settings;
+    KeyInfo   key_info;
+    size_type num_deleted;
+    Table     table;         // holds num_buckets and num_elements too
+};
+
+#undef JUMP_
+
+// -----------------------------------------------------------------------------
+template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
+const typename sparse_hashtable<V,K,HF,ExK,SetK,EqK,A>::size_type
+sparse_hashtable<V,K,HF,ExK,SetK,EqK,A>::ILLEGAL_BUCKET;
+
+// How full we let the table get before we resize.  Knuth says .8 is
+// good -- higher causes us to probe too much, though saves memory
+// -----------------------------------------------------------------------------
+template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
+const int sparse_hashtable<V,K,HF,ExK,SetK,EqK,A>::HT_OCCUPANCY_PCT = 50;
+
+// How empty we let the table get before we resize lower.
+// It should be less than OCCUPANCY_PCT / 2 or we thrash resizing
+// -----------------------------------------------------------------------------
+template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
+const int sparse_hashtable<V,K,HF,ExK,SetK,EqK,A>::HT_EMPTY_PCT
+= static_cast<int>(0.4 *
+                   sparse_hashtable<V,K,HF,ExK,SetK,EqK,A>::HT_OCCUPANCY_PCT);
+
+
+//  ----------------------------------------------------------------------
+//                   S P A R S E _ H A S H _ M A P
+//  ----------------------------------------------------------------------
+template <class Key, class T,
+          class HashFcn  = spp_hash<Key>,
+          class EqualKey = std::equal_to<Key>,
+          class Alloc    = SPP_DEFAULT_ALLOCATOR<std::pair<const Key, T> > >
+class sparse_hash_map
+{
+public:
+    typedef typename std::pair<const Key, T> value_type;
+
+private:
+    // Apparently select1st is not stl-standard, so we define our own
+    struct SelectKey
+    {
+        typedef const Key& result_type;
+
+        inline const Key& operator()(const value_type& p) const
+        {
+            return p.first;
+        }
+    };
+
+    struct SetKey
+    {
+        inline void operator()(value_type* value, const Key& new_key) const
+        {
+            *const_cast<Key*>(&value->first) = new_key;
+        }
+    };
+
+    // For operator[].
+    struct DefaultValue
+    {
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+        template <class KT>
+        inline value_type operator()(KT&& key)  const
+        {
+            return { std::forward<KT>(key), T() };
+        }
+#else
+        inline value_type operator()(const Key& key)  const
+        {
+            return std::make_pair(key, T());
+        }
+#endif
+    };
+
+    // The actual data
+    typedef sparse_hashtable<value_type, Key, HashFcn, SelectKey,
+                             SetKey, EqualKey, Alloc> ht;
+
+public:
+    typedef typename ht::key_type             key_type;
+    typedef T                                 data_type;
+    typedef T                                 mapped_type;
+    typedef typename ht::hasher               hasher;
+    typedef typename ht::key_equal            key_equal;
+    typedef Alloc                             allocator_type;
+
+    typedef typename ht::size_type            size_type;
+    typedef typename ht::difference_type      difference_type;
+    typedef typename ht::pointer              pointer;
+    typedef typename ht::const_pointer        const_pointer;
+    typedef typename ht::reference            reference;
+    typedef typename ht::const_reference      const_reference;
+
+    typedef typename ht::iterator             iterator;
+    typedef typename ht::const_iterator       const_iterator;
+    typedef typename ht::local_iterator       local_iterator;
+    typedef typename ht::const_local_iterator const_local_iterator;
+
+    // Iterator functions
+    iterator       begin()                         { return rep.begin(); }
+    iterator       end()                           { return rep.end(); }
+    const_iterator begin() const                   { return rep.cbegin(); }
+    const_iterator end() const                     { return rep.cend(); }
+    const_iterator cbegin() const                  { return rep.cbegin(); }
+    const_iterator cend() const                    { return rep.cend(); }
+
+    // These come from tr1's unordered_map. For us, a bucket has 0 or 1 elements.
+    local_iterator begin(size_type i)              { return rep.begin(i); }
+    local_iterator end(size_type i)                { return rep.end(i); }
+    const_local_iterator begin(size_type i) const  { return rep.begin(i); }
+    const_local_iterator end(size_type i) const    { return rep.end(i); }
+    const_local_iterator cbegin(size_type i) const { return rep.cbegin(i); }
+    const_local_iterator cend(size_type i) const   { return rep.cend(i); }
+
+    // Accessor functions
+    // ------------------
+    allocator_type get_allocator() const           { return rep.get_allocator(); }
+    hasher hash_funct() const                      { return rep.hash_funct(); }
+    hasher hash_function() const                   { return hash_funct(); }
+    key_equal key_eq() const                       { return rep.key_eq(); }
+
+
+    // Constructors
+    // ------------
+    explicit sparse_hash_map(size_type n = 0,
+                             const hasher& hf = hasher(),
+                             const key_equal& eql = key_equal(),
+                             const allocator_type& alloc = allocator_type())
+        : rep(n, hf, eql, SelectKey(), SetKey(), alloc)
+    {
+    }
+
+    explicit sparse_hash_map(const allocator_type& alloc) :
+        rep(0, hasher(), key_equal(), SelectKey(), SetKey(), alloc)
+    {
+    }
+
+    sparse_hash_map(size_type n, const allocator_type& alloc) :
+        rep(n, hasher(), key_equal(), SelectKey(), SetKey(), alloc)
+    {
+    }
+
+    sparse_hash_map(size_type n, const hasher& hf, const allocator_type& alloc) :
+        rep(n, hf, key_equal(), SelectKey(), SetKey(), alloc)
+    {
+    }
+
+    template <class InputIterator>
+    sparse_hash_map(InputIterator f, InputIterator l,
+                    size_type n = 0,
+                    const hasher& hf = hasher(),
+                    const key_equal& eql = key_equal(),
+                    const allocator_type& alloc = allocator_type())
+        : rep(n, hf, eql, SelectKey(), SetKey(), alloc)
+    {
+        rep.insert(f, l);
+    }
+
+    template <class InputIterator>
+    sparse_hash_map(InputIterator f, InputIterator l,
+                    size_type n, const allocator_type& alloc)
+        : rep(n, hasher(), key_equal(), SelectKey(), SetKey(), alloc)
+    {
+        rep.insert(f, l);
+    }
+
+    template <class InputIterator>
+    sparse_hash_map(InputIterator f, InputIterator l,
+                    size_type n, const hasher& hf, const allocator_type& alloc)
+        : rep(n, hf, key_equal(), SelectKey(), SetKey(), alloc)
+    {
+        rep.insert(f, l);
+    }
+
+    sparse_hash_map(const sparse_hash_map &o) :
+        rep(o.rep)
+    {}
+
+    sparse_hash_map(const sparse_hash_map &o,
+                    const allocator_type& alloc) :
+        rep(o.rep, alloc)
+    {}
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+    sparse_hash_map(sparse_hash_map &&o) :
+        rep(std::move(o.rep))
+    {}
+
+    sparse_hash_map(sparse_hash_map &&o,
+                    const allocator_type& alloc) :
+        rep(std::move(o.rep), alloc)
+    {}
+
+    sparse_hash_map& operator=(sparse_hash_map &&o) = default;
+#endif
+
+#if !defined(SPP_NO_CXX11_HDR_INITIALIZER_LIST)
+    sparse_hash_map(std::initializer_list<value_type> init,
+                    size_type n = 0,
+                    const hasher& hf = hasher(),
+                    const key_equal& eql = key_equal(),
+                    const allocator_type& alloc = allocator_type())
+        : rep(n, hf, eql, SelectKey(), SetKey(), alloc)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+    sparse_hash_map(std::initializer_list<value_type> init,
+                    size_type n, const allocator_type& alloc) :
+        rep(n, hasher(), key_equal(), SelectKey(), SetKey(), alloc)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+    sparse_hash_map(std::initializer_list<value_type> init,
+                    size_type n, const hasher& hf, const allocator_type& alloc) :
+        rep(n, hf, key_equal(), SelectKey(), SetKey(), alloc)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+    sparse_hash_map& operator=(std::initializer_list<value_type> init)
+    {
+        rep.clear();
+        rep.insert(init.begin(), init.end());
+        return *this;
+    }
+
+    void insert(std::initializer_list<value_type> init)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+#endif
+
+    sparse_hash_map& operator=(const sparse_hash_map &o)
+    {
+        rep = o.rep;
+        return *this;
+    }
+
+    void clear()                        { rep.clear(); }
+    void swap(sparse_hash_map& hs)      { rep.swap(hs.rep); }
+
+    // Functions concerning size
+    // -------------------------
+    size_type size() const              { return rep.size(); }
+    size_type max_size() const          { return rep.max_size(); }
+    bool empty() const                  { return rep.empty(); }
+    size_type bucket_count() const      { return rep.bucket_count(); }
+    size_type max_bucket_count() const  { return rep.max_bucket_count(); }
+
+    size_type bucket_size(size_type i) const    { return rep.bucket_size(i); }
+    size_type bucket(const key_type& key) const { return rep.bucket(key); }
+    float     load_factor() const       { return size() * 1.0f / bucket_count(); }
+
+    float max_load_factor() const      { return rep.get_enlarge_factor(); }
+    void  max_load_factor(float grow)  { rep.set_enlarge_factor(grow); }
+
+    float min_load_factor() const      { return rep.get_shrink_factor(); }
+    void  min_load_factor(float shrink){ rep.set_shrink_factor(shrink); }
+
+    void set_resizing_parameters(float shrink, float grow)
+    {
+        rep.set_resizing_parameters(shrink, grow);
+    }
+
+    void resize(size_type cnt)        { rep.resize(cnt); }
+    void rehash(size_type cnt)        { resize(cnt); } // c++11 name
+    void reserve(size_type cnt)       { resize(cnt); } // c++11
+
+    // Lookup
+    // ------
+    iterator find(const key_type& key)                 { return rep.find(key); }
+    const_iterator find(const key_type& key) const     { return rep.find(key); }
+    bool contains(const key_type& key) const           { return rep.find(key) != rep.end(); }
+
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class KT>
+    mapped_type& operator[](KT&& key)
+    {
+        return rep.template find_or_insert<DefaultValue>(std::forward<KT>(key)).second;
+    }
+#else
+    mapped_type& operator[](const key_type& key)
+    {
+        return rep.template find_or_insert<DefaultValue>(key).second;
+    }
+#endif
+
+    size_type count(const key_type& key) const         { return rep.count(key); }
+
+    std::pair<iterator, iterator>
+    equal_range(const key_type& key)             { return rep.equal_range(key); }
+
+    std::pair<const_iterator, const_iterator>
+    equal_range(const key_type& key) const       { return rep.equal_range(key); }
+
+    mapped_type& at(const key_type& key)
+    {
+        iterator it = rep.find(key);
+        if (it == rep.end())
+            throw_exception(std::out_of_range("at: key not present"));
+        return it->second;
+    }
+
+    const mapped_type& at(const key_type& key) const
+    {
+        const_iterator it = rep.find(key);
+        if (it == rep.cend())
+            throw_exception(std::out_of_range("at: key not present"));
+        return it->second;
+    }
+
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class... Args>
+    std::pair<iterator, bool> emplace(Args&&... args)
+    {
+        return rep.emplace(std::forward<Args>(args)...);
+    }
+
+    template <class... Args>
+    iterator emplace_hint(const_iterator , Args&&... args)
+    {
+        return rep.emplace(std::forward<Args>(args)...).first;
+    }
+#endif
+
+    // Insert
+    // ------
+    std::pair<iterator, bool>
+    insert(const value_type& obj)                    { return rep.insert(obj); }
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+    template< class P >
+    std::pair<iterator, bool> insert(P&& obj)        { return rep.insert(std::forward<P>(obj)); }
+#endif
+
+    template <class InputIterator>
+    void insert(InputIterator f, InputIterator l)    { rep.insert(f, l); }
+
+    void insert(const_iterator f, const_iterator l)  { rep.insert(f, l); }
+
+    iterator insert(iterator /*unused*/, const value_type& obj) { return insert(obj).first; }
+    iterator insert(const_iterator /*unused*/, const value_type& obj) { return insert(obj).first; }
+
+    // Deleted key routines - just to keep google test framework happy
+    // we don't actually use the deleted key
+    // ---------------------------------------------------------------
+    void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
+    void clear_deleted_key()                    { rep.clear_deleted_key();  }
+    key_type deleted_key() const                { return rep.deleted_key(); }
+
+    // Erase
+    // -----
+    size_type erase(const key_type& key)               { return rep.erase(key); }
+    iterator  erase(iterator it)                       { return rep.erase(it); }
+    iterator  erase(iterator f, iterator l)            { return rep.erase(f, l); }
+    iterator  erase(const_iterator it)                 { return rep.erase(it); }
+    iterator  erase(const_iterator f, const_iterator l){ return rep.erase(f, l); }
+
+    // Comparison
+    // ----------
+    bool operator==(const sparse_hash_map& hs) const   { return rep == hs.rep; }
+    bool operator!=(const sparse_hash_map& hs) const   { return rep != hs.rep; }
+
+
+    // I/O -- this is an add-on for writing metainformation to disk
+    //
+    // For maximum flexibility, this does not assume a particular
+    // file type (though it will probably be a FILE *).  We just pass
+    // the fp through to rep.
+
+    // If your keys and values are simple enough, you can pass this
+    // serializer to serialize()/unserialize().  "Simple enough" means
+    // value_type is a POD type that contains no pointers.  Note,
+    // however, we don't try to normalize endianness.
+    // ---------------------------------------------------------------
+    typedef typename ht::NopointerSerializer NopointerSerializer;
+
+    // serializer: a class providing operator()(OUTPUT*, const value_type&)
+    //    (writing value_type to OUTPUT).  You can specify a
+    //    NopointerSerializer object if appropriate (see above).
+    // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
+    //    pointer to a class providing size_t Write(const void*, size_t),
+    //    which writes a buffer into a stream (which fp presumably
+    //    owns) and returns the number of bytes successfully written.
+    //    Note basic_ostream<not_char> is not currently supported.
+    // ---------------------------------------------------------------
+    template <typename ValueSerializer, typename OUTPUT>
+    bool serialize(ValueSerializer serializer, OUTPUT* fp)
+    {
+        return rep.serialize(serializer, fp);
+    }
+
+    // serializer: a functor providing operator()(INPUT*, value_type*)
+    //    (reading from INPUT and into value_type).  You can specify a
+    //    NopointerSerializer object if appropriate (see above).
+    // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
+    //    pointer to a class providing size_t Read(void*, size_t),
+    //    which reads into a buffer from a stream (which fp presumably
+    //    owns) and returns the number of bytes successfully read.
+    //    Note basic_istream<not_char> is not currently supported.
+    // NOTE: Since value_type is std::pair<const Key, T>, ValueSerializer
+    // may need to do a const cast in order to fill in the key.
+    // NOTE: if Key or T are not POD types, the serializer MUST use
+    // placement-new to initialize their values, rather than a normal
+    // equals-assignment or similar.  (The value_type* passed into the
+    // serializer points to garbage memory.)
+    // ---------------------------------------------------------------
+    template <typename ValueSerializer, typename INPUT>
+    bool unserialize(ValueSerializer serializer, INPUT* fp)
+    {
+        return rep.unserialize(serializer, fp);
+    }
+
+    // The four methods below are DEPRECATED.
+    // Use serialize() and unserialize() for new code.
+    // -----------------------------------------------
+    template <typename OUTPUT>
+    bool write_metadata(OUTPUT *fp)       { return rep.write_metadata(fp); }
+
+    template <typename INPUT>
+    bool read_metadata(INPUT *fp)         { return rep.read_metadata(fp); }
+
+    template <typename OUTPUT>
+    bool write_nopointer_data(OUTPUT *fp) { return rep.write_nopointer_data(fp); }
+
+    template <typename INPUT>
+    bool read_nopointer_data(INPUT *fp)   { return rep.read_nopointer_data(fp); }
+
+
+private:
+    // The actual data
+    // ---------------
+    ht rep;
+};
+
+//  ----------------------------------------------------------------------
+//                   S P A R S E _ H A S H _ S E T
+//  ----------------------------------------------------------------------
+
+template <class Value,
+          class HashFcn  = spp_hash<Value>,
+          class EqualKey = std::equal_to<Value>,
+          class Alloc    = SPP_DEFAULT_ALLOCATOR<Value> >
+class sparse_hash_set
+{
+private:
+    // Apparently identity is not stl-standard, so we define our own
+    struct Identity
+    {
+        typedef const Value& result_type;
+        inline const Value& operator()(const Value& v) const { return v; }
+    };
+
+    struct SetKey
+    {
+        inline void operator()(Value* value, const Value& new_key) const
+        {
+            *value = new_key;
+        }
+    };
+
+    typedef sparse_hashtable<Value, Value, HashFcn, Identity, SetKey,
+                             EqualKey, Alloc> ht;
+
+public:
+    typedef typename ht::key_type              key_type;
+    typedef typename ht::value_type            value_type;
+    typedef typename ht::hasher                hasher;
+    typedef typename ht::key_equal             key_equal;
+    typedef Alloc                              allocator_type;
+
+    typedef typename ht::size_type             size_type;
+    typedef typename ht::difference_type       difference_type;
+    typedef typename ht::const_pointer         pointer;
+    typedef typename ht::const_pointer         const_pointer;
+    typedef typename ht::const_reference       reference;
+    typedef typename ht::const_reference       const_reference;
+
+    typedef typename ht::const_iterator        iterator;
+    typedef typename ht::const_iterator        const_iterator;
+    typedef typename ht::const_local_iterator  local_iterator;
+    typedef typename ht::const_local_iterator  const_local_iterator;
+
+
+    // Iterator functions -- recall all iterators are const
+    iterator       begin() const             { return rep.begin(); }
+    iterator       end() const               { return rep.end(); }
+    const_iterator cbegin() const            { return rep.cbegin(); }
+    const_iterator cend() const              { return rep.cend(); }
+
+    // These come from tr1's unordered_set. For us, a bucket has 0 or 1 elements.
+    local_iterator begin(size_type i) const  { return rep.begin(i); }
+    local_iterator end(size_type i) const    { return rep.end(i); }
+    local_iterator cbegin(size_type i) const { return rep.cbegin(i); }
+    local_iterator cend(size_type i) const   { return rep.cend(i); }
+
+
+    // Accessor functions
+    // ------------------
+    allocator_type get_allocator() const     { return rep.get_allocator(); }
+    hasher         hash_funct() const        { return rep.hash_funct(); }
+    hasher         hash_function() const     { return hash_funct(); }  // tr1 name
+    key_equal      key_eq() const            { return rep.key_eq(); }
+
+
+    // Constructors
+    // ------------
+    explicit sparse_hash_set(size_type n = 0,
+                             const hasher& hf = hasher(),
+                             const key_equal& eql = key_equal(),
+                             const allocator_type& alloc = allocator_type()) :
+        rep(n, hf, eql, Identity(), SetKey(), alloc)
+    {
+    }
+
+    explicit sparse_hash_set(const allocator_type& alloc) :
+        rep(0, hasher(), key_equal(), Identity(), SetKey(), alloc)
+    {
+    }
+
+    sparse_hash_set(size_type n, const allocator_type& alloc) :
+        rep(n, hasher(), key_equal(), Identity(), SetKey(), alloc)
+    {
+    }
+
+    sparse_hash_set(size_type n, const hasher& hf,
+                    const allocator_type& alloc) :
+        rep(n, hf, key_equal(), Identity(), SetKey(), alloc)
+    {
+    }
+
+    template <class InputIterator>
+    sparse_hash_set(InputIterator f, InputIterator l,
+                    size_type n = 0,
+                    const hasher& hf = hasher(),
+                    const key_equal& eql = key_equal(),
+                    const allocator_type& alloc = allocator_type())
+        : rep(n, hf, eql, Identity(), SetKey(), alloc)
+    {
+        rep.insert(f, l);
+    }
+
+    template <class InputIterator>
+    sparse_hash_set(InputIterator f, InputIterator l,
+                    size_type n, const allocator_type& alloc)
+        : rep(n, hasher(), key_equal(), Identity(), SetKey(), alloc)
+    {
+        rep.insert(f, l);
+    }
+
+    template <class InputIterator>
+    sparse_hash_set(InputIterator f, InputIterator l,
+                    size_type n, const hasher& hf, const allocator_type& alloc)
+        : rep(n, hf, key_equal(), Identity(), SetKey(), alloc)
+    {
+        rep.insert(f, l);
+    }
+
+    sparse_hash_set(const sparse_hash_set &o) :
+        rep(o.rep)
+    {}
+
+    sparse_hash_set(const sparse_hash_set &o,
+                    const allocator_type& alloc) :
+        rep(o.rep, alloc)
+    {}
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+    sparse_hash_set(sparse_hash_set &&o) :
+        rep(std::move(o.rep))
+    {}
+
+    sparse_hash_set(sparse_hash_set &&o,
+                    const allocator_type& alloc) :
+        rep(std::move(o.rep), alloc)
+    {}
+#endif
+
+#if !defined(SPP_NO_CXX11_HDR_INITIALIZER_LIST)
+    sparse_hash_set(std::initializer_list<value_type> init,
+                    size_type n = 0,
+                    const hasher& hf = hasher(),
+                    const key_equal& eql = key_equal(),
+                    const allocator_type& alloc = allocator_type()) :
+        rep(n, hf, eql, Identity(), SetKey(), alloc)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+    sparse_hash_set(std::initializer_list<value_type> init,
+                    size_type n, const allocator_type& alloc) :
+        rep(n, hasher(), key_equal(), Identity(), SetKey(), alloc)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+    sparse_hash_set(std::initializer_list<value_type> init,
+                    size_type n, const hasher& hf,
+                    const allocator_type& alloc) :
+        rep(n, hf, key_equal(), Identity(), SetKey(), alloc)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+    sparse_hash_set& operator=(std::initializer_list<value_type> init)
+    {
+        rep.clear();
+        rep.insert(init.begin(), init.end());
+        return *this;
+    }
+
+    void insert(std::initializer_list<value_type> init)
+    {
+        rep.insert(init.begin(), init.end());
+    }
+
+#endif
+
+    sparse_hash_set& operator=(const sparse_hash_set &o)
+    {
+        rep = o.rep;
+        return *this;
+    }
+
+    void clear()                        { rep.clear(); }
+    void swap(sparse_hash_set& hs)      { rep.swap(hs.rep); }
+
+
+    // Functions concerning size
+    // -------------------------
+    size_type size() const              { return rep.size(); }
+    size_type max_size() const          { return rep.max_size(); }
+    bool empty() const                  { return rep.empty(); }
+    size_type bucket_count() const      { return rep.bucket_count(); }
+    size_type max_bucket_count() const  { return rep.max_bucket_count(); }
+
+    size_type bucket_size(size_type i) const    { return rep.bucket_size(i); }
+    size_type bucket(const key_type& key) const { return rep.bucket(key); }
+
+    float     load_factor() const       { return size() * 1.0f / bucket_count(); }
+
+    float max_load_factor() const      { return rep.get_enlarge_factor(); }
+    void  max_load_factor(float grow)  { rep.set_enlarge_factor(grow); }
+
+    float min_load_factor() const      { return rep.get_shrink_factor(); }
+    void  min_load_factor(float shrink){ rep.set_shrink_factor(shrink); }
+
+    void set_resizing_parameters(float shrink, float grow)
+    {
+        rep.set_resizing_parameters(shrink, grow);
+    }
+
+    void resize(size_type cnt)        { rep.resize(cnt); }
+    void rehash(size_type cnt)        { resize(cnt); } // c++11 name
+    void reserve(size_type cnt)       { resize(cnt); } // c++11
+
+    // Lookup
+    // ------
+    iterator find(const key_type& key) const     { return rep.find(key); }
+    bool contains(const key_type& key) const     { return rep.find(key) != rep.end(); }
+
+    size_type count(const key_type& key) const   { return rep.count(key); }
+
+    std::pair<iterator, iterator>
+    equal_range(const key_type& key) const       { return rep.equal_range(key); }
+
+#if !defined(SPP_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class... Args>
+    std::pair<iterator, bool> emplace(Args&&... args)
+    {
+        return rep.emplace(std::forward<Args>(args)...);
+    }
+
+    template <class... Args>
+    iterator emplace_hint(const_iterator , Args&&... args)
+    {
+        return rep.emplace(std::forward<Args>(args)...).first;
+    }
+#endif
+
+    // Insert
+    // ------
+    std::pair<iterator, bool> insert(const value_type& obj)
+    {
+        std::pair<typename ht::iterator, bool> p = rep.insert(obj);
+        return std::pair<iterator, bool>(p.first, p.second);   // const to non-const
+    }
+
+#if !defined(SPP_NO_CXX11_RVALUE_REFERENCES)
+    template<class P>
+    std::pair<iterator, bool> insert(P&& obj)        { return rep.insert(std::forward<P>(obj)); }
+#endif
+
+    template <class InputIterator>
+    void insert(InputIterator f, InputIterator l)    { rep.insert(f, l); }
+
+    void insert(const_iterator f, const_iterator l)  { rep.insert(f, l); }
+
+    iterator insert(iterator /*unused*/, const value_type& obj) { return insert(obj).first; }
+
+    // Deleted key - do nothing - just to keep google test framework happy
+    // -------------------------------------------------------------------
+    void set_deleted_key(const key_type& key) { rep.set_deleted_key(key); }
+    void clear_deleted_key()                  { rep.clear_deleted_key();  }
+    key_type deleted_key() const              { return rep.deleted_key(); }
+
+    // Erase
+    // -----
+    size_type erase(const key_type& key)      { return rep.erase(key); }
+    iterator  erase(iterator it)              { return rep.erase(it); }
+    iterator  erase(iterator f, iterator l)   { return rep.erase(f, l); }
+
+    // Comparison
+    // ----------
+    bool operator==(const sparse_hash_set& hs) const { return rep == hs.rep; }
+    bool operator!=(const sparse_hash_set& hs) const { return rep != hs.rep; }
+
+
+    // I/O -- this is an add-on for writing metainformation to disk
+    //
+    // For maximum flexibility, this does not assume a particular
+    // file type (though it will probably be a FILE *).  We just pass
+    // the fp through to rep.
+
+    // If your keys and values are simple enough, you can pass this
+    // serializer to serialize()/unserialize().  "Simple enough" means
+    // value_type is a POD type that contains no pointers.  Note,
+    // however, we don't try to normalize endianness.
+    // ---------------------------------------------------------------
+    typedef typename ht::NopointerSerializer NopointerSerializer;
+
+    // serializer: a class providing operator()(OUTPUT*, const value_type&)
+    //    (writing value_type to OUTPUT).  You can specify a
+    //    NopointerSerializer object if appropriate (see above).
+    // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a
+    //    pointer to a class providing size_t Write(const void*, size_t),
+    //    which writes a buffer into a stream (which fp presumably
+    //    owns) and returns the number of bytes successfully written.
+    //    Note basic_ostream<not_char> is not currently supported.
+    // ---------------------------------------------------------------
+    template <typename ValueSerializer, typename OUTPUT>
+    bool serialize(ValueSerializer serializer, OUTPUT* fp)
+    {
+        return rep.serialize(serializer, fp);
+    }
+
+    // serializer: a functor providing operator()(INPUT*, value_type*)
+    //    (reading from INPUT and into value_type).  You can specify a
+    //    NopointerSerializer object if appropriate (see above).
+    // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a
+    //    pointer to a class providing size_t Read(void*, size_t),
+    //    which reads into a buffer from a stream (which fp presumably
+    //    owns) and returns the number of bytes successfully read.
+    //    Note basic_istream<not_char> is not currently supported.
+    // NOTE: Since value_type is const Key, ValueSerializer
+    // may need to do a const cast in order to fill in the key.
+    // NOTE: if Key is not a POD type, the serializer MUST use
+    // placement-new to initialize its value, rather than a normal
+    // equals-assignment or similar.  (The value_type* passed into
+    // the serializer points to garbage memory.)
+    // ---------------------------------------------------------------
+    template <typename ValueSerializer, typename INPUT>
+    bool unserialize(ValueSerializer serializer, INPUT* fp)
+    {
+        return rep.unserialize(serializer, fp);
+    }
+
+    // The four methods below are DEPRECATED.
+    // Use serialize() and unserialize() for new code.
+    // -----------------------------------------------
+    template <typename OUTPUT>
+    bool write_metadata(OUTPUT *fp)       { return rep.write_metadata(fp); }
+
+    template <typename INPUT>
+    bool read_metadata(INPUT *fp)         { return rep.read_metadata(fp); }
+
+    template <typename OUTPUT>
+    bool write_nopointer_data(OUTPUT *fp) { return rep.write_nopointer_data(fp); }
+
+    template <typename INPUT>
+    bool read_nopointer_data(INPUT *fp)   { return rep.read_nopointer_data(fp); }
+
+private:
+    // The actual data
+    // ---------------
+    ht rep;
+};
+
+} // spp_ namespace
+
+
+// We need a global swap for all our classes as well
+// -------------------------------------------------
+
+template <class T, class Alloc>
+inline void swap(spp_::sparsegroup<T,Alloc> &x, spp_::sparsegroup<T,Alloc> &y)
+{
+    x.swap(y);
+}
+
+template <class T, class Alloc>
+inline void swap(spp_::sparsetable<T,Alloc> &x, spp_::sparsetable<T,Alloc> &y)
+{
+    x.swap(y);
+}
+
+template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
+inline void swap(spp_::sparse_hashtable<V,K,HF,ExK,SetK,EqK,A> &x,
+                 spp_::sparse_hashtable<V,K,HF,ExK,SetK,EqK,A> &y)
+{
+    x.swap(y);
+}
+
+template <class Key, class T, class HashFcn, class EqualKey, class Alloc>
+inline void swap(spp_::sparse_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,
+                 spp_::sparse_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2)
+{
+    hm1.swap(hm2);
+}
+
+template <class Val, class HashFcn, class EqualKey, class Alloc>
+inline void swap(spp_::sparse_hash_set<Val, HashFcn, EqualKey, Alloc>& hs1,
+                 spp_::sparse_hash_set<Val, HashFcn, EqualKey, Alloc>& hs2)
+{
+    hs1.swap(hs2);
+}
+
+#endif // sparsepp_h_guard_
diff --git a/examples/others/sparsepp/spp_config.h b/examples/others/sparsepp/spp_config.h
new file mode 100644
index 00000000..46eeee5c
--- /dev/null
+++ b/examples/others/sparsepp/spp_config.h
@@ -0,0 +1,781 @@
+#if !defined(spp_config_h_guard)
+#define spp_config_h_guard
+
+// --------------------------------------------------
+// Sparsepp config macros
+// some can be overriden on the command line
+// --------------------------------------------------
+#ifndef SPP_NAMESPACE
+     #define SPP_NAMESPACE spp
+#endif
+
+#ifndef spp_
+    #define spp_ SPP_NAMESPACE
+#endif
+
+#ifndef SPP_DEFAULT_ALLOCATOR
+    #if (defined(SPP_USE_SPP_ALLOC) && SPP_USE_SPP_ALLOC) && defined(_MSC_VER)
+        // -----------------------------------------------------------------------------
+        // When building with the Microsoft compiler, we use a custom allocator because
+        // the default one fragments memory when reallocating. This is desirable only 
+        // when creating large sparsepp hash maps. If you create lots of small hash_maps,
+        // define the following before including spp.h:
+        //     #define SPP_DEFAULT_ALLOCATOR spp::libc_allocator
+        // -----------------------------------------------------------------------------
+        #define SPP_DEFAULT_ALLOCATOR spp_::spp_allocator
+        #define SPP_INCLUDE_SPP_ALLOC
+    #else
+        #define SPP_DEFAULT_ALLOCATOR spp_::libc_allocator
+    #endif
+#endif
+
+#ifndef SPP_GROUP_SIZE
+    // must be 32 or 64
+    #define SPP_GROUP_SIZE 32
+#endif
+
+#ifndef SPP_ALLOC_SZ
+    // must be power of 2 (0 = agressive alloc, 1 = smallest memory usage, 2 = good compromise)
+    #define SPP_ALLOC_SZ 0
+#endif
+
+#ifndef SPP_STORE_NUM_ITEMS
+    // 1 uses a little bit more memory, but faster!!
+    #define SPP_STORE_NUM_ITEMS 1 
+#endif
+
+
+// ---------------------------------------------------------------------------
+// Compiler detection code (SPP_ proprocessor macros) derived from Boost
+// libraries. Therefore Boost software licence reproduced below.
+// ---------------------------------------------------------------------------
+// Boost Software License - Version 1.0 - August 17th, 2003
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+//
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+//
+// 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+// ---------------------------------------------------------------------------
+
+// Boost like configuration
+// ------------------------
+#if defined __clang__
+
+    #if defined(i386)
+        #include <cpuid.h>
+        inline void spp_cpuid(int info[4], int InfoType) {
+            __cpuid_count(InfoType, 0, info[0], info[1], info[2], info[3]);
+        }
+    #endif
+
+    #define SPP_POPCNT   __builtin_popcount
+    #define SPP_POPCNT64 __builtin_popcountll
+
+    #define SPP_HAS_CSTDINT
+
+    #ifndef __has_extension
+        #define __has_extension __has_feature
+    #endif
+
+    #if !__has_feature(cxx_exceptions) && !defined(SPP_NO_EXCEPTIONS)
+        #define SPP_NO_EXCEPTIONS
+    #endif
+
+    #if !__has_feature(cxx_rtti) && !defined(SPP_NO_RTTI)
+      #define SPP_NO_RTTI
+    #endif
+
+    #if !__has_feature(cxx_rtti) && !defined(SPP_NO_TYPEID)
+        #define SPP_NO_TYPEID
+    #endif
+
+    #if defined(__int64) && !defined(__GNUC__)
+        #define SPP_HAS_MS_INT64
+    #endif
+
+    #define SPP_HAS_NRVO
+
+    // Branch prediction hints
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_expect)
+             #define SPP_LIKELY(x) __builtin_expect(x, 1)
+             #define SPP_UNLIKELY(x) __builtin_expect(x, 0)
+        #endif
+    #endif
+
+    // Clang supports "long long" in all compilation modes.
+    #define SPP_HAS_LONG_LONG
+
+    #if !__has_feature(cxx_constexpr)
+        #define SPP_NO_CXX11_CONSTEXPR
+    #endif
+
+    #if !__has_feature(cxx_decltype)
+        #define SPP_NO_CXX11_DECLTYPE
+    #endif
+
+    #if !__has_feature(cxx_decltype_incomplete_return_types)
+        #define SPP_NO_CXX11_DECLTYPE_N3276
+    #endif
+
+    #if !__has_feature(cxx_defaulted_functions)
+        #define SPP_NO_CXX11_DEFAULTED_FUNCTIONS
+    #endif
+
+    #if !__has_feature(cxx_deleted_functions)
+        #define SPP_NO_CXX11_DELETED_FUNCTIONS
+    #endif
+
+    #if !__has_feature(cxx_explicit_conversions)
+        #define SPP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+    #endif
+
+    #if !__has_feature(cxx_default_function_template_args)
+        #define SPP_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+    #endif
+
+    #if !__has_feature(cxx_generalized_initializers)
+        #define SPP_NO_CXX11_HDR_INITIALIZER_LIST
+    #endif
+
+    #if !__has_feature(cxx_lambdas)
+        #define SPP_NO_CXX11_LAMBDAS
+    #endif
+
+    #if !__has_feature(cxx_local_type_template_args)
+        #define SPP_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+    #endif
+
+    #if !__has_feature(cxx_raw_string_literals)
+        #define SPP_NO_CXX11_RAW_LITERALS
+    #endif
+
+    #if !__has_feature(cxx_reference_qualified_functions)
+        #define SPP_NO_CXX11_REF_QUALIFIERS
+    #endif
+
+    #if !__has_feature(cxx_generalized_initializers)
+        #define SPP_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    #endif
+
+    #if !__has_feature(cxx_rvalue_references)
+        #define SPP_NO_CXX11_RVALUE_REFERENCES
+    #endif
+
+    #if !__has_feature(cxx_static_assert)
+        #define SPP_NO_CXX11_STATIC_ASSERT
+    #endif
+
+    #if !__has_feature(cxx_alias_templates)
+        #define SPP_NO_CXX11_TEMPLATE_ALIASES
+    #endif
+
+    #if !__has_feature(cxx_variadic_templates)
+        #define SPP_NO_CXX11_VARIADIC_TEMPLATES
+    #endif
+
+    #if !__has_feature(cxx_user_literals)
+        #define SPP_NO_CXX11_USER_DEFINED_LITERALS
+    #endif
+
+    #if !__has_feature(cxx_alignas)
+        #define SPP_NO_CXX11_ALIGNAS
+    #endif
+
+    #if !__has_feature(cxx_trailing_return)
+        #define SPP_NO_CXX11_TRAILING_RESULT_TYPES
+    #endif
+
+    #if !__has_feature(cxx_inline_namespaces)
+        #define SPP_NO_CXX11_INLINE_NAMESPACES
+    #endif
+
+    #if !__has_feature(cxx_override_control)
+        #define SPP_NO_CXX11_FINAL
+    #endif
+
+    #if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__))
+        #define SPP_NO_CXX14_BINARY_LITERALS
+    #endif
+
+    #if !__has_feature(__cxx_decltype_auto__)
+        #define SPP_NO_CXX14_DECLTYPE_AUTO
+    #endif
+
+    #if !__has_feature(__cxx_init_captures__)
+        #define SPP_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+    #endif
+
+    #if !__has_feature(__cxx_generic_lambdas__)
+        #define SPP_NO_CXX14_GENERIC_LAMBDAS
+    #endif
+
+
+    #if !__has_feature(__cxx_generic_lambdas__) || !__has_feature(__cxx_relaxed_constexpr__)
+        #define SPP_NO_CXX14_CONSTEXPR
+    #endif
+
+    #if !__has_feature(__cxx_return_type_deduction__)
+        #define SPP_NO_CXX14_RETURN_TYPE_DEDUCTION
+    #endif
+
+    #if !__has_feature(__cxx_variable_templates__)
+        #define SPP_NO_CXX14_VARIABLE_TEMPLATES
+    #endif
+
+    #if __cplusplus < 201400
+        #define SPP_NO_CXX14_DIGIT_SEPARATORS
+    #endif
+
+    #if defined(__has_builtin) && __has_builtin(__builtin_unreachable)
+      #define SPP_UNREACHABLE_RETURN(x) __builtin_unreachable();
+    #endif
+
+    #define SPP_ATTRIBUTE_UNUSED __attribute__((__unused__))
+
+    #ifndef SPP_COMPILER
+        #define SPP_COMPILER "Clang version " __clang_version__
+    #endif
+
+    #define SPP_CLANG 1
+
+
+#elif defined __GNUC__
+
+    #define SPP_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+    //  definition to expand macro then apply to pragma message
+    // #define VALUE_TO_STRING(x) #x
+    // #define VALUE(x) VALUE_TO_STRING(x)
+    // #define VAR_NAME_VALUE(var) #var "="  VALUE(var)
+    // #pragma message(VAR_NAME_VALUE(SPP_GCC_VERSION))
+
+    #if defined(i386)
+        #include <cpuid.h>
+        inline void spp_cpuid(int info[4], int InfoType) {
+            __cpuid_count(InfoType, 0, info[0], info[1], info[2], info[3]);
+        }
+    #endif
+
+    // __POPCNT__ defined when the compiled with popcount support
+    // (-mpopcnt compiler option is given for example)
+    #ifdef __POPCNT__
+        // slower unless compiled iwith -mpopcnt
+        #define SPP_POPCNT   __builtin_popcount
+        #define SPP_POPCNT64 __builtin_popcountll
+    #endif
+
+    #if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
+        #define SPP_GCC_CXX11
+    #endif
+
+    #if __GNUC__ == 3
+        #if defined (__PATHSCALE__)
+             #define SPP_NO_TWO_PHASE_NAME_LOOKUP
+             #define SPP_NO_IS_ABSTRACT
+        #endif
+
+        #if __GNUC_MINOR__ < 4
+             #define SPP_NO_IS_ABSTRACT
+        #endif
+
+        #define SPP_NO_CXX11_EXTERN_TEMPLATE
+    #endif
+
+    #if __GNUC__ < 4
+    //
+    // All problems to gcc-3.x and earlier here:
+    //
+    #define SPP_NO_TWO_PHASE_NAME_LOOKUP
+        #ifdef __OPEN64__
+            #define SPP_NO_IS_ABSTRACT
+        #endif
+    #endif
+
+    // GCC prior to 3.4 had     #pragma once too but it didn't work well with filesystem links
+    #if SPP_GCC_VERSION >= 30400
+        #define SPP_HAS_PRAGMA_ONCE
+    #endif
+
+    #if SPP_GCC_VERSION < 40400
+        // Previous versions of GCC did not completely implement value-initialization:
+        // GCC Bug 30111, "Value-initialization of POD base class doesn't initialize
+        // members", reported by Jonathan Wakely in 2006,
+        // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111 (fixed for GCC 4.4)
+        // GCC Bug 33916, "Default constructor fails to initialize array members",
+        // reported by Michael Elizabeth Chastain in 2007,
+        // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916 (fixed for GCC 4.2.4)
+        // See also: http://www.boost.org/libs/utility/value_init.htm    #compiler_issues
+        #define SPP_NO_COMPLETE_VALUE_INITIALIZATION
+    #endif
+
+    #if !defined(__EXCEPTIONS) && !defined(SPP_NO_EXCEPTIONS)
+        #define SPP_NO_EXCEPTIONS
+    #endif
+
+    //
+    // Threading support: Turn this on unconditionally here (except for
+    // those platforms where we can know for sure). It will get turned off again
+    // later if no threading API is detected.
+    //
+    #if !defined(__MINGW32__) && !defined(linux) && !defined(__linux) && !defined(__linux__)
+        #define SPP_HAS_THREADS
+    #endif
+
+    //
+    // gcc has "long long"
+    // Except on Darwin with standard compliance enabled (-pedantic)
+    // Apple gcc helpfully defines this macro we can query
+    //
+    #if !defined(__DARWIN_NO_LONG_LONG)
+        #define SPP_HAS_LONG_LONG
+    #endif
+
+    //
+    // gcc implements the named return value optimization since version 3.1
+    //
+    #define SPP_HAS_NRVO
+
+    // Branch prediction hints
+    #define SPP_LIKELY(x) __builtin_expect(x, 1)
+    #define SPP_UNLIKELY(x) __builtin_expect(x, 0)
+
+    //
+    // Dynamic shared object (DSO) and dynamic-link library (DLL) support
+    //
+    #if __GNUC__ >= 4
+       #if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(__CYGWIN__)
+            // All Win32 development environments, including 64-bit Windows and MinGW, define
+            // _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
+            // so does not define _WIN32 or its variants.
+            #define SPP_HAS_DECLSPEC
+            #define SPP_SYMBOL_EXPORT __attribute__((__dllexport__))
+            #define SPP_SYMBOL_IMPORT __attribute__((__dllimport__))
+       #else
+            #define SPP_SYMBOL_EXPORT __attribute__((__visibility__("default")))
+            #define SPP_SYMBOL_IMPORT
+       #endif
+
+       #define SPP_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
+    #else
+       // config/platform/win32.hpp will define SPP_SYMBOL_EXPORT, etc., unless already defined
+       #define SPP_SYMBOL_EXPORT
+    #endif
+
+    //
+    // RTTI and typeinfo detection is possible post gcc-4.3:
+    //
+    #if SPP_GCC_VERSION > 40300
+        #ifndef __GXX_RTTI
+            #ifndef SPP_NO_TYPEID
+                #define SPP_NO_TYPEID
+            #endif
+            #ifndef SPP_NO_RTTI
+                #define SPP_NO_RTTI
+            #endif
+        #endif
+    #endif
+
+    //
+    // Recent GCC versions have __int128 when in 64-bit mode.
+    //
+    // We disable this if the compiler is really nvcc with C++03 as it
+    // doesn't actually support __int128 as of CUDA_VERSION=7500
+    // even though it defines __SIZEOF_INT128__.
+    // See https://svn.boost.org/trac/boost/ticket/8048
+    //     https://svn.boost.org/trac/boost/ticket/11852
+    // Only re-enable this for nvcc if you're absolutely sure
+    // of the circumstances under which it's supported:
+    //
+    #if defined(__CUDACC__)
+        #if defined(SPP_GCC_CXX11)
+            #define SPP_NVCC_CXX11
+        #else
+            #define SPP_NVCC_CXX03
+        #endif
+    #endif
+
+    #if defined(__SIZEOF_INT128__) && !defined(SPP_NVCC_CXX03)
+        #define SPP_HAS_INT128
+    #endif
+    //
+    // Recent GCC versions have a __float128 native type, we need to
+    // include a std lib header to detect this - not ideal, but we'll
+    // be including <cstddef> later anyway when we select the std lib.
+    //
+    // Nevertheless, as of CUDA 7.5, using __float128 with the host
+    // compiler in pre-C++11 mode is still not supported.
+    // See https://svn.boost.org/trac/boost/ticket/11852
+    //
+    #ifdef __cplusplus
+        #include <cstddef>
+    #else
+        #include <stddef.h>
+    #endif
+
+    #if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) && !defined(SPP_NVCC_CXX03)
+         #define SPP_HAS_FLOAT128
+    #endif
+
+    // C++0x features in 4.3.n and later
+    //
+    #if (SPP_GCC_VERSION >= 40300) && defined(SPP_GCC_CXX11)
+       // C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
+       // passed on the command line, which in turn defines
+       // __GXX_EXPERIMENTAL_CXX0X__.
+       #define SPP_HAS_DECLTYPE
+       #define SPP_HAS_RVALUE_REFS
+       #define SPP_HAS_STATIC_ASSERT
+       #define SPP_HAS_VARIADIC_TMPL
+       #define SPP_HAS_CSTDINT
+    #else
+       #define SPP_NO_CXX11_DECLTYPE
+       #define SPP_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+       #define SPP_NO_CXX11_RVALUE_REFERENCES
+       #define SPP_NO_CXX11_STATIC_ASSERT
+    #endif
+
+    // C++0x features in 4.4.n and later
+    //
+    #if (SPP_GCC_VERSION < 40400) || !defined(SPP_GCC_CXX11)
+       #define SPP_NO_CXX11_AUTO_DECLARATIONS
+       #define SPP_NO_CXX11_AUTO_MULTIDECLARATIONS
+       #define SPP_NO_CXX11_CHAR16_T
+       #define SPP_NO_CXX11_CHAR32_T
+       #define SPP_NO_CXX11_HDR_INITIALIZER_LIST
+       #define SPP_NO_CXX11_DEFAULTED_FUNCTIONS
+       #define SPP_NO_CXX11_DELETED_FUNCTIONS
+       #define SPP_NO_CXX11_TRAILING_RESULT_TYPES
+       #define SPP_NO_CXX11_INLINE_NAMESPACES
+       #define SPP_NO_CXX11_VARIADIC_TEMPLATES
+    #endif
+
+    #if SPP_GCC_VERSION < 40500
+       #define SPP_NO_SFINAE_EXPR
+    #endif
+
+    // GCC 4.5 forbids declaration of defaulted functions in private or protected sections
+    #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ == 5) || !defined(SPP_GCC_CXX11)
+       #define SPP_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+    #endif
+
+    // C++0x features in 4.5.0 and later
+    //
+    #if (SPP_GCC_VERSION < 40500) || !defined(SPP_GCC_CXX11)
+       #define SPP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+       #define SPP_NO_CXX11_LAMBDAS
+       #define SPP_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+       #define SPP_NO_CXX11_RAW_LITERALS
+    #endif
+
+    // C++0x features in 4.6.n and later
+    //
+    #if (SPP_GCC_VERSION < 40600) || !defined(SPP_GCC_CXX11)
+        #define SPP_NO_CXX11_CONSTEXPR
+        #define SPP_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    #endif
+
+    // C++0x features in 4.7.n and later
+    //
+    #if (SPP_GCC_VERSION < 40700) || !defined(SPP_GCC_CXX11)
+        #define SPP_NO_CXX11_FINAL
+        #define SPP_NO_CXX11_TEMPLATE_ALIASES
+        #define SPP_NO_CXX11_USER_DEFINED_LITERALS
+        #define SPP_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+    #endif
+
+    // C++0x features in 4.8.n and later
+    //
+    #if (SPP_GCC_VERSION < 40800) || !defined(SPP_GCC_CXX11)
+        #define SPP_NO_CXX11_ALIGNAS
+    #endif
+
+    // C++0x features in 4.8.1 and later
+    //
+    #if (SPP_GCC_VERSION < 40801) || !defined(SPP_GCC_CXX11)
+        #define SPP_NO_CXX11_DECLTYPE_N3276
+        #define SPP_NO_CXX11_REF_QUALIFIERS
+        #define SPP_NO_CXX14_BINARY_LITERALS
+    #endif
+
+    // C++14 features in 4.9.0 and later
+    //
+    #if (SPP_GCC_VERSION < 40900) || (__cplusplus < 201300)
+        #define SPP_NO_CXX14_RETURN_TYPE_DEDUCTION
+        #define SPP_NO_CXX14_GENERIC_LAMBDAS
+        #define SPP_NO_CXX14_DIGIT_SEPARATORS
+        #define SPP_NO_CXX14_DECLTYPE_AUTO
+        #if !((SPP_GCC_VERSION >= 40801) && (SPP_GCC_VERSION < 40900) && defined(SPP_GCC_CXX11))
+            #define SPP_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+        #endif
+    #endif
+
+
+    // C++ 14:
+    #if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+        #define SPP_NO_CXX14_CONSTEXPR
+    #endif
+    #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+        #define SPP_NO_CXX14_VARIABLE_TEMPLATES
+    #endif
+
+    //
+    // Unused attribute:
+    #if __GNUC__ >= 4
+        #define SPP_ATTRIBUTE_UNUSED __attribute__((__unused__))
+    #endif
+    //
+    // __builtin_unreachable:
+    #if SPP_GCC_VERSION >= 40800
+        #define SPP_UNREACHABLE_RETURN(x) __builtin_unreachable();
+    #endif
+
+    #ifndef SPP_COMPILER
+        #define SPP_COMPILER "GNU C++ version " __VERSION__
+    #endif
+
+    // ConceptGCC compiler:
+    //   http://www.generic-programming.org/software/ConceptGCC/
+    #ifdef __GXX_CONCEPTS__
+        #define SPP_HAS_CONCEPTS
+        #define SPP_COMPILER "ConceptGCC version " __VERSION__
+    #endif
+
+#elif defined _MSC_VER
+
+    #include <intrin.h>                     // for __popcnt()
+
+    #define SPP_POPCNT_CHECK  // slower when defined, but we have to check!
+    #define spp_cpuid(info, x)    __cpuid(info, x)
+
+    #define SPP_POPCNT __popcnt
+    #if (SPP_GROUP_SIZE == 64 && INTPTR_MAX == INT64_MAX)
+        #define SPP_POPCNT64 __popcnt64
+    #endif
+
+    // Attempt to suppress VC6 warnings about the length of decorated names (obsolete):
+    #pragma warning( disable : 4503 ) // warning: decorated name length exceeded
+
+    #define SPP_HAS_PRAGMA_ONCE
+    #define SPP_HAS_CSTDINT
+
+   //
+    // versions check:
+    // we don't support Visual C++ prior to version 7.1:
+    #if _MSC_VER < 1310
+        #error "Antique compiler not supported"
+    #endif
+
+    #if _MSC_FULL_VER < 180020827
+        #define SPP_NO_FENV_H
+    #endif
+
+    #if _MSC_VER < 1400
+        // although a conforming signature for swprint exists in VC7.1
+        // it appears not to actually work:
+        #define SPP_NO_SWPRINTF
+
+        // Our extern template tests also fail for this compiler:
+        #define SPP_NO_CXX11_EXTERN_TEMPLATE
+
+        // Variadic macros do not exist for VC7.1 and lower
+        #define SPP_NO_CXX11_VARIADIC_MACROS
+    #endif
+
+    #if _MSC_VER < 1500  // 140X == VC++ 8.0
+        #undef SPP_HAS_CSTDINT
+        #define SPP_NO_MEMBER_TEMPLATE_FRIENDS
+    #endif
+
+    #if _MSC_VER < 1600  // 150X == VC++ 9.0
+        // A bug in VC9:
+        #define SPP_NO_ADL_BARRIER
+    #endif
+
+
+    // MSVC (including the latest checked version) has not yet completely
+    // implemented value-initialization, as is reported:
+    // "VC++ does not value-initialize members of derived classes without
+    // user-declared constructor", reported in 2009 by Sylvester Hesp:
+    // https:    //connect.microsoft.com/VisualStudio/feedback/details/484295
+    // "Presence of copy constructor breaks member class initialization",
+    // reported in 2009 by Alex Vakulenko:
+    // https:    //connect.microsoft.com/VisualStudio/feedback/details/499606
+    // "Value-initialization in new-expression", reported in 2005 by
+    // Pavel Kuznetsov (MetaCommunications Engineering):
+    // https:    //connect.microsoft.com/VisualStudio/feedback/details/100744
+    // See also: http:    //www.boost.org/libs/utility/value_init.htm    #compiler_issues
+    // (Niels Dekker, LKEB, May 2010)
+    #define SPP_NO_COMPLETE_VALUE_INITIALIZATION
+
+    #ifndef _NATIVE_WCHAR_T_DEFINED
+        #define SPP_NO_INTRINSIC_WCHAR_T
+    #endif
+
+    //
+    // check for exception handling support:
+    #if !defined(_CPPUNWIND) && !defined(SPP_NO_EXCEPTIONS)
+        #define SPP_NO_EXCEPTIONS
+    #endif
+
+    //
+    // __int64 support:
+    //
+    #define SPP_HAS_MS_INT64
+    #if defined(_MSC_EXTENSIONS) || (_MSC_VER >= 1400)
+        #define SPP_HAS_LONG_LONG
+    #else
+        #define SPP_NO_LONG_LONG
+    #endif
+
+    #if (_MSC_VER >= 1400) && !defined(_DEBUG)
+        #define SPP_HAS_NRVO
+    #endif
+
+    #if _MSC_VER >= 1500  // 150X == VC++ 9.0
+        #define SPP_HAS_PRAGMA_DETECT_MISMATCH
+    #endif
+
+    //
+    // disable Win32 API's if compiler extensions are
+    // turned off:
+    //
+    #if !defined(_MSC_EXTENSIONS) && !defined(SPP_DISABLE_WIN32)
+        #define SPP_DISABLE_WIN32
+    #endif
+
+    #if !defined(_CPPRTTI) && !defined(SPP_NO_RTTI)
+        #define SPP_NO_RTTI
+    #endif
+
+    //
+    // TR1 features:
+    //
+    #if _MSC_VER >= 1700
+        //      #define SPP_HAS_TR1_HASH	// don't know if this is true yet.
+        //      #define SPP_HAS_TR1_TYPE_TRAITS	// don't know if this is true yet.
+        #define SPP_HAS_TR1_UNORDERED_MAP
+        #define SPP_HAS_TR1_UNORDERED_SET
+    #endif
+
+    //
+    // C++0x features
+    //
+    //   See above for SPP_NO_LONG_LONG
+
+    // C++ features supported by VC++ 10 (aka 2010)
+    //
+    #if _MSC_VER < 1600
+        #define SPP_NO_CXX11_AUTO_DECLARATIONS
+        #define SPP_NO_CXX11_AUTO_MULTIDECLARATIONS
+        #define SPP_NO_CXX11_LAMBDAS
+        #define SPP_NO_CXX11_RVALUE_REFERENCES
+        #define SPP_NO_CXX11_STATIC_ASSERT
+        #define SPP_NO_CXX11_DECLTYPE
+    #endif // _MSC_VER < 1600
+
+    #if _MSC_VER >= 1600
+        #define SPP_HAS_STDINT_H
+    #endif
+
+    // C++11 features supported by VC++ 11 (aka 2012)
+    //
+    #if _MSC_VER < 1700
+        #define SPP_NO_CXX11_FINAL
+    #endif // _MSC_VER < 1700
+
+    // C++11 features supported by VC++ 12 (aka 2013).
+    //
+    #if _MSC_FULL_VER < 180020827
+        #define SPP_NO_CXX11_DEFAULTED_FUNCTIONS
+        #define SPP_NO_CXX11_DELETED_FUNCTIONS
+        #define SPP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+        #define SPP_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+        #define SPP_NO_CXX11_RAW_LITERALS
+        #define SPP_NO_CXX11_TEMPLATE_ALIASES
+        #define SPP_NO_CXX11_TRAILING_RESULT_TYPES
+        #define SPP_NO_CXX11_VARIADIC_TEMPLATES
+        #define SPP_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+        #define SPP_NO_CXX11_DECLTYPE_N3276
+    #endif
+
+    // C++11 features supported by VC++ 14 (aka 2014) CTP1
+    #if (_MSC_FULL_VER < 190021730)
+        #define SPP_NO_CXX11_REF_QUALIFIERS
+        #define SPP_NO_CXX11_USER_DEFINED_LITERALS
+        #define SPP_NO_CXX11_ALIGNAS
+        #define SPP_NO_CXX11_INLINE_NAMESPACES
+        #define SPP_NO_CXX14_DECLTYPE_AUTO
+        #define SPP_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+        #define SPP_NO_CXX14_RETURN_TYPE_DEDUCTION
+        #define SPP_NO_CXX11_HDR_INITIALIZER_LIST
+    #endif
+
+    // C++11 features not supported by any versions
+    #define SPP_NO_CXX11_CHAR16_T
+    #define SPP_NO_CXX11_CHAR32_T
+    #define SPP_NO_CXX11_CONSTEXPR
+    #define SPP_NO_SFINAE_EXPR
+    #define SPP_NO_TWO_PHASE_NAME_LOOKUP
+
+    // C++ 14:
+    #if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+        #define SPP_NO_CXX14_BINARY_LITERALS
+    #endif
+
+    #if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+        #define SPP_NO_CXX14_CONSTEXPR
+    #endif
+
+    #if (__cplusplus < 201304) // There's no SD6 check for this....
+        #define SPP_NO_CXX14_DIGIT_SEPARATORS
+    #endif
+
+    #if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+        #define SPP_NO_CXX14_GENERIC_LAMBDAS
+    #endif
+
+    #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+         #define SPP_NO_CXX14_VARIABLE_TEMPLATES
+    #endif
+
+#endif
+
+// from boost/config/suffix.hpp
+// ----------------------------
+#ifndef SPP_ATTRIBUTE_UNUSED
+    #define SPP_ATTRIBUTE_UNUSED
+#endif
+
+/*
+  Try to persuade compilers to inline. 
+*/
+#ifndef SPP_FORCEINLINE
+    #if defined(__GNUC__)
+        #define SPP_FORCEINLINE __inline __attribute__ ((always_inline))
+    #elif defined(_MSC_VER)
+        #define SPP_FORCEINLINE __forceinline
+    #else
+        #define SPP_FORCEINLINE inline
+    #endif
+#endif
+
+
+#endif // spp_config_h_guard
diff --git a/examples/others/sparsepp/spp_dlalloc.h b/examples/others/sparsepp/spp_dlalloc.h
new file mode 100644
index 00000000..f88aab7c
--- /dev/null
+++ b/examples/others/sparsepp/spp_dlalloc.h
@@ -0,0 +1,4044 @@
+#ifndef spp_dlalloc__h_
+#define spp_dlalloc__h_
+
+/* This is a C++ allocator created from Doug Lea's dlmalloc
+   (Version 2.8.6 Wed Aug 29 06:57:58 2012)
+   see: http://g.oswego.edu/dl/html/malloc.html
+*/
+
+#include "spp_utils.h"
+#include "spp_smartptr.h"
+
+
+#ifndef SPP_FORCEINLINE
+    #if defined(__GNUC__)
+        #define SPP_FORCEINLINE __inline __attribute__ ((always_inline))
+    #elif defined(_MSC_VER)
+        #define SPP_FORCEINLINE __forceinline
+    #else
+        #define SPP_FORCEINLINE inline
+    #endif
+#endif
+
+
+#ifndef SPP_IMPL
+    #define SPP_IMPL SPP_FORCEINLINE
+#endif
+
+#ifndef SPP_API
+    #define SPP_API  static
+#endif
+
+
+namespace spp
+{
+    // ---------------------- allocator internal API -----------------------
+    typedef void* mspace;
+
+    /*
+      create_mspace creates and returns a new independent space with the
+      given initial capacity, or, if 0, the default granularity size.  It
+      returns null if there is no system memory available to create the
+      space.  If argument locked is non-zero, the space uses a separate
+      lock to control access. The capacity of the space will grow
+      dynamically as needed to service mspace_malloc requests.  You can
+      control the sizes of incremental increases of this space by
+      compiling with a different SPP_DEFAULT_GRANULARITY or dynamically
+      setting with mallopt(M_GRANULARITY, value).
+    */
+    SPP_API mspace create_mspace(size_t capacity, int locked);
+    SPP_API size_t destroy_mspace(mspace msp);
+    SPP_API void*  mspace_malloc(mspace msp, size_t bytes);
+    SPP_API void   mspace_free(mspace msp, void* mem);
+    SPP_API void*  mspace_realloc(mspace msp, void* mem, size_t newsize);
+
+#if 0
+    SPP_API mspace create_mspace_with_base(void* base, size_t capacity, int locked);
+    SPP_API int    mspace_track_large_chunks(mspace msp, int enable);
+    SPP_API void*  mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
+    SPP_API void*  mspace_memalign(mspace msp, size_t alignment, size_t bytes);
+    SPP_API void** mspace_independent_calloc(mspace msp, size_t n_elements,
+                                             size_t elem_size, void* chunks[]);
+    SPP_API void** mspace_independent_comalloc(mspace msp, size_t n_elements,
+                                               size_t sizes[], void* chunks[]);
+    SPP_API size_t mspace_footprint(mspace msp);
+    SPP_API size_t mspace_max_footprint(mspace msp);
+    SPP_API size_t mspace_usable_size(const void* mem);
+    SPP_API int    mspace_trim(mspace msp, size_t pad);
+    SPP_API int    mspace_mallopt(int, int);
+#endif
+
+    // -----------------------------------------------------------
+    // -----------------------------------------------------------
+    struct MSpace : public spp_rc
+    {
+        MSpace() :
+            _sp(create_mspace(0, 0))
+        {}
+
+        ~MSpace()
+        {
+            destroy_mspace(_sp);
+        }
+
+        mspace _sp;
+    };
+
+    // -----------------------------------------------------------
+    // -----------------------------------------------------------
+    template<class T>
+    class spp_allocator
+    {
+    public:
+        typedef T         value_type;
+        typedef T*        pointer;
+        typedef ptrdiff_t difference_type;
+        typedef const T*  const_pointer;
+        typedef size_t    size_type;
+
+        MSpace *getSpace() const { return _space.get(); }
+
+        spp_allocator() : _space(new MSpace) {}
+        
+        template<class U>
+        spp_allocator(const spp_allocator<U> &o) : _space(o.getSpace()) {}
+
+        template<class U>
+        spp_allocator& operator=(const spp_allocator<U> &o) 
+        {
+            if (&o != this)
+                _space = o.getSpace();
+            return *this;
+        }
+
+        void swap(spp_allocator &o)
+        {
+            std::swap(_space, o._space);
+        }
+
+        pointer allocate(size_t n, const_pointer  /* unused */ = 0)
+        {
+            pointer res = static_cast<pointer>(mspace_malloc(_space->_sp, n * sizeof(T)));
+            if (!res)
+                throw std::bad_alloc();
+            return res;
+        }
+
+        void deallocate(pointer p, size_t /* unused */)
+        {
+            mspace_free(_space->_sp, p);
+        }
+
+        pointer reallocate(pointer p, size_t new_size)
+        {
+            pointer res = static_cast<pointer>(mspace_realloc(_space->_sp, p, new_size * sizeof(T)));
+            if (!res)
+                throw std::bad_alloc();
+            return res;
+        }
+
+        pointer reallocate(pointer p, size_type /* old_size */, size_t new_size)
+        {
+            return reallocate(p, new_size);
+        }
+        
+        size_type max_size() const
+        {
+            return static_cast<size_type>(-1) / sizeof(value_type);
+        }
+
+        void construct(pointer p, const value_type& val)
+        {
+            new (p) value_type(val);
+        }
+
+        void destroy(pointer p) { p->~value_type(); }
+
+        template<class U>
+        struct rebind
+        {
+            // rebind to libc_allocator because we want to use malloc_inspect_all in destructive_iterator 
+            // to reduce peak memory usage (we don't want <group_items> mixed with value_type when 
+            // we traverse the allocated memory).
+            typedef spp::spp_allocator<U> other;
+        };
+
+        mspace space() const { return _space->_sp; }
+
+        // check if we can clear the whole allocator memory at once => works only if the allocator 
+        // is not be shared. If can_clear() returns true, we expect that the next allocator call
+        // will be clear() - not allocate() or deallocate()
+        bool can_clear()
+        {
+            assert(!_space_to_clear);
+            _space_to_clear.reset();
+            _space_to_clear.swap(_space);
+            if (_space_to_clear->count() == 1)
+                return true;
+            else
+                _space_to_clear.swap(_space);
+            return false;
+        }
+
+        void clear()
+        {
+            assert(!_space && !!_space_to_clear);
+            _space_to_clear.reset();
+            _space = new MSpace;
+        }
+        
+    private:
+        spp_sptr<MSpace> _space;
+        spp_sptr<MSpace> _space_to_clear;
+    };
+}
+
+
+// allocators are "equal" whenever memory allocated with one can be deallocated with the other
+template<class T>
+inline bool operator==(const spp_::spp_allocator<T> &a, const spp_::spp_allocator<T> &b)
+{
+    return a.space() == b.space();
+}
+
+template<class T>
+inline bool operator!=(const spp_::spp_allocator<T> &a, const spp_::spp_allocator<T> &b)
+{
+    return !(a == b);
+}
+
+namespace std
+{
+    template <class T>
+    inline void swap(spp_::spp_allocator<T> &a, spp_::spp_allocator<T> &b)
+    {
+        a.swap(b);
+    }
+}
+
+#if !defined(SPP_EXCLUDE_IMPLEMENTATION)
+
+#ifndef WIN32
+    #ifdef _WIN32
+        #define WIN32 1
+    #endif
+    #ifdef _WIN32_WCE
+        #define SPP_LACKS_FCNTL_H
+        #define WIN32 1
+    #endif
+#endif
+
+#ifdef WIN32
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+    #include <tchar.h>
+    #define SPP_HAVE_MMAP 1
+    #define SPP_LACKS_UNISTD_H
+    #define SPP_LACKS_SYS_PARAM_H
+    #define SPP_LACKS_SYS_MMAN_H
+    #define SPP_LACKS_STRING_H
+    #define SPP_LACKS_STRINGS_H
+    #define SPP_LACKS_SYS_TYPES_H
+    #define SPP_LACKS_ERRNO_H
+    #define SPP_LACKS_SCHED_H
+    #ifndef SPP_MALLOC_FAILURE_ACTION
+        #define SPP_MALLOC_FAILURE_ACTION
+    #endif
+    #ifndef SPP_MMAP_CLEARS
+        #ifdef _WIN32_WCE /* WINCE reportedly does not clear */
+            #define SPP_MMAP_CLEARS 0
+        #else
+            #define SPP_MMAP_CLEARS 1
+        #endif
+    #endif
+#endif
+
+#if defined(DARWIN) || defined(_DARWIN)
+    #define SPP_HAVE_MMAP 1
+    /* OSX allocators provide 16 byte alignment */
+    #ifndef SPP_MALLOC_ALIGNMENT
+        #define SPP_MALLOC_ALIGNMENT ((size_t)16U)
+    #endif
+#endif
+
+#ifndef SPP_LACKS_SYS_TYPES_H
+    #include <sys/types.h>  /* For size_t */
+#endif
+
+#ifndef SPP_MALLOC_ALIGNMENT
+    #define SPP_MALLOC_ALIGNMENT ((size_t)(2 * sizeof(void *)))
+#endif
+
+/* ------------------- size_t and alignment properties -------------------- */
+static const size_t spp_max_size_t = ~(size_t)0;
+static const size_t spp_size_t_bitsize = sizeof(size_t) << 3;
+static const size_t spp_half_max_size_t = spp_max_size_t / 2U;
+static const size_t spp_chunk_align_mask = SPP_MALLOC_ALIGNMENT - 1;
+
+#if defined(SPP_DEBUG) || !defined(NDEBUG)
+static bool spp_is_aligned(void *p) { return ((size_t)p & spp_chunk_align_mask) == 0; }
+#endif
+
+// the number of bytes to offset an address to align it
+static size_t align_offset(void *p)
+{
+    return (((size_t)p & spp_chunk_align_mask) == 0) ? 0 :
+           ((SPP_MALLOC_ALIGNMENT - ((size_t)p & spp_chunk_align_mask)) & spp_chunk_align_mask);
+}
+
+
+#ifndef SPP_FOOTERS
+    #define SPP_FOOTERS 0
+#endif
+
+#ifndef SPP_ABORT
+    #define SPP_ABORT  abort()
+#endif
+
+#ifndef SPP_ABORT_ON_ASSERT_FAILURE
+    #define SPP_ABORT_ON_ASSERT_FAILURE 1
+#endif
+
+#ifndef SPP_PROCEED_ON_ERROR
+    #define SPP_PROCEED_ON_ERROR 0
+#endif
+
+#ifndef SPP_INSECURE
+    #define SPP_INSECURE 0
+#endif
+
+#ifndef SPP_MALLOC_INSPECT_ALL
+    #define SPP_MALLOC_INSPECT_ALL 0
+#endif
+
+#ifndef SPP_HAVE_MMAP
+    #define SPP_HAVE_MMAP 1
+#endif
+
+#ifndef SPP_MMAP_CLEARS
+    #define SPP_MMAP_CLEARS 1
+#endif
+
+#ifndef SPP_HAVE_MREMAP
+    #ifdef linux
+        #define SPP_HAVE_MREMAP 1
+        #ifndef _GNU_SOURCE
+            #define _GNU_SOURCE /* Turns on mremap() definition */
+        #endif
+    #else
+        #define SPP_HAVE_MREMAP 0
+    #endif
+#endif
+
+#ifndef SPP_MALLOC_FAILURE_ACTION
+    // ENOMEM = 12
+    #define SPP_MALLOC_FAILURE_ACTION  errno = 12
+#endif
+
+
+#ifndef SPP_DEFAULT_GRANULARITY
+    #if defined(WIN32)
+        #define SPP_DEFAULT_GRANULARITY (0)  /* 0 means to compute in init_mparams */
+    #else
+        #define SPP_DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
+    #endif
+#endif
+
+#ifndef SPP_DEFAULT_TRIM_THRESHOLD
+    #define SPP_DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)
+#endif
+
+#ifndef SPP_DEFAULT_MMAP_THRESHOLD
+    #if SPP_HAVE_MMAP
+        #define SPP_DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
+    #else
+        #define SPP_DEFAULT_MMAP_THRESHOLD spp_max_size_t
+    #endif
+#endif
+
+#ifndef SPP_MAX_RELEASE_CHECK_RATE
+    #if SPP_HAVE_MMAP
+        #define SPP_MAX_RELEASE_CHECK_RATE 4095
+    #else
+        #define SPP_MAX_RELEASE_CHECK_RATE spp_max_size_t
+    #endif
+#endif
+
+#ifndef SPP_USE_BUILTIN_FFS
+    #define SPP_USE_BUILTIN_FFS 0
+#endif
+
+#ifndef SPP_USE_DEV_RANDOM
+    #define SPP_USE_DEV_RANDOM 0
+#endif
+
+#ifndef SPP_NO_SEGMENT_TRAVERSAL
+    #define SPP_NO_SEGMENT_TRAVERSAL 0
+#endif
+
+
+
+/*------------------------------ internal #includes ---------------------- */
+
+#ifdef _MSC_VER
+    #pragma warning( disable : 4146 ) /* no "unsigned" warnings */
+#endif
+#ifndef SPP_LACKS_ERRNO_H
+    #include <errno.h>       /* for SPP_MALLOC_FAILURE_ACTION */
+#endif
+
+#ifdef SPP_DEBUG
+    #if SPP_ABORT_ON_ASSERT_FAILURE
+        #undef assert
+        #define assert(x) if(!(x)) SPP_ABORT
+    #else
+        #include <assert.h>
+    #endif
+#else
+    #ifndef assert
+        #define assert(x)
+    #endif
+    #define SPP_DEBUG 0
+#endif
+
+#if !defined(WIN32) && !defined(SPP_LACKS_TIME_H)
+    #include <time.h>        /* for magic initialization */
+#endif
+
+#ifndef SPP_LACKS_STDLIB_H
+    #include <stdlib.h>      /* for abort() */
+#endif
+
+#ifndef SPP_LACKS_STRING_H
+    #include <string.h>      /* for memset etc */
+#endif
+
+#if SPP_USE_BUILTIN_FFS
+    #ifndef SPP_LACKS_STRINGS_H
+        #include <strings.h>     /* for ffs */
+    #endif
+#endif
+
+#if SPP_HAVE_MMAP
+    #ifndef SPP_LACKS_SYS_MMAN_H
+        /* On some versions of linux, mremap decl in mman.h needs __USE_GNU set */
+        #if (defined(linux) && !defined(__USE_GNU))
+            #define __USE_GNU 1
+            #include <sys/mman.h>    /* for mmap */
+            #undef __USE_GNU
+        #else
+            #include <sys/mman.h>    /* for mmap */
+        #endif
+    #endif
+    #ifndef SPP_LACKS_FCNTL_H
+        #include <fcntl.h>
+    #endif
+#endif
+
+#ifndef SPP_LACKS_UNISTD_H
+    #include <unistd.h>     /* for sbrk, sysconf */
+#else
+    #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
+        extern void*     sbrk(ptrdiff_t);
+    #endif
+#endif
+
+#include <new>
+
+namespace spp
+{
+
+/* Declarations for bit scanning on win32 */
+#if defined(_MSC_VER) && _MSC_VER>=1300
+    #ifndef BitScanForward /* Try to avoid pulling in WinNT.h */
+        extern "C" {
+            unsigned char _BitScanForward(unsigned long *index, unsigned long mask);
+            unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);
+        }
+        
+        #define BitScanForward _BitScanForward
+        #define BitScanReverse _BitScanReverse
+        #pragma intrinsic(_BitScanForward)
+        #pragma intrinsic(_BitScanReverse)
+    #endif /* BitScanForward */
+#endif /* defined(_MSC_VER) && _MSC_VER>=1300 */
+
+#ifndef WIN32
+    #ifndef malloc_getpagesize
+        #ifdef _SC_PAGESIZE         /* some SVR4 systems omit an underscore */
+            #ifndef _SC_PAGE_SIZE
+                #define _SC_PAGE_SIZE _SC_PAGESIZE
+            #endif
+        #endif
+        #ifdef _SC_PAGE_SIZE
+            #define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
+        #else
+            #if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
+                extern size_t getpagesize();
+                #define malloc_getpagesize getpagesize()
+            #else
+                #ifdef WIN32 /* use supplied emulation of getpagesize */
+                    #define malloc_getpagesize getpagesize()
+                #else
+                    #ifndef SPP_LACKS_SYS_PARAM_H
+                        #include <sys/param.h>
+                    #endif
+                    #ifdef EXEC_PAGESIZE
+                        #define malloc_getpagesize EXEC_PAGESIZE
+                    #else
+                        #ifdef NBPG
+                            #ifndef CLSIZE
+                                #define malloc_getpagesize NBPG
+                            #else
+                                #define malloc_getpagesize (NBPG * CLSIZE)
+                            #endif
+                        #else
+                            #ifdef NBPC
+                                #define malloc_getpagesize NBPC
+                            #else
+                                #ifdef PAGESIZE
+                                    #define malloc_getpagesize PAGESIZE
+                                #else /* just guess */
+                                    #define malloc_getpagesize ((size_t)4096U)
+                                #endif
+                            #endif
+                        #endif
+                    #endif
+                #endif
+            #endif
+        #endif
+    #endif
+#endif
+
+/* -------------------------- MMAP preliminaries ------------------------- */
+
+/*
+   If SPP_HAVE_MORECORE or SPP_HAVE_MMAP are false, we just define calls and
+   checks to fail so compiler optimizer can delete code rather than
+   using so many "#if"s.
+*/
+
+
+/* MMAP must return mfail on failure */
+static void *mfail  = (void*)spp_max_size_t;
+static char *cmfail = (char*)mfail;
+
+#if SPP_HAVE_MMAP
+
+#ifndef WIN32
+    #define SPP_MUNMAP_DEFAULT(a, s)  munmap((a), (s))
+    #define SPP_MMAP_PROT            (PROT_READ | PROT_WRITE)
+    #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
+        #define MAP_ANONYMOUS        MAP_ANON
+    #endif
+    
+    #ifdef MAP_ANONYMOUS
+        #define SPP_MMAP_FLAGS           (MAP_PRIVATE | MAP_ANONYMOUS)
+        #define SPP_MMAP_DEFAULT(s)       mmap(0, (s), SPP_MMAP_PROT, SPP_MMAP_FLAGS, -1, 0)
+    #else /* MAP_ANONYMOUS */
+        /*
+           Nearly all versions of mmap support MAP_ANONYMOUS, so the following
+           is unlikely to be needed, but is supplied just in case.
+        */
+        #define SPP_MMAP_FLAGS           (MAP_PRIVATE)
+        static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
+        void SPP_MMAP_DEFAULT(size_t s)
+        {
+            if (dev_zero_fd < 0)
+                dev_zero_fd = open("/dev/zero", O_RDWR);
+            mmap(0, s, SPP_MMAP_PROT, SPP_MMAP_FLAGS, dev_zero_fd, 0);
+        }
+    #endif /* MAP_ANONYMOUS */
+    
+    #define SPP_DIRECT_MMAP_DEFAULT(s) SPP_MMAP_DEFAULT(s)
+    
+#else /* WIN32 */
+    
+    /* Win32 MMAP via VirtualAlloc */
+    static SPP_FORCEINLINE void* win32mmap(size_t size)
+    {
+        void* ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+        return (ptr != 0) ? ptr : mfail;
+    }
+    
+    /* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
+    static SPP_FORCEINLINE void* win32direct_mmap(size_t size)
+    {
+        void* ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
+                                 PAGE_READWRITE);
+        return (ptr != 0) ? ptr : mfail;
+    }
+    
+    /* This function supports releasing coalesed segments */
+    static SPP_FORCEINLINE int win32munmap(void* ptr, size_t size)
+    {
+        MEMORY_BASIC_INFORMATION minfo;
+        char* cptr = (char*)ptr;
+        while (size)
+        {
+            if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
+                return -1;
+            if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
+                    minfo.State != MEM_COMMIT || minfo.RegionSize > size)
+                return -1;
+            if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
+                return -1;
+            cptr += minfo.RegionSize;
+            size -= minfo.RegionSize;
+        }
+        return 0;
+    }
+    
+    #define SPP_MMAP_DEFAULT(s)             win32mmap(s)
+    #define SPP_MUNMAP_DEFAULT(a, s)        win32munmap((a), (s))
+    #define SPP_DIRECT_MMAP_DEFAULT(s)      win32direct_mmap(s)
+#endif /* WIN32 */
+#endif /* SPP_HAVE_MMAP */
+
+#if SPP_HAVE_MREMAP
+    #ifndef WIN32
+        #define SPP_MREMAP_DEFAULT(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv))
+    #endif
+#endif
+
+/**
+ * Define SPP_CALL_MMAP/SPP_CALL_MUNMAP/SPP_CALL_DIRECT_MMAP
+ */
+#if SPP_HAVE_MMAP
+    #define USE_MMAP_BIT                1
+
+    #ifdef SPP_MMAP
+        #define SPP_CALL_MMAP(s)        SPP_MMAP(s)
+    #else
+        #define SPP_CALL_MMAP(s)        SPP_MMAP_DEFAULT(s)
+    #endif
+
+    #ifdef SPP_MUNMAP
+        #define SPP_CALL_MUNMAP(a, s)   SPP_MUNMAP((a), (s))
+    #else
+        #define SPP_CALL_MUNMAP(a, s)   SPP_MUNMAP_DEFAULT((a), (s))
+    #endif
+
+    #ifdef SPP_DIRECT_MMAP
+        #define SPP_CALL_DIRECT_MMAP(s) SPP_DIRECT_MMAP(s)
+    #else
+        #define SPP_CALL_DIRECT_MMAP(s) SPP_DIRECT_MMAP_DEFAULT(s)
+    #endif
+
+#else  /* SPP_HAVE_MMAP */
+    #define USE_MMAP_BIT            0
+
+    #define SPP_MMAP(s)                 mfail
+    #define SPP_MUNMAP(a, s)            (-1)
+    #define SPP_DIRECT_MMAP(s)          mfail
+    #define SPP_CALL_DIRECT_MMAP(s)     SPP_DIRECT_MMAP(s)
+    #define SPP_CALL_MMAP(s)            SPP_MMAP(s)
+    #define SPP_CALL_MUNMAP(a, s)       SPP_MUNMAP((a), (s))
+#endif
+
+/**
+ * Define SPP_CALL_MREMAP
+ */
+#if SPP_HAVE_MMAP && SPP_HAVE_MREMAP
+    #ifdef MREMAP
+        #define SPP_CALL_MREMAP(addr, osz, nsz, mv) MREMAP((addr), (osz), (nsz), (mv))
+    #else
+        #define SPP_CALL_MREMAP(addr, osz, nsz, mv) SPP_MREMAP_DEFAULT((addr), (osz), (nsz), (mv))
+    #endif
+#else
+    #define SPP_CALL_MREMAP(addr, osz, nsz, mv)     mfail
+#endif
+
+/* mstate bit set if continguous morecore disabled or failed */
+static const unsigned USE_NONCONTIGUOUS_BIT = 4U;
+
+/* segment bit set in create_mspace_with_base */
+static const unsigned EXTERN_BIT = 8U;
+
+
+/* --------------------------- flags ------------------------ */
+
+static const unsigned PINUSE_BIT = 1;
+static const unsigned CINUSE_BIT = 2;
+static const unsigned FLAG4_BIT  = 4;
+static const unsigned INUSE_BITS = (PINUSE_BIT | CINUSE_BIT);
+static const unsigned FLAG_BITS  = (PINUSE_BIT | CINUSE_BIT | FLAG4_BIT);
+
+/* ------------------- Chunks sizes and alignments ----------------------- */
+
+#if SPP_FOOTERS
+    static const unsigned CHUNK_OVERHEAD = 2 * sizeof(size_t);
+#else
+    static const unsigned CHUNK_OVERHEAD = sizeof(size_t);
+#endif
+
+/* MMapped chunks need a second word of overhead ... */
+static const unsigned SPP_MMAP_CHUNK_OVERHEAD = 2 * sizeof(size_t);
+
+/* ... and additional padding for fake next-chunk at foot */
+static const unsigned SPP_MMAP_FOOT_PAD = 4 * sizeof(size_t);
+
+// ===============================================================================
+struct malloc_chunk_header
+{
+    void set_size_and_pinuse_of_free_chunk(size_t s)
+    {
+        _head = s | PINUSE_BIT;
+        set_foot(s);
+    }
+
+    void set_foot(size_t s)
+    {
+        ((malloc_chunk_header *)((char*)this + s))->_prev_foot = s;
+    }
+
+    // extraction of fields from head words
+    bool cinuse() const        { return !!(_head & CINUSE_BIT); }
+    bool pinuse() const        { return !!(_head & PINUSE_BIT); }
+    bool flag4inuse() const    { return !!(_head & FLAG4_BIT); }
+    bool is_inuse() const      { return (_head & INUSE_BITS) != PINUSE_BIT; }
+    bool is_mmapped() const    { return (_head & INUSE_BITS) == 0; }
+
+    size_t chunksize() const   { return _head & ~(FLAG_BITS); }
+
+    void clear_pinuse()        { _head &= ~PINUSE_BIT; }
+    void set_flag4()           { _head |= FLAG4_BIT; }
+    void clear_flag4()         { _head &= ~FLAG4_BIT; }
+
+    // Treat space at ptr +/- offset as a chunk
+    malloc_chunk_header * chunk_plus_offset(size_t s)
+    {
+        return (malloc_chunk_header *)((char*)this + s);
+    }
+    malloc_chunk_header * chunk_minus_offset(size_t s)
+    {
+        return (malloc_chunk_header *)((char*)this - s);
+    }
+
+    // Ptr to next or previous physical malloc_chunk.
+    malloc_chunk_header * next_chunk()
+    {
+        return (malloc_chunk_header *)((char*)this + (_head & ~FLAG_BITS));
+    }
+    malloc_chunk_header * prev_chunk()
+    {
+        return (malloc_chunk_header *)((char*)this - (_prev_foot));
+    }
+
+    // extract next chunk's pinuse bit
+    size_t next_pinuse()  { return next_chunk()->_head & PINUSE_BIT; }
+
+    size_t   _prev_foot;  // Size of previous chunk (if free).
+    size_t   _head;       // Size and inuse bits.
+};
+
+// ===============================================================================
+struct malloc_chunk : public malloc_chunk_header
+{
+    // Set size, pinuse bit, foot, and clear next pinuse
+    void set_free_with_pinuse(size_t s, malloc_chunk* n)
+    {
+        n->clear_pinuse();
+        set_size_and_pinuse_of_free_chunk(s);
+    }
+
+    // Get the internal overhead associated with chunk p
+    size_t overhead_for() { return is_mmapped() ? SPP_MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD; }
+
+    // Return true if malloced space is not necessarily cleared
+    bool calloc_must_clear()
+    {
+#if SPP_MMAP_CLEARS
+        return !is_mmapped();
+#else
+        return true;
+#endif
+    }
+
+    struct malloc_chunk* _fd;         // double links -- used only if free.
+    struct malloc_chunk* _bk;
+};
+
+static const unsigned MCHUNK_SIZE = sizeof(malloc_chunk);
+
+/* The smallest size we can malloc is an aligned minimal chunk */
+static const unsigned MIN_CHUNK_SIZE = (MCHUNK_SIZE + spp_chunk_align_mask) & ~spp_chunk_align_mask;
+
+typedef malloc_chunk  mchunk;
+typedef malloc_chunk* mchunkptr;
+typedef malloc_chunk_header *hchunkptr;
+typedef malloc_chunk* sbinptr;         // The type of bins of chunks
+typedef unsigned int bindex_t;         // Described below
+typedef unsigned int binmap_t;         // Described below
+typedef unsigned int flag_t;           // The type of various bit flag sets
+
+// conversion from malloc headers to user pointers, and back
+static SPP_FORCEINLINE void *chunk2mem(const void *p)       { return (void *)((char *)p + 2 * sizeof(size_t)); }
+static SPP_FORCEINLINE mchunkptr mem2chunk(const void *mem) { return (mchunkptr)((char *)mem - 2 * sizeof(size_t)); }
+
+// chunk associated with aligned address A
+static SPP_FORCEINLINE mchunkptr align_as_chunk(char *A)    { return (mchunkptr)(A + align_offset(chunk2mem(A))); }
+
+// Bounds on request (not chunk) sizes.
+static const unsigned MAX_REQUEST = (-MIN_CHUNK_SIZE) << 2;
+static const unsigned MIN_REQUEST = MIN_CHUNK_SIZE - CHUNK_OVERHEAD - 1;
+
+// pad request bytes into a usable size
+static SPP_FORCEINLINE size_t pad_request(size_t req)
+{
+    return (req + CHUNK_OVERHEAD + spp_chunk_align_mask) & ~spp_chunk_align_mask;
+}
+
+// pad request, checking for minimum (but not maximum)
+static SPP_FORCEINLINE size_t request2size(size_t req)
+{
+    return req < MIN_REQUEST ? MIN_CHUNK_SIZE : pad_request(req);
+}
+
+
+/* ------------------ Operations on head and foot fields ----------------- */
+
+/*
+  The head field of a chunk is or'ed with PINUSE_BIT when previous
+  adjacent chunk in use, and or'ed with CINUSE_BIT if this chunk is in
+  use, unless mmapped, in which case both bits are cleared.
+
+  FLAG4_BIT is not used by this malloc, but might be useful in extensions.
+*/
+
+// Head value for fenceposts
+static const unsigned FENCEPOST_HEAD = INUSE_BITS | sizeof(size_t);
+
+
+/* ---------------------- Overlaid data structures ----------------------- */
+
+/*
+  When chunks are not in use, they are treated as nodes of either
+  lists or trees.
+
+  "Small"  chunks are stored in circular doubly-linked lists, and look
+  like this:
+
+    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Size of previous chunk                            |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    `head:' |             Size of chunk, in bytes                         |P|
+      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Forward pointer to next chunk in list             |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Back pointer to previous chunk in list            |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Unused space (may be 0 bytes long)                .
+            .                                                               .
+            .                                                               |
+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    `foot:' |             Size of chunk, in bytes                           |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+  Larger chunks are kept in a form of bitwise digital trees (aka
+  tries) keyed on chunksizes.  Because malloc_tree_chunks are only for
+  free chunks greater than 256 bytes, their size doesn't impose any
+  constraints on user chunk sizes.  Each node looks like:
+
+    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Size of previous chunk                            |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    `head:' |             Size of chunk, in bytes                         |P|
+      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Forward pointer to next chunk of same size        |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Back pointer to previous chunk of same size       |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Pointer to left child (child[0])                  |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Pointer to right child (child[1])                 |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Pointer to parent                                 |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             bin index of this chunk                           |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |             Unused space                                      .
+            .                                                               |
+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    `foot:' |             Size of chunk, in bytes                           |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+  Each tree holding treenodes is a tree of unique chunk sizes.  Chunks
+  of the same size are arranged in a circularly-linked list, with only
+  the oldest chunk (the next to be used, in our FIFO ordering)
+  actually in the tree.  (Tree members are distinguished by a non-null
+  parent pointer.)  If a chunk with the same size an an existing node
+  is inserted, it is linked off the existing node using pointers that
+  work in the same way as fd/bk pointers of small chunks.
+
+  Each tree contains a power of 2 sized range of chunk sizes (the
+  smallest is 0x100 <= x < 0x180), which is is divided in half at each
+  tree level, with the chunks in the smaller half of the range (0x100
+  <= x < 0x140 for the top nose) in the left subtree and the larger
+  half (0x140 <= x < 0x180) in the right subtree.  This is, of course,
+  done by inspecting individual bits.
+
+  Using these rules, each node's left subtree contains all smaller
+  sizes than its right subtree.  However, the node at the root of each
+  subtree has no particular ordering relationship to either.  (The
+  dividing line between the subtree sizes is based on trie relation.)
+  If we remove the last chunk of a given size from the interior of the
+  tree, we need to replace it with a leaf node.  The tree ordering
+  rules permit a node to be replaced by any leaf below it.
+
+  The smallest chunk in a tree (a common operation in a best-fit
+  allocator) can be found by walking a path to the leftmost leaf in
+  the tree.  Unlike a usual binary tree, where we follow left child
+  pointers until we reach a null, here we follow the right child
+  pointer any time the left one is null, until we reach a leaf with
+  both child pointers null. The smallest chunk in the tree will be
+  somewhere along that path.
+
+  The worst case number of steps to add, find, or remove a node is
+  bounded by the number of bits differentiating chunks within
+  bins. Under current bin calculations, this ranges from 6 up to 21
+  (for 32 bit sizes) or up to 53 (for 64 bit sizes). The typical case
+  is of course much better.
+*/
+
+// ===============================================================================
+struct malloc_tree_chunk : public malloc_chunk_header
+{
+    malloc_tree_chunk *leftmost_child()
+    {
+        return _child[0] ? _child[0] : _child[1];
+    }
+
+
+    malloc_tree_chunk* _fd;
+    malloc_tree_chunk* _bk;
+
+    malloc_tree_chunk* _child[2];
+    malloc_tree_chunk* _parent;
+    bindex_t           _index;
+};
+
+typedef malloc_tree_chunk  tchunk;
+typedef malloc_tree_chunk* tchunkptr;
+typedef malloc_tree_chunk* tbinptr; // The type of bins of trees
+
+/* ----------------------------- Segments -------------------------------- */
+
+/*
+  Each malloc space may include non-contiguous segments, held in a
+  list headed by an embedded malloc_segment record representing the
+  top-most space. Segments also include flags holding properties of
+  the space. Large chunks that are directly allocated by mmap are not
+  included in this list. They are instead independently created and
+  destroyed without otherwise keeping track of them.
+
+  Segment management mainly comes into play for spaces allocated by
+  MMAP.  Any call to MMAP might or might not return memory that is
+  adjacent to an existing segment.  MORECORE normally contiguously
+  extends the current space, so this space is almost always adjacent,
+  which is simpler and faster to deal with. (This is why MORECORE is
+  used preferentially to MMAP when both are available -- see
+  sys_alloc.)  When allocating using MMAP, we don't use any of the
+  hinting mechanisms (inconsistently) supported in various
+  implementations of unix mmap, or distinguish reserving from
+  committing memory. Instead, we just ask for space, and exploit
+  contiguity when we get it.  It is probably possible to do
+  better than this on some systems, but no general scheme seems
+  to be significantly better.
+
+  Management entails a simpler variant of the consolidation scheme
+  used for chunks to reduce fragmentation -- new adjacent memory is
+  normally prepended or appended to an existing segment. However,
+  there are limitations compared to chunk consolidation that mostly
+  reflect the fact that segment processing is relatively infrequent
+  (occurring only when getting memory from system) and that we
+  don't expect to have huge numbers of segments:
+
+  * Segments are not indexed, so traversal requires linear scans.  (It
+    would be possible to index these, but is not worth the extra
+    overhead and complexity for most programs on most platforms.)
+  * New segments are only appended to old ones when holding top-most
+    memory; if they cannot be prepended to others, they are held in
+    different segments.
+
+  Except for the top-most segment of an mstate, each segment record
+  is kept at the tail of its segment. Segments are added by pushing
+  segment records onto the list headed by &mstate.seg for the
+  containing mstate.
+
+  Segment flags control allocation/merge/deallocation policies:
+  * If EXTERN_BIT set, then we did not allocate this segment,
+    and so should not try to deallocate or merge with others.
+    (This currently holds only for the initial segment passed
+    into create_mspace_with_base.)
+  * If USE_MMAP_BIT set, the segment may be merged with
+    other surrounding mmapped segments and trimmed/de-allocated
+    using munmap.
+  * If neither bit is set, then the segment was obtained using
+    MORECORE so can be merged with surrounding MORECORE'd segments
+    and deallocated/trimmed using MORECORE with negative arguments.
+*/
+
+// ===============================================================================
+struct malloc_segment
+{
+    bool is_mmapped_segment()  { return !!(_sflags & USE_MMAP_BIT); }
+    bool is_extern_segment()   { return !!(_sflags & EXTERN_BIT); }
+
+    char*           _base;          // base address
+    size_t          _size;          // allocated size
+    malloc_segment* _next;          // ptr to next segment
+    flag_t          _sflags;        // mmap and extern flag
+};
+
+typedef malloc_segment  msegment;
+typedef malloc_segment* msegmentptr;
+
+/* ------------- Malloc_params ------------------- */
+
+/*
+  malloc_params holds global properties, including those that can be
+  dynamically set using mallopt. There is a single instance, mparams,
+  initialized in init_mparams. Note that the non-zeroness of "magic"
+  also serves as an initialization flag.
+*/
+
+// ===============================================================================
+struct malloc_params
+{
+    malloc_params() : _magic(0) {}
+
+    void ensure_initialization()
+    {
+        if (!_magic)
+            _init();
+    }
+    
+    SPP_IMPL int change(int param_number, int value);
+
+    size_t page_align(size_t sz)
+    {
+        return (sz + (_page_size - 1)) & ~(_page_size - 1);
+    }
+
+    size_t granularity_align(size_t sz)
+    {
+        return (sz + (_granularity - 1)) & ~(_granularity - 1);
+    }
+
+    bool is_page_aligned(char *S)
+    {
+        return ((size_t)S & (_page_size - 1)) == 0;
+    }
+
+    SPP_IMPL int _init();
+
+    size_t _magic;
+    size_t _page_size;
+    size_t _granularity;
+    size_t _mmap_threshold;
+    size_t _trim_threshold;
+    flag_t _default_mflags;
+};
+
+static malloc_params mparams;
+
+/* ---------------------------- malloc_state ----------------------------- */
+
+/*
+   A malloc_state holds all of the bookkeeping for a space.
+   The main fields are:
+
+  Top
+    The topmost chunk of the currently active segment. Its size is
+    cached in topsize.  The actual size of topmost space is
+    topsize+TOP_FOOT_SIZE, which includes space reserved for adding
+    fenceposts and segment records if necessary when getting more
+    space from the system.  The size at which to autotrim top is
+    cached from mparams in trim_check, except that it is disabled if
+    an autotrim fails.
+
+  Designated victim (dv)
+    This is the preferred chunk for servicing small requests that
+    don't have exact fits.  It is normally the chunk split off most
+    recently to service another small request.  Its size is cached in
+    dvsize. The link fields of this chunk are not maintained since it
+    is not kept in a bin.
+
+  SmallBins
+    An array of bin headers for free chunks.  These bins hold chunks
+    with sizes less than MIN_LARGE_SIZE bytes. Each bin contains
+    chunks of all the same size, spaced 8 bytes apart.  To simplify
+    use in double-linked lists, each bin header acts as a malloc_chunk
+    pointing to the real first node, if it exists (else pointing to
+    itself).  This avoids special-casing for headers.  But to avoid
+    waste, we allocate only the fd/bk pointers of bins, and then use
+    repositioning tricks to treat these as the fields of a chunk.
+
+  TreeBins
+    Treebins are pointers to the roots of trees holding a range of
+    sizes. There are 2 equally spaced treebins for each power of two
+    from TREE_SHIFT to TREE_SHIFT+16. The last bin holds anything
+    larger.
+
+  Bin maps
+    There is one bit map for small bins ("smallmap") and one for
+    treebins ("treemap).  Each bin sets its bit when non-empty, and
+    clears the bit when empty.  Bit operations are then used to avoid
+    bin-by-bin searching -- nearly all "search" is done without ever
+    looking at bins that won't be selected.  The bit maps
+    conservatively use 32 bits per map word, even if on 64bit system.
+    For a good description of some of the bit-based techniques used
+    here, see Henry S. Warren Jr's book "Hacker's Delight" (and
+    supplement at http://hackersdelight.org/). Many of these are
+    intended to reduce the branchiness of paths through malloc etc, as
+    well as to reduce the number of memory locations read or written.
+
+  Segments
+    A list of segments headed by an embedded malloc_segment record
+    representing the initial space.
+
+  Address check support
+    The least_addr field is the least address ever obtained from
+    MORECORE or MMAP. Attempted frees and reallocs of any address less
+    than this are trapped (unless SPP_INSECURE is defined).
+
+  Magic tag
+    A cross-check field that should always hold same value as mparams._magic.
+
+  Max allowed footprint
+    The maximum allowed bytes to allocate from system (zero means no limit)
+
+  Flags
+    Bits recording whether to use MMAP, locks, or contiguous MORECORE
+
+  Statistics
+    Each space keeps track of current and maximum system memory
+    obtained via MORECORE or MMAP.
+
+  Trim support
+    Fields holding the amount of unused topmost memory that should trigger
+    trimming, and a counter to force periodic scanning to release unused
+    non-topmost segments.
+
+  Extension support
+    A void* pointer and a size_t field that can be used to help implement
+    extensions to this malloc.
+*/
+
+
+// ================================================================================
+class malloc_state
+{
+public:
+    /* ----------------------- _malloc, _free, etc... --- */
+    SPP_FORCEINLINE void* _malloc(size_t bytes);
+    SPP_FORCEINLINE void  _free(mchunkptr p);
+
+
+    /* ------------------------ Relays to internal calls to malloc/free from realloc, memalign etc */
+    void *internal_malloc(size_t b) { return mspace_malloc(this, b); }
+    void internal_free(void *mem)   { mspace_free(this, mem); }
+
+    /* ------------------------ ----------------------- */
+
+    SPP_IMPL void      init_top(mchunkptr p, size_t psize);
+    SPP_IMPL void      init_bins();
+    SPP_IMPL void      init(char* tbase, size_t tsize);
+
+    /* ------------------------ System alloc/dealloc -------------------------- */
+    SPP_IMPL void*     sys_alloc(size_t nb);
+    SPP_IMPL size_t    release_unused_segments();
+    SPP_IMPL int       sys_trim(size_t pad);
+    SPP_IMPL void      dispose_chunk(mchunkptr p, size_t psize);
+
+    /* ----------------------- Internal support for realloc, memalign, etc --- */
+    SPP_IMPL mchunkptr try_realloc_chunk(mchunkptr p, size_t nb, int can_move);
+    SPP_IMPL void*     internal_memalign(size_t alignment, size_t bytes);
+    SPP_IMPL void**    ialloc(size_t n_elements, size_t* sizes, int opts, void* chunks[]);
+    SPP_IMPL size_t    internal_bulk_free(void* array[], size_t nelem);
+    SPP_IMPL void      internal_inspect_all(void(*handler)(void *start, void *end,
+                                                           size_t used_bytes, void* callback_arg),
+                                            void* arg);
+
+    /* -------------------------- system alloc setup (Operations on mflags) ----- */
+    bool      use_lock() const { return false; }
+    void      enable_lock()    {}
+    void      set_lock(int)    {}
+    void      disable_lock()   {}
+
+    bool      use_mmap() const { return !!(_mflags & USE_MMAP_BIT); }
+    void      enable_mmap()    { _mflags |=  USE_MMAP_BIT; }
+
+#if SPP_HAVE_MMAP
+    void      disable_mmap()   { _mflags &= ~USE_MMAP_BIT; }
+#else
+    void      disable_mmap()   {}
+#endif
+
+    /* ----------------------- Runtime Check Support ------------------------- */
+
+    /*
+      For security, the main invariant is that malloc/free/etc never
+      writes to a static address other than malloc_state, unless static
+      malloc_state itself has been corrupted, which cannot occur via
+      malloc (because of these checks). In essence this means that we
+      believe all pointers, sizes, maps etc held in malloc_state, but
+      check all of those linked or offsetted from other embedded data
+      structures.  These checks are interspersed with main code in a way
+      that tends to minimize their run-time cost.
+
+      When SPP_FOOTERS is defined, in addition to range checking, we also
+      verify footer fields of inuse chunks, which can be used guarantee
+      that the mstate controlling malloc/free is intact.  This is a
+      streamlined version of the approach described by William Robertson
+      et al in "Run-time Detection of Heap-based Overflows" LISA'03
+      http://www.usenix.org/events/lisa03/tech/robertson.html The footer
+      of an inuse chunk holds the xor of its mstate and a random seed,
+      that is checked upon calls to free() and realloc().  This is
+      (probabalistically) unguessable from outside the program, but can be
+      computed by any code successfully malloc'ing any chunk, so does not
+      itself provide protection against code that has already broken
+      security through some other means.  Unlike Robertson et al, we
+      always dynamically check addresses of all offset chunks (previous,
+      next, etc). This turns out to be cheaper than relying on hashes.
+    */
+
+
+#if !SPP_INSECURE
+    // Check if address a is at least as high as any from MORECORE or MMAP
+    bool        ok_address(void *a) const { return (char *)a >= _least_addr; }
+
+    // Check if address of next chunk n is higher than base chunk p
+    static bool ok_next(void *p, void *n) { return p < n; }
+
+    // Check if p has inuse status
+    static bool ok_inuse(mchunkptr p)     { return p->is_inuse(); }
+
+    // Check if p has its pinuse bit on
+    static bool ok_pinuse(mchunkptr p)    { return p->pinuse(); }
+
+    // Check if (alleged) mstate m has expected magic field
+    bool        ok_magic() const          { return _magic == mparams._magic; }
+
+    // In gcc, use __builtin_expect to minimize impact of checks
+  #if defined(__GNUC__) && __GNUC__ >= 3
+    static bool rtcheck(bool e)       { return __builtin_expect(e, 1); }
+  #else
+    static bool rtcheck(bool e)       { return e; }
+  #endif
+#else
+    static bool ok_address(void *)       { return true; }
+    static bool ok_next(void *, void *)  { return true; }
+    static bool ok_inuse(mchunkptr)      { return true; }
+    static bool ok_pinuse(mchunkptr)     { return true; }
+    static bool ok_magic()               { return true; }
+    static bool rtcheck(bool)            { return true; }
+#endif
+
+    bool is_initialized() const           { return _top != 0; }
+
+    bool use_noncontiguous()  const       { return !!(_mflags & USE_NONCONTIGUOUS_BIT); }
+    void disable_contiguous()             { _mflags |=  USE_NONCONTIGUOUS_BIT; }
+
+    // Return segment holding given address
+    msegmentptr segment_holding(char* addr) const
+    {
+        msegmentptr sp = (msegmentptr)&_seg;
+        for (;;)
+        {
+            if (addr >= sp->_base && addr < sp->_base + sp->_size)
+                return sp;
+            if ((sp = sp->_next) == 0)
+                return 0;
+        }
+    }
+
+    // Return true if segment contains a segment link
+    int has_segment_link(msegmentptr ss) const
+    {
+        msegmentptr sp = (msegmentptr)&_seg;
+        for (;;)
+        {
+            if ((char*)sp >= ss->_base && (char*)sp < ss->_base + ss->_size)
+                return 1;
+            if ((sp = sp->_next) == 0)
+                return 0;
+        }
+    }
+
+    bool should_trim(size_t s) const { return s > _trim_check; }
+
+    /* -------------------------- Debugging setup ---------------------------- */
+
+#if ! SPP_DEBUG
+    void check_free_chunk(mchunkptr) {}
+    void check_inuse_chunk(mchunkptr) {}
+    void check_malloced_chunk(void*, size_t) {}
+    void check_mmapped_chunk(mchunkptr) {}
+    void check_malloc_state() {}
+    void check_top_chunk(mchunkptr) {}
+#else /* SPP_DEBUG */
+    void check_free_chunk(mchunkptr p)       { do_check_free_chunk(p); }
+    void check_inuse_chunk(mchunkptr p)      { do_check_inuse_chunk(p); }
+    void check_malloced_chunk(void* p, size_t s) { do_check_malloced_chunk(p, s); }
+    void check_mmapped_chunk(mchunkptr p)    { do_check_mmapped_chunk(p); }
+    void check_malloc_state()                { do_check_malloc_state(); }
+    void check_top_chunk(mchunkptr p)        { do_check_top_chunk(p); }
+
+    void do_check_any_chunk(mchunkptr p) const;
+    void do_check_top_chunk(mchunkptr p) const;
+    void do_check_mmapped_chunk(mchunkptr p) const;
+    void do_check_inuse_chunk(mchunkptr p) const;
+    void do_check_free_chunk(mchunkptr p) const;
+    void do_check_malloced_chunk(void* mem, size_t s) const;
+    void do_check_tree(tchunkptr t);
+    void do_check_treebin(bindex_t i);
+    void do_check_smallbin(bindex_t i);
+    void do_check_malloc_state();
+    int  bin_find(mchunkptr x);
+    size_t traverse_and_check();
+#endif
+
+private:
+
+    /* ---------------------------- Indexing Bins ---------------------------- */
+
+    static bool  is_small(size_t s)          { return (s >> SMALLBIN_SHIFT) < NSMALLBINS; }
+    static bindex_t  small_index(size_t s)   { return (bindex_t)(s  >> SMALLBIN_SHIFT); }
+    static size_t small_index2size(size_t i) { return i << SMALLBIN_SHIFT; }
+    static bindex_t  MIN_SMALL_INDEX()       { return small_index(MIN_CHUNK_SIZE); }
+
+    // assign tree index for size S to variable I. Use x86 asm if possible
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+    SPP_FORCEINLINE static bindex_t compute_tree_index(size_t S)
+    {
+        unsigned int X = S >> TREEBIN_SHIFT;
+        if (X == 0)
+            return 0;
+        else if (X > 0xFFFF)
+            return NTREEBINS - 1;
+
+        unsigned int K = (unsigned) sizeof(X) * __CHAR_BIT__ - 1 - (unsigned) __builtin_clz(X);
+        return (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT - 1)) & 1)));
+    }
+
+#elif defined (__INTEL_COMPILER)
+    SPP_FORCEINLINE static bindex_t compute_tree_index(size_t S)
+    {
+        size_t X = S >> TREEBIN_SHIFT;
+        if (X == 0)
+            return 0;
+        else if (X > 0xFFFF)
+            return NTREEBINS - 1;
+
+        unsigned int K = _bit_scan_reverse(X);
+        return (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT - 1)) & 1)));
+    }
+
+#elif defined(_MSC_VER) && _MSC_VER>=1300
+    SPP_FORCEINLINE static bindex_t compute_tree_index(size_t S)
+    {
+        size_t X = S >> TREEBIN_SHIFT;
+        if (X == 0)
+            return 0;
+        else if (X > 0xFFFF)
+            return NTREEBINS - 1;
+
+        unsigned int K;
+        _BitScanReverse((DWORD *) &K, (DWORD) X);
+        return (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT - 1)) & 1)));
+    }
+
+#else // GNUC
+    SPP_FORCEINLINE static bindex_t compute_tree_index(size_t S)
+    {
+        size_t X = S >> TREEBIN_SHIFT;
+        if (X == 0)
+            return 0;
+        else if (X > 0xFFFF)
+            return NTREEBINS - 1;
+
+        unsigned int Y = (unsigned int)X;
+        unsigned int N = ((Y - 0x100) >> 16) & 8;
+        unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;
+        N += K;
+        N += K = (((Y <<= K) - 0x4000) >> 16) & 2;
+        K = 14 - N + ((Y <<= K) >> 15);
+        return (K << 1) + ((S >> (K + (TREEBIN_SHIFT - 1)) & 1));
+    }
+#endif
+
+    // Shift placing maximum resolved bit in a treebin at i as sign bit
+    static bindex_t leftshift_for_tree_index(bindex_t i)
+    {
+        return (i == NTREEBINS - 1) ? 0 :
+               ((spp_size_t_bitsize - 1) - ((i >> 1) + TREEBIN_SHIFT - 2));
+    }
+
+    // The size of the smallest chunk held in bin with index i
+    static bindex_t minsize_for_tree_index(bindex_t i)
+    {
+        return ((size_t)1 << ((i >> 1) + TREEBIN_SHIFT)) |
+               (((size_t)(i & 1)) << ((i >> 1) + TREEBIN_SHIFT - 1));
+    }
+
+
+    // ----------- isolate the least set bit of a bitmap
+    static binmap_t least_bit(binmap_t x) { return x & -x; }
+
+    // ----------- mask with all bits to left of least bit of x on
+    static binmap_t left_bits(binmap_t x) { return (x << 1) | -(x << 1); }
+
+    // index corresponding to given bit. Use x86 asm if possible
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+    static bindex_t compute_bit2idx(binmap_t X)
+    {
+        unsigned int J;
+        J = __builtin_ctz(X);
+        return (bindex_t)J;
+    }
+
+#elif defined (__INTEL_COMPILER)
+    static bindex_t compute_bit2idx(binmap_t X)
+    {
+        unsigned int J;
+        J = _bit_scan_forward(X);
+        return (bindex_t)J;
+    }
+
+#elif defined(_MSC_VER) && _MSC_VER>=1300
+    static bindex_t compute_bit2idx(binmap_t X)
+    {
+        unsigned int J;
+        _BitScanForward((DWORD *) &J, X);
+        return (bindex_t)J;
+    }
+
+#elif SPP_USE_BUILTIN_FFS
+    static bindex_t compute_bit2idx(binmap_t X) { return ffs(X) - 1; }
+
+#else
+    static bindex_t compute_bit2idx(binmap_t X)
+    {
+        unsigned int Y = X - 1;
+        unsigned int K = Y >> (16 - 4) & 16;
+        unsigned int N = K;        Y >>= K;
+        N += K = Y >> (8 - 3) &  8;  Y >>= K;
+        N += K = Y >> (4 - 2) &  4;  Y >>= K;
+        N += K = Y >> (2 - 1) &  2;  Y >>= K;
+        N += K = Y >> (1 - 0) &  1;  Y >>= K;
+        return (bindex_t)(N + Y);
+    }
+#endif
+
+    /* ------------------------ Set up inuse chunks with or without footers ---*/
+#if !SPP_FOOTERS
+    void mark_inuse_foot(malloc_chunk_header *, size_t) {}
+#else
+    //Set foot of inuse chunk to be xor of mstate and seed
+    void  mark_inuse_foot(malloc_chunk_header *p, size_t s)
+    {
+        (((mchunkptr)((char*)p + s))->prev_foot = (size_t)this ^ mparams._magic);
+    }
+#endif
+
+    void set_inuse(malloc_chunk_header *p, size_t s)
+    {
+        p->_head = (p->_head & PINUSE_BIT) | s | CINUSE_BIT;
+        ((mchunkptr)(((char*)p) + s))->_head |= PINUSE_BIT;
+        mark_inuse_foot(p, s);
+    }
+
+    void set_inuse_and_pinuse(malloc_chunk_header *p, size_t s)
+    {
+        p->_head = s | PINUSE_BIT | CINUSE_BIT;
+        ((mchunkptr)(((char*)p) + s))->_head |= PINUSE_BIT;
+        mark_inuse_foot(p, s);
+    }
+
+    void set_size_and_pinuse_of_inuse_chunk(malloc_chunk_header *p, size_t s)
+    {
+        p->_head = s | PINUSE_BIT | CINUSE_BIT;
+        mark_inuse_foot(p, s);
+    }
+
+    /* ------------------------ Addressing by index. See  about smallbin repositioning --- */
+    sbinptr  smallbin_at(bindex_t i) const { return (sbinptr)((char*)&_smallbins[i << 1]); }
+    tbinptr* treebin_at(bindex_t i)  { return &_treebins[i]; }
+
+    /* ----------------------- bit corresponding to given index ---------*/
+    static binmap_t idx2bit(bindex_t i) { return ((binmap_t)1 << i); }
+
+    // --------------- Mark/Clear bits with given index
+    void     mark_smallmap(bindex_t i)      { _smallmap |=  idx2bit(i); }
+    void     clear_smallmap(bindex_t i)     { _smallmap &= ~idx2bit(i); }
+    binmap_t smallmap_is_marked(bindex_t i) const { return _smallmap & idx2bit(i); }
+
+    void     mark_treemap(bindex_t i)       { _treemap  |=  idx2bit(i); }
+    void     clear_treemap(bindex_t i)      { _treemap  &= ~idx2bit(i); }
+    binmap_t treemap_is_marked(bindex_t i)  const { return _treemap & idx2bit(i); }
+
+    /* ------------------------ ----------------------- */
+    SPP_FORCEINLINE void insert_small_chunk(mchunkptr P, size_t S);
+    SPP_FORCEINLINE void unlink_small_chunk(mchunkptr P, size_t S);
+    SPP_FORCEINLINE void unlink_first_small_chunk(mchunkptr B, mchunkptr P, bindex_t I);
+    SPP_FORCEINLINE void replace_dv(mchunkptr P, size_t S);
+
+    /* ------------------------- Operations on trees ------------------------- */
+    SPP_FORCEINLINE void insert_large_chunk(tchunkptr X, size_t S);
+    SPP_FORCEINLINE void unlink_large_chunk(tchunkptr X);
+
+    /* ------------------------ Relays to large vs small bin operations */
+    SPP_FORCEINLINE void insert_chunk(mchunkptr P, size_t S);
+    SPP_FORCEINLINE void unlink_chunk(mchunkptr P, size_t S);
+
+    /* -----------------------  Direct-mmapping chunks ----------------------- */
+    SPP_IMPL void*       mmap_alloc(size_t nb);
+    SPP_IMPL mchunkptr   mmap_resize(mchunkptr oldp, size_t nb, int flags);
+
+    SPP_IMPL void        reset_on_error();
+    SPP_IMPL void*       prepend_alloc(char* newbase, char* oldbase, size_t nb);
+    SPP_IMPL void        add_segment(char* tbase, size_t tsize, flag_t mmapped);
+
+    /* ------------------------ malloc --------------------------- */
+    SPP_IMPL void*       tmalloc_large(size_t nb);
+    SPP_IMPL void*       tmalloc_small(size_t nb);
+
+    /* ------------------------Bin types, widths and sizes -------- */
+    static const size_t NSMALLBINS      = 32;
+    static const size_t NTREEBINS       = 32;
+    static const size_t SMALLBIN_SHIFT  = 3;
+    static const size_t SMALLBIN_WIDTH  = 1 << SMALLBIN_SHIFT;
+    static const size_t TREEBIN_SHIFT   = 8;
+    static const size_t MIN_LARGE_SIZE  = 1 << TREEBIN_SHIFT;
+    static const size_t MAX_SMALL_SIZE  = (MIN_LARGE_SIZE - 1);
+    static const size_t MAX_SMALL_REQUEST = (MAX_SMALL_SIZE - spp_chunk_align_mask - CHUNK_OVERHEAD);
+
+    /* ------------------------ data members --------------------------- */
+    binmap_t   _smallmap;
+    binmap_t   _treemap;
+    size_t     _dvsize;
+    size_t     _topsize;
+    char*      _least_addr;
+    mchunkptr  _dv;
+    mchunkptr  _top;
+    size_t     _trim_check;
+    size_t     _release_checks;
+    size_t     _magic;
+    mchunkptr  _smallbins[(NSMALLBINS + 1) * 2];
+    tbinptr    _treebins[NTREEBINS];
+public:
+    size_t     _footprint;
+    size_t     _max_footprint;
+    size_t     _footprint_limit; // zero means no limit
+    flag_t     _mflags;
+
+    msegment   _seg;
+
+private:
+    void*      _extp;      // Unused but available for extensions
+    size_t     _exts;
+};
+
+typedef malloc_state*    mstate;
+
+/* ------------- end malloc_state ------------------- */
+
+#if SPP_FOOTERS
+static malloc_state* get_mstate_for(malloc_chunk_header *p)
+{
+    return (malloc_state*)(((mchunkptr)((char*)(p) +
+                                        (p->chunksize())))->prev_foot ^ mparams._magic);
+}
+#endif
+
+/* -------------------------- system alloc setup ------------------------- */
+
+
+
+// For mmap, use granularity alignment on windows, else page-align
+#ifdef WIN32
+    #define mmap_align(S) mparams.granularity_align(S)
+#else
+    #define mmap_align(S) mparams.page_align(S)
+#endif
+
+//  True if segment S holds address A
+static bool segment_holds(msegmentptr S, mchunkptr A)
+{
+    return (char*)A >= S->_base && (char*)A < S->_base + S->_size;
+}
+
+/*
+  top_foot_size is padding at the end of a segment, including space
+  that may be needed to place segment records and fenceposts when new
+  noncontiguous segments are added.
+*/
+static SPP_FORCEINLINE size_t top_foot_size()
+{
+    return align_offset(chunk2mem((void *)0)) + 
+        pad_request(sizeof(struct malloc_segment)) + 
+        MIN_CHUNK_SIZE;
+}
+
+
+// For sys_alloc, enough padding to ensure can malloc request on success
+static SPP_FORCEINLINE size_t sys_alloc_padding()
+{
+    return  top_foot_size() + SPP_MALLOC_ALIGNMENT;
+}
+
+
+#define SPP_USAGE_ERROR_ACTION(m,p) SPP_ABORT
+
+/* ---------------------------- setting mparams -------------------------- */
+
+// Initialize mparams
+int malloc_params::_init()
+{
+#ifdef NEED_GLOBAL_LOCK_INIT
+    if (malloc_global_mutex_status <= 0)
+        init_malloc_global_mutex();
+#endif
+
+    if (_magic == 0)
+    {
+        size_t magic;
+        size_t psize;
+        size_t gsize;
+
+#ifndef WIN32
+        psize = malloc_getpagesize;
+        gsize = ((SPP_DEFAULT_GRANULARITY != 0) ? SPP_DEFAULT_GRANULARITY : psize);
+#else
+        {
+            SYSTEM_INFO system_info;
+            GetSystemInfo(&system_info);
+            psize = system_info.dwPageSize;
+            gsize = ((SPP_DEFAULT_GRANULARITY != 0) ?
+                     SPP_DEFAULT_GRANULARITY : system_info.dwAllocationGranularity);
+        }
+#endif
+
+        /* Sanity-check configuration:
+           size_t must be unsigned and as wide as pointer type.
+           ints must be at least 4 bytes.
+           alignment must be at least 8.
+           Alignment, min chunk size, and page size must all be powers of 2.
+        */
+        if ((sizeof(size_t) != sizeof(char*)) ||
+                (spp_max_size_t < MIN_CHUNK_SIZE)  ||
+                (sizeof(int) < 4)  ||
+                (SPP_MALLOC_ALIGNMENT < (size_t)8U) ||
+                ((SPP_MALLOC_ALIGNMENT & (SPP_MALLOC_ALIGNMENT - 1)) != 0) ||
+                ((MCHUNK_SIZE      & (MCHUNK_SIZE - 1))      != 0) ||
+                ((gsize            & (gsize - 1))            != 0) ||
+                ((psize            & (psize - 1))            != 0))
+            SPP_ABORT;
+        _granularity = gsize;
+        _page_size = psize;
+        _mmap_threshold = SPP_DEFAULT_MMAP_THRESHOLD;
+        _trim_threshold = SPP_DEFAULT_TRIM_THRESHOLD;
+        _default_mflags = USE_MMAP_BIT | USE_NONCONTIGUOUS_BIT;
+
+        {
+#if SPP_USE_DEV_RANDOM
+            int fd;
+            unsigned char buf[sizeof(size_t)];
+            // Try to use /dev/urandom, else fall back on using time
+            if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
+                    read(fd, buf, sizeof(buf)) == sizeof(buf))
+            {
+                magic = *((size_t *) buf);
+                close(fd);
+            }
+            else
+#endif
+            {
+#ifdef WIN32
+                magic = (size_t)(GetTickCount() ^ (size_t)0x55555555U);
+#elif defined(SPP_LACKS_TIME_H)
+                magic = (size_t)&magic ^ (size_t)0x55555555U;
+#else
+                magic = (size_t)(time(0) ^ (size_t)0x55555555U);
+#endif
+            }
+            magic |= (size_t)8U;    // ensure nonzero
+            magic &= ~(size_t)7U;   // improve chances of fault for bad values
+            // Until memory modes commonly available, use volatile-write
+            (*(volatile size_t *)(&(_magic))) = magic;
+        }
+    }
+
+    return 1;
+}
+
+/*
+  mallopt tuning options.  SVID/XPG defines four standard parameter
+  numbers for mallopt, normally defined in malloc.h.  None of these
+  are used in this malloc, so setting them has no effect. But this
+  malloc does support the following options.
+*/
+static const int  m_trim_threshold = -1;
+static const int  m_granularity    = -2;
+static const int  m_mmap_threshold = -3;
+
+// support for mallopt
+int malloc_params::change(int param_number, int value)
+{
+    size_t val;
+    ensure_initialization();
+    val = (value == -1) ? spp_max_size_t : (size_t)value;
+
+    switch (param_number)
+    {
+    case m_trim_threshold:
+        _trim_threshold = val;
+        return 1;
+
+    case m_granularity:
+        if (val >= _page_size && ((val & (val - 1)) == 0))
+        {
+            _granularity = val;
+            return 1;
+        }
+        else
+            return 0;
+
+    case m_mmap_threshold:
+        _mmap_threshold = val;
+        return 1;
+
+    default:
+        return 0;
+    }
+}
+
+#if SPP_DEBUG
+/* ------------------------- Debugging Support --------------------------- */
+
+// Check properties of any chunk, whether free, inuse, mmapped etc
+void malloc_state::do_check_any_chunk(mchunkptr p)  const
+{
+    assert((spp_is_aligned(chunk2mem(p))) || (p->_head == FENCEPOST_HEAD));
+    assert(ok_address(p));
+}
+
+// Check properties of top chunk
+void malloc_state::do_check_top_chunk(mchunkptr p) const
+{
+    msegmentptr sp = segment_holding((char*)p);
+    size_t  sz = p->_head & ~INUSE_BITS; // third-lowest bit can be set!
+    assert(sp != 0);
+    assert((spp_is_aligned(chunk2mem(p))) || (p->_head == FENCEPOST_HEAD));
+    assert(ok_address(p));
+    assert(sz == _topsize);
+    assert(sz > 0);
+    assert(sz == ((sp->_base + sp->_size) - (char*)p) - top_foot_size());
+    assert(p->pinuse());
+    assert(!p->chunk_plus_offset(sz)->pinuse());
+}
+
+// Check properties of (inuse) mmapped chunks
+void malloc_state::do_check_mmapped_chunk(mchunkptr p) const
+{
+    size_t  sz = p->chunksize();
+    size_t len = (sz + (p->_prev_foot) + SPP_MMAP_FOOT_PAD);
+    assert(p->is_mmapped());
+    assert(use_mmap());
+    assert((spp_is_aligned(chunk2mem(p))) || (p->_head == FENCEPOST_HEAD));
+    assert(ok_address(p));
+    assert(!is_small(sz));
+    assert((len & (mparams._page_size - 1)) == 0);
+    assert(p->chunk_plus_offset(sz)->_head == FENCEPOST_HEAD);
+    assert(p->chunk_plus_offset(sz + sizeof(size_t))->_head == 0);
+}
+
+// Check properties of inuse chunks
+void malloc_state::do_check_inuse_chunk(mchunkptr p) const
+{
+    do_check_any_chunk(p);
+    assert(p->is_inuse());
+    assert(p->next_pinuse());
+    // If not pinuse and not mmapped, previous chunk has OK offset
+    assert(p->is_mmapped() || p->pinuse() || (mchunkptr)p->prev_chunk()->next_chunk() == p);
+    if (p->is_mmapped())
+        do_check_mmapped_chunk(p);
+}
+
+// Check properties of free chunks
+void malloc_state::do_check_free_chunk(mchunkptr p) const
+{
+    size_t sz = p->chunksize();
+    mchunkptr next = (mchunkptr)p->chunk_plus_offset(sz);
+    do_check_any_chunk(p);
+    assert(!p->is_inuse());
+    assert(!p->next_pinuse());
+    assert(!p->is_mmapped());
+    if (p != _dv && p != _top)
+    {
+        if (sz >= MIN_CHUNK_SIZE)
+        {
+            assert((sz & spp_chunk_align_mask) == 0);
+            assert(spp_is_aligned(chunk2mem(p)));
+            assert(next->_prev_foot == sz);
+            assert(p->pinuse());
+            assert(next == _top || next->is_inuse());
+            assert(p->_fd->_bk == p);
+            assert(p->_bk->_fd == p);
+        }
+        else  // markers are always of size sizeof(size_t)
+            assert(sz == sizeof(size_t));
+    }
+}
+
+// Check properties of malloced chunks at the point they are malloced
+void malloc_state::do_check_malloced_chunk(void* mem, size_t s) const
+{
+    if (mem != 0)
+    {
+        mchunkptr p = mem2chunk(mem);
+        size_t sz = p->_head & ~INUSE_BITS;
+        do_check_inuse_chunk(p);
+        assert((sz & spp_chunk_align_mask) == 0);
+        assert(sz >= MIN_CHUNK_SIZE);
+        assert(sz >= s);
+        // unless mmapped, size is less than MIN_CHUNK_SIZE more than request
+        assert(p->is_mmapped() || sz < (s + MIN_CHUNK_SIZE));
+    }
+}
+
+// Check a tree and its subtrees.
+void malloc_state::do_check_tree(tchunkptr t)
+{
+    tchunkptr head = 0;
+    tchunkptr u = t;
+    bindex_t tindex = t->_index;
+    size_t tsize = t->chunksize();
+    bindex_t idx = compute_tree_index(tsize);
+    assert(tindex == idx);
+    assert(tsize >= MIN_LARGE_SIZE);
+    assert(tsize >= minsize_for_tree_index(idx));
+    assert((idx == NTREEBINS - 1) || (tsize < minsize_for_tree_index((idx + 1))));
+
+    do
+    {
+        // traverse through chain of same-sized nodes
+        do_check_any_chunk((mchunkptr)u);
+        assert(u->_index == tindex);
+        assert(u->chunksize() == tsize);
+        assert(!u->is_inuse());
+        assert(!u->next_pinuse());
+        assert(u->_fd->_bk == u);
+        assert(u->_bk->_fd == u);
+        if (u->_parent == 0)
+        {
+            assert(u->_child[0] == 0);
+            assert(u->_child[1] == 0);
+        }
+        else
+        {
+            assert(head == 0); // only one node on chain has parent
+            head = u;
+            assert(u->_parent != u);
+            assert(u->_parent->_child[0] == u ||
+                   u->_parent->_child[1] == u ||
+                   *((tbinptr*)(u->_parent)) == u);
+            if (u->_child[0] != 0)
+            {
+                assert(u->_child[0]->_parent == u);
+                assert(u->_child[0] != u);
+                do_check_tree(u->_child[0]);
+            }
+            if (u->_child[1] != 0)
+            {
+                assert(u->_child[1]->_parent == u);
+                assert(u->_child[1] != u);
+                do_check_tree(u->_child[1]);
+            }
+            if (u->_child[0] != 0 && u->_child[1] != 0)
+                assert(u->_child[0]->chunksize() < u->_child[1]->chunksize());
+        }
+        u = u->_fd;
+    }
+    while (u != t);
+    assert(head != 0);
+}
+
+//  Check all the chunks in a treebin.
+void malloc_state::do_check_treebin(bindex_t i)
+{
+    tbinptr* tb = (tbinptr*)treebin_at(i);
+    tchunkptr t = *tb;
+    int empty = (_treemap & (1U << i)) == 0;
+    if (t == 0)
+        assert(empty);
+    if (!empty)
+        do_check_tree(t);
+}
+
+//  Check all the chunks in a smallbin.
+void malloc_state::do_check_smallbin(bindex_t i)
+{
+    sbinptr b = smallbin_at(i);
+    mchunkptr p = b->_bk;
+    unsigned int empty = (_smallmap & (1U << i)) == 0;
+    if (p == b)
+        assert(empty);
+    if (!empty)
+    {
+        for (; p != b; p = p->_bk)
+        {
+            size_t size = p->chunksize();
+            mchunkptr q;
+            // each chunk claims to be free
+            do_check_free_chunk(p);
+            // chunk belongs in bin
+            assert(small_index(size) == i);
+            assert(p->_bk == b || p->_bk->chunksize() == p->chunksize());
+            // chunk is followed by an inuse chunk
+            q = (mchunkptr)p->next_chunk();
+            if (q->_head != FENCEPOST_HEAD)
+                do_check_inuse_chunk(q);
+        }
+    }
+}
+
+// Find x in a bin. Used in other check functions.
+int malloc_state::bin_find(mchunkptr x)
+{
+    size_t size = x->chunksize();
+    if (is_small(size))
+    {
+        bindex_t sidx = small_index(size);
+        sbinptr b = smallbin_at(sidx);
+        if (smallmap_is_marked(sidx))
+        {
+            mchunkptr p = b;
+            do
+            {
+                if (p == x)
+                    return 1;
+            }
+            while ((p = p->_fd) != b);
+        }
+    }
+    else
+    {
+        bindex_t tidx = compute_tree_index(size);
+        if (treemap_is_marked(tidx))
+        {
+            tchunkptr t = *treebin_at(tidx);
+            size_t sizebits = size << leftshift_for_tree_index(tidx);
+            while (t != 0 && t->chunksize() != size)
+            {
+                t = t->_child[(sizebits >> (spp_size_t_bitsize - 1)) & 1];
+                sizebits <<= 1;
+            }
+            if (t != 0)
+            {
+                tchunkptr u = t;
+                do
+                {
+                    if (u == (tchunkptr)x)
+                        return 1;
+                }
+                while ((u = u->_fd) != t);
+            }
+        }
+    }
+    return 0;
+}
+
+// Traverse each chunk and check it; return total
+size_t malloc_state::traverse_and_check()
+{
+    size_t sum = 0;
+    if (is_initialized())
+    {
+        msegmentptr s = (msegmentptr)&_seg;
+        sum += _topsize + top_foot_size();
+        while (s != 0)
+        {
+            mchunkptr q = align_as_chunk(s->_base);
+            mchunkptr lastq = 0;
+            assert(q->pinuse());
+            while (segment_holds(s, q) &&
+                    q != _top && q->_head != FENCEPOST_HEAD)
+            {
+                sum += q->chunksize();
+                if (q->is_inuse())
+                {
+                    assert(!bin_find(q));
+                    do_check_inuse_chunk(q);
+                }
+                else
+                {
+                    assert(q == _dv || bin_find(q));
+                    assert(lastq == 0 || lastq->is_inuse()); // Not 2 consecutive free
+                    do_check_free_chunk(q);
+                }
+                lastq = q;
+                q = (mchunkptr)q->next_chunk();
+            }
+            s = s->_next;
+        }
+    }
+    return sum;
+}
+
+
+// Check all properties of malloc_state.
+void malloc_state::do_check_malloc_state()
+{
+    bindex_t i;
+    size_t total;
+    // check bins
+    for (i = 0; i < NSMALLBINS; ++i)
+        do_check_smallbin(i);
+    for (i = 0; i < NTREEBINS; ++i)
+        do_check_treebin(i);
+
+    if (_dvsize != 0)
+    {
+        // check dv chunk
+        do_check_any_chunk(_dv);
+        assert(_dvsize == _dv->chunksize());
+        assert(_dvsize >= MIN_CHUNK_SIZE);
+        assert(bin_find(_dv) == 0);
+    }
+
+    if (_top != 0)
+    {
+        // check top chunk
+        do_check_top_chunk(_top);
+        //assert(topsize == top->chunksize()); redundant
+        assert(_topsize > 0);
+        assert(bin_find(_top) == 0);
+    }
+
+    total = traverse_and_check();
+    assert(total <= _footprint);
+    assert(_footprint <= _max_footprint);
+}
+#endif // SPP_DEBUG
+
+/* ----------------------- Operations on smallbins ----------------------- */
+
+/*
+  Various forms of linking and unlinking are defined as macros.  Even
+  the ones for trees, which are very long but have very short typical
+  paths.  This is ugly but reduces reliance on inlining support of
+  compilers.
+*/
+
+// Link a free chunk into a smallbin
+void malloc_state::insert_small_chunk(mchunkptr p, size_t s)
+{
+    bindex_t I  = small_index(s);
+    mchunkptr B = smallbin_at(I);
+    mchunkptr F = B;
+    assert(s >= MIN_CHUNK_SIZE);
+    if (!smallmap_is_marked(I))
+        mark_smallmap(I);
+    else if (rtcheck(ok_address(B->_fd)))
+        F = B->_fd;
+    else
+        SPP_ABORT;
+    B->_fd = p;
+    F->_bk = p;
+    p->_fd = F;
+    p->_bk = B;
+}
+
+// Unlink a chunk from a smallbin
+void malloc_state::unlink_small_chunk(mchunkptr p, size_t s)
+{
+    mchunkptr F = p->_fd;
+    mchunkptr B = p->_bk;
+    bindex_t I = small_index(s);
+    assert(p != B);
+    assert(p != F);
+    assert(p->chunksize() == small_index2size(I));
+    if (rtcheck(F == smallbin_at(I) || (ok_address(F) && F->_bk == p)))
+    {
+        if (B == F)
+            clear_smallmap(I);
+        else if (rtcheck(B == smallbin_at(I) ||
+                         (ok_address(B) && B->_fd == p)))
+        {
+            F->_bk = B;
+            B->_fd = F;
+        }
+        else
+            SPP_ABORT;
+    }
+    else
+        SPP_ABORT;
+}
+
+// Unlink the first chunk from a smallbin
+void malloc_state::unlink_first_small_chunk(mchunkptr B, mchunkptr p, bindex_t I)
+{
+    mchunkptr F = p->_fd;
+    assert(p != B);
+    assert(p != F);
+    assert(p->chunksize() == small_index2size(I));
+    if (B == F)
+        clear_smallmap(I);
+    else if (rtcheck(ok_address(F) && F->_bk == p))
+    {
+        F->_bk = B;
+        B->_fd = F;
+    }
+    else
+        SPP_ABORT;
+}
+
+// Replace dv node, binning the old one
+// Used only when dvsize known to be small
+void malloc_state::replace_dv(mchunkptr p, size_t s)
+{
+    size_t DVS = _dvsize;
+    assert(is_small(DVS));
+    if (DVS != 0)
+    {
+        mchunkptr DV = _dv;
+        insert_small_chunk(DV, DVS);
+    }
+    _dvsize = s;
+    _dv = p;
+}
+
+/* ------------------------- Operations on trees ------------------------- */
+
+// Insert chunk into tree
+void malloc_state::insert_large_chunk(tchunkptr X, size_t s)
+{
+    tbinptr* H;
+    bindex_t I = compute_tree_index(s);
+    H = treebin_at(I);
+    X->_index = I;
+    X->_child[0] = X->_child[1] = 0;
+    if (!treemap_is_marked(I))
+    {
+        mark_treemap(I);
+        *H = X;
+        X->_parent = (tchunkptr)H;
+        X->_fd = X->_bk = X;
+    }
+    else
+    {
+        tchunkptr T = *H;
+        size_t K = s << leftshift_for_tree_index(I);
+        for (;;)
+        {
+            if (T->chunksize() != s)
+            {
+                tchunkptr* C = &(T->_child[(K >> (spp_size_t_bitsize - 1)) & 1]);
+                K <<= 1;
+                if (*C != 0)
+                    T = *C;
+                else if (rtcheck(ok_address(C)))
+                {
+                    *C = X;
+                    X->_parent = T;
+                    X->_fd = X->_bk = X;
+                    break;
+                }
+                else
+                {
+                    SPP_ABORT;
+                    break;
+                }
+            }
+            else
+            {
+                tchunkptr F = T->_fd;
+                if (rtcheck(ok_address(T) && ok_address(F)))
+                {
+                    T->_fd = F->_bk = X;
+                    X->_fd = F;
+                    X->_bk = T;
+                    X->_parent = 0;
+                    break;
+                }
+                else
+                {
+                    SPP_ABORT;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+/*
+  Unlink steps:
+
+  1. If x is a chained node, unlink it from its same-sized fd/bk links
+     and choose its bk node as its replacement.
+  2. If x was the last node of its size, but not a leaf node, it must
+     be replaced with a leaf node (not merely one with an open left or
+     right), to make sure that lefts and rights of descendents
+     correspond properly to bit masks.  We use the rightmost descendent
+     of x.  We could use any other leaf, but this is easy to locate and
+     tends to counteract removal of leftmosts elsewhere, and so keeps
+     paths shorter than minimally guaranteed.  This doesn't loop much
+     because on average a node in a tree is near the bottom.
+  3. If x is the base of a chain (i.e., has parent links) relink
+     x's parent and children to x's replacement (or null if none).
+*/
+
+void malloc_state::unlink_large_chunk(tchunkptr X)
+{
+    tchunkptr XP = X->_parent;
+    tchunkptr R;
+    if (X->_bk != X)
+    {
+        tchunkptr F = X->_fd;
+        R = X->_bk;
+        if (rtcheck(ok_address(F) && F->_bk == X && R->_fd == X))
+        {
+            F->_bk = R;
+            R->_fd = F;
+        }
+        else
+            SPP_ABORT;
+    }
+    else
+    {
+        tchunkptr* RP;
+        if (((R = *(RP = &(X->_child[1]))) != 0) ||
+                ((R = *(RP = &(X->_child[0]))) != 0))
+        {
+            tchunkptr* CP;
+            while ((*(CP = &(R->_child[1])) != 0) ||
+                    (*(CP = &(R->_child[0])) != 0))
+                R = *(RP = CP);
+            if (rtcheck(ok_address(RP)))
+                *RP = 0;
+            else
+                SPP_ABORT;
+        }
+    }
+    if (XP != 0)
+    {
+        tbinptr* H = treebin_at(X->_index);
+        if (X == *H)
+        {
+            if ((*H = R) == 0)
+                clear_treemap(X->_index);
+        }
+        else if (rtcheck(ok_address(XP)))
+        {
+            if (XP->_child[0] == X)
+                XP->_child[0] = R;
+            else
+                XP->_child[1] = R;
+        }
+        else
+            SPP_ABORT;
+        if (R != 0)
+        {
+            if (rtcheck(ok_address(R)))
+            {
+                tchunkptr C0, C1;
+                R->_parent = XP;
+                if ((C0 = X->_child[0]) != 0)
+                {
+                    if (rtcheck(ok_address(C0)))
+                    {
+                        R->_child[0] = C0;
+                        C0->_parent = R;
+                    }
+                    else
+                        SPP_ABORT;
+                }
+                if ((C1 = X->_child[1]) != 0)
+                {
+                    if (rtcheck(ok_address(C1)))
+                    {
+                        R->_child[1] = C1;
+                        C1->_parent = R;
+                    }
+                    else
+                        SPP_ABORT;
+                }
+            }
+            else
+                SPP_ABORT;
+        }
+    }
+}
+
+// Relays to large vs small bin operations
+
+void malloc_state::insert_chunk(mchunkptr p, size_t s)
+{
+    if (is_small(s))
+        insert_small_chunk(p, s);
+    else
+    {
+        tchunkptr tp = (tchunkptr)(p);
+        insert_large_chunk(tp, s);
+    }
+}
+
+void malloc_state::unlink_chunk(mchunkptr p, size_t s)
+{
+    if (is_small(s))
+        unlink_small_chunk(p, s);
+    else
+    {
+        tchunkptr tp = (tchunkptr)(p);
+        unlink_large_chunk(tp);
+    }
+}
+
+
+/* -----------------------  Direct-mmapping chunks ----------------------- */
+
+/*
+  Directly mmapped chunks are set up with an offset to the start of
+  the mmapped region stored in the prev_foot field of the chunk. This
+  allows reconstruction of the required argument to MUNMAP when freed,
+  and also allows adjustment of the returned chunk to meet alignment
+  requirements (especially in memalign).
+*/
+
+// Malloc using mmap
+void* malloc_state::mmap_alloc(size_t nb)
+{
+    size_t mmsize = mmap_align(nb + 6 * sizeof(size_t) + spp_chunk_align_mask);
+    if (_footprint_limit != 0)
+    {
+        size_t fp = _footprint + mmsize;
+        if (fp <= _footprint || fp > _footprint_limit)
+            return 0;
+    }
+    if (mmsize > nb)
+    {
+        // Check for wrap around 0
+        char* mm = (char*)(SPP_CALL_DIRECT_MMAP(mmsize));
+        if (mm != cmfail)
+        {
+            size_t offset = align_offset(chunk2mem(mm));
+            size_t psize = mmsize - offset - SPP_MMAP_FOOT_PAD;
+            mchunkptr p = (mchunkptr)(mm + offset);
+            p->_prev_foot = offset;
+            p->_head = psize;
+            mark_inuse_foot(p, psize);
+            p->chunk_plus_offset(psize)->_head = FENCEPOST_HEAD;
+            p->chunk_plus_offset(psize + sizeof(size_t))->_head = 0;
+
+            if (_least_addr == 0 || mm < _least_addr)
+                _least_addr = mm;
+            if ((_footprint += mmsize) > _max_footprint)
+                _max_footprint = _footprint;
+            assert(spp_is_aligned(chunk2mem(p)));
+            check_mmapped_chunk(p);
+            return chunk2mem(p);
+        }
+    }
+    return 0;
+}
+
+// Realloc using mmap
+mchunkptr malloc_state::mmap_resize(mchunkptr oldp, size_t nb, int flags)
+{
+    size_t oldsize = oldp->chunksize();
+    (void)flags;      // placate people compiling -Wunused
+    if (is_small(nb)) // Can't shrink mmap regions below small size
+        return 0;
+
+    // Keep old chunk if big enough but not too big
+    if (oldsize >= nb + sizeof(size_t) &&
+            (oldsize - nb) <= (mparams._granularity << 1))
+        return oldp;
+    else
+    {
+        size_t offset = oldp->_prev_foot;
+        size_t oldmmsize = oldsize + offset + SPP_MMAP_FOOT_PAD;
+        size_t newmmsize = mmap_align(nb + 6 * sizeof(size_t) + spp_chunk_align_mask);
+        char* cp = (char*)SPP_CALL_MREMAP((char*)oldp - offset,
+                                      oldmmsize, newmmsize, flags);
+        if (cp != cmfail)
+        {
+            mchunkptr newp = (mchunkptr)(cp + offset);
+            size_t psize = newmmsize - offset - SPP_MMAP_FOOT_PAD;
+            newp->_head = psize;
+            mark_inuse_foot(newp, psize);
+            newp->chunk_plus_offset(psize)->_head = FENCEPOST_HEAD;
+            newp->chunk_plus_offset(psize + sizeof(size_t))->_head = 0;
+
+            if (cp < _least_addr)
+                _least_addr = cp;
+            if ((_footprint += newmmsize - oldmmsize) > _max_footprint)
+                _max_footprint = _footprint;
+            check_mmapped_chunk(newp);
+            return newp;
+        }
+    }
+    return 0;
+}
+
+
+/* -------------------------- mspace management -------------------------- */
+
+// Initialize top chunk and its size
+void malloc_state::init_top(mchunkptr p, size_t psize)
+{
+    // Ensure alignment
+    size_t offset = align_offset(chunk2mem(p));
+    p = (mchunkptr)((char*)p + offset);
+    psize -= offset;
+
+    _top = p;
+    _topsize = psize;
+    p->_head = psize | PINUSE_BIT;
+    // set size of fake trailing chunk holding overhead space only once
+    p->chunk_plus_offset(psize)->_head = top_foot_size();
+    _trim_check = mparams._trim_threshold; // reset on each update
+}
+
+// Initialize bins for a new mstate that is otherwise zeroed out
+void malloc_state::init_bins()
+{
+    // Establish circular links for smallbins
+    bindex_t i;
+    for (i = 0; i < NSMALLBINS; ++i)
+    {
+        sbinptr bin = smallbin_at(i);
+        bin->_fd = bin->_bk = bin;
+    }
+}
+
+#if SPP_PROCEED_ON_ERROR
+
+// default corruption action
+void malloc_state::reset_on_error()
+{
+    int i;
+    ++malloc_corruption_error_count;
+    // Reinitialize fields to forget about all memory
+    _smallmap = _treemap = 0;
+    _dvsize = _topsize = 0;
+    _seg._base = 0;
+    _seg._size = 0;
+    _seg._next = 0;
+    _top = _dv = 0;
+    for (i = 0; i < NTREEBINS; ++i)
+        *treebin_at(i) = 0;
+    init_bins();
+}
+#endif
+
+/* Allocate chunk and prepend remainder with chunk in successor base. */
+void* malloc_state::prepend_alloc(char* newbase, char* oldbase, size_t nb)
+{
+    mchunkptr p = align_as_chunk(newbase);
+    mchunkptr oldfirst = align_as_chunk(oldbase);
+    size_t psize = (char*)oldfirst - (char*)p;
+    mchunkptr q = (mchunkptr)p->chunk_plus_offset(nb);
+    size_t qsize = psize - nb;
+    set_size_and_pinuse_of_inuse_chunk(p, nb);
+
+    assert((char*)oldfirst > (char*)q);
+    assert(oldfirst->pinuse());
+    assert(qsize >= MIN_CHUNK_SIZE);
+
+    // consolidate remainder with first chunk of old base
+    if (oldfirst == _top)
+    {
+        size_t tsize = _topsize += qsize;
+        _top = q;
+        q->_head = tsize | PINUSE_BIT;
+        check_top_chunk(q);
+    }
+    else if (oldfirst == _dv)
+    {
+        size_t dsize = _dvsize += qsize;
+        _dv = q;
+        q->set_size_and_pinuse_of_free_chunk(dsize);
+    }
+    else
+    {
+        if (!oldfirst->is_inuse())
+        {
+            size_t nsize = oldfirst->chunksize();
+            unlink_chunk(oldfirst, nsize);
+            oldfirst = (mchunkptr)oldfirst->chunk_plus_offset(nsize);
+            qsize += nsize;
+        }
+        q->set_free_with_pinuse(qsize, oldfirst);
+        insert_chunk(q, qsize);
+        check_free_chunk(q);
+    }
+
+    check_malloced_chunk(chunk2mem(p), nb);
+    return chunk2mem(p);
+}
+
+// Add a segment to hold a new noncontiguous region
+void malloc_state::add_segment(char* tbase, size_t tsize, flag_t mmapped)
+{
+    // Determine locations and sizes of segment, fenceposts, old top
+    char* old_top = (char*)_top;
+    msegmentptr oldsp = segment_holding(old_top);
+    char* old_end = oldsp->_base + oldsp->_size;
+    size_t ssize = pad_request(sizeof(struct malloc_segment));
+    char* rawsp = old_end - (ssize + 4 * sizeof(size_t) + spp_chunk_align_mask);
+    size_t offset = align_offset(chunk2mem(rawsp));
+    char* asp = rawsp + offset;
+    char* csp = (asp < (old_top + MIN_CHUNK_SIZE)) ? old_top : asp;
+    mchunkptr sp = (mchunkptr)csp;
+    msegmentptr ss = (msegmentptr)(chunk2mem(sp));
+    mchunkptr tnext = (mchunkptr)sp->chunk_plus_offset(ssize);
+    mchunkptr p = tnext;
+    int nfences = 0;
+
+    // reset top to new space
+    init_top((mchunkptr)tbase, tsize - top_foot_size());
+
+    // Set up segment record
+    assert(spp_is_aligned(ss));
+    set_size_and_pinuse_of_inuse_chunk(sp, ssize);
+    *ss = _seg; // Push current record
+    _seg._base = tbase;
+    _seg._size = tsize;
+    _seg._sflags = mmapped;
+    _seg._next = ss;
+
+    // Insert trailing fenceposts
+    for (;;)
+    {
+        mchunkptr nextp = (mchunkptr)p->chunk_plus_offset(sizeof(size_t));
+        p->_head = FENCEPOST_HEAD;
+        ++nfences;
+        if ((char*)(&(nextp->_head)) < old_end)
+            p = nextp;
+        else
+            break;
+    }
+    assert(nfences >= 2);
+
+    // Insert the rest of old top into a bin as an ordinary free chunk
+    if (csp != old_top)
+    {
+        mchunkptr q = (mchunkptr)old_top;
+        size_t psize = csp - old_top;
+        mchunkptr tn = (mchunkptr)q->chunk_plus_offset(psize);
+        q->set_free_with_pinuse(psize, tn);
+        insert_chunk(q, psize);
+    }
+
+    check_top_chunk(_top);
+}
+
+/* -------------------------- System allocation -------------------------- */
+
+// Get memory from system using MMAP
+void* malloc_state::sys_alloc(size_t nb)
+{
+    char* tbase = cmfail;
+    size_t tsize = 0;
+    flag_t mmap_flag = 0;
+    size_t asize; // allocation size
+
+    mparams.ensure_initialization();
+
+    // Directly map large chunks, but only if already initialized
+    if (use_mmap() && nb >= mparams._mmap_threshold && _topsize != 0)
+    {
+        void* mem = mmap_alloc(nb);
+        if (mem != 0)
+            return mem;
+    }
+
+    asize = mparams.granularity_align(nb + sys_alloc_padding());
+    if (asize <= nb)
+        return 0; // wraparound
+    if (_footprint_limit != 0)
+    {
+        size_t fp = _footprint + asize;
+        if (fp <= _footprint || fp > _footprint_limit)
+            return 0;
+    }
+
+    /*
+      Try getting memory with a call to MMAP new space (disabled if not SPP_HAVE_MMAP).
+      We need to request enough bytes from system to ensure
+      we can malloc nb bytes upon success, so pad with enough space for
+      top_foot, plus alignment-pad to make sure we don't lose bytes if
+      not on boundary, and round this up to a granularity unit.
+    */
+
+    if (SPP_HAVE_MMAP && tbase == cmfail)
+    {
+        // Try MMAP
+        char* mp = (char*)(SPP_CALL_MMAP(asize));
+        if (mp != cmfail)
+        {
+            tbase = mp;
+            tsize = asize;
+            mmap_flag = USE_MMAP_BIT;
+        }
+    }
+
+    if (tbase != cmfail)
+    {
+
+        if ((_footprint += tsize) > _max_footprint)
+            _max_footprint = _footprint;
+
+        if (!is_initialized())
+        {
+            // first-time initialization
+            if (_least_addr == 0 || tbase < _least_addr)
+                _least_addr = tbase;
+            _seg._base = tbase;
+            _seg._size = tsize;
+            _seg._sflags = mmap_flag;
+            _magic = mparams._magic;
+            _release_checks = SPP_MAX_RELEASE_CHECK_RATE;
+            init_bins();
+
+            // Offset top by embedded malloc_state
+            mchunkptr mn = (mchunkptr)mem2chunk(this)->next_chunk();
+            init_top(mn, (size_t)((tbase + tsize) - (char*)mn) - top_foot_size());
+        }
+
+        else
+        {
+            // Try to merge with an existing segment
+            msegmentptr sp = &_seg;
+            // Only consider most recent segment if traversal suppressed
+            while (sp != 0 && tbase != sp->_base + sp->_size)
+                sp = (SPP_NO_SEGMENT_TRAVERSAL) ? 0 : sp->_next;
+            if (sp != 0 &&
+                    !sp->is_extern_segment() &&
+                    (sp->_sflags & USE_MMAP_BIT) == mmap_flag &&
+                    segment_holds(sp, _top))
+            {
+                // append
+                sp->_size += tsize;
+                init_top(_top, _topsize + tsize);
+            }
+            else
+            {
+                if (tbase < _least_addr)
+                    _least_addr = tbase;
+                sp = &_seg;
+                while (sp != 0 && sp->_base != tbase + tsize)
+                    sp = (SPP_NO_SEGMENT_TRAVERSAL) ? 0 : sp->_next;
+                if (sp != 0 &&
+                        !sp->is_extern_segment() &&
+                        (sp->_sflags & USE_MMAP_BIT) == mmap_flag)
+                {
+                    char* oldbase = sp->_base;
+                    sp->_base = tbase;
+                    sp->_size += tsize;
+                    return prepend_alloc(tbase, oldbase, nb);
+                }
+                else
+                    add_segment(tbase, tsize, mmap_flag);
+            }
+        }
+
+        if (nb < _topsize)
+        {
+            // Allocate from new or extended top space
+            size_t rsize = _topsize -= nb;
+            mchunkptr p = _top;
+            mchunkptr r = _top = (mchunkptr)p->chunk_plus_offset(nb);
+            r->_head = rsize | PINUSE_BIT;
+            set_size_and_pinuse_of_inuse_chunk(p, nb);
+            check_top_chunk(_top);
+            check_malloced_chunk(chunk2mem(p), nb);
+            return chunk2mem(p);
+        }
+    }
+
+    SPP_MALLOC_FAILURE_ACTION;
+    return 0;
+}
+
+/* -----------------------  system deallocation -------------------------- */
+
+// Unmap and unlink any mmapped segments that don't contain used chunks
+size_t malloc_state::release_unused_segments()
+{
+    size_t released = 0;
+    int nsegs = 0;
+    msegmentptr pred = &_seg;
+    msegmentptr sp = pred->_next;
+    while (sp != 0)
+    {
+        char* base = sp->_base;
+        size_t size = sp->_size;
+        msegmentptr next = sp->_next;
+        ++nsegs;
+        if (sp->is_mmapped_segment() && !sp->is_extern_segment())
+        {
+            mchunkptr p = align_as_chunk(base);
+            size_t psize = p->chunksize();
+            // Can unmap if first chunk holds entire segment and not pinned
+            if (!p->is_inuse() && (char*)p + psize >= base + size - top_foot_size())
+            {
+                tchunkptr tp = (tchunkptr)p;
+                assert(segment_holds(sp, p));
+                if (p == _dv)
+                {
+                    _dv = 0;
+                    _dvsize = 0;
+                }
+                else
+                    unlink_large_chunk(tp);
+                if (SPP_CALL_MUNMAP(base, size) == 0)
+                {
+                    released += size;
+                    _footprint -= size;
+                    // unlink obsoleted record
+                    sp = pred;
+                    sp->_next = next;
+                }
+                else
+                {
+                    // back out if cannot unmap
+                    insert_large_chunk(tp, psize);
+                }
+            }
+        }
+        if (SPP_NO_SEGMENT_TRAVERSAL) // scan only first segment
+            break;
+        pred = sp;
+        sp = next;
+    }
+    // Reset check counter
+    _release_checks = (((size_t) nsegs > (size_t) SPP_MAX_RELEASE_CHECK_RATE) ?
+                       (size_t) nsegs : (size_t) SPP_MAX_RELEASE_CHECK_RATE);
+    return released;
+}
+
+int malloc_state::sys_trim(size_t pad)
+{
+    size_t released = 0;
+    mparams.ensure_initialization();
+    if (pad < MAX_REQUEST && is_initialized())
+    {
+        pad += top_foot_size(); // ensure enough room for segment overhead
+
+        if (_topsize > pad)
+        {
+            // Shrink top space in _granularity - size units, keeping at least one
+            size_t unit = mparams._granularity;
+            size_t extra = ((_topsize - pad + (unit - 1)) / unit -
+                            1) * unit;
+            msegmentptr sp = segment_holding((char*)_top);
+
+            if (!sp->is_extern_segment())
+            {
+                if (sp->is_mmapped_segment())
+                {
+                    if (SPP_HAVE_MMAP &&
+                        sp->_size >= extra &&
+                        !has_segment_link(sp))
+                    {
+                        // can't shrink if pinned
+                        size_t newsize = sp->_size - extra;
+                        (void)newsize; // placate people compiling -Wunused-variable
+                        // Prefer mremap, fall back to munmap
+                        if ((SPP_CALL_MREMAP(sp->_base, sp->_size, newsize, 0) != mfail) ||
+                            (SPP_CALL_MUNMAP(sp->_base + newsize, extra) == 0))
+                            released = extra;
+                    }
+                }
+            }
+
+            if (released != 0)
+            {
+                sp->_size -= released;
+                _footprint -= released;
+                init_top(_top, _topsize - released);
+                check_top_chunk(_top);
+            }
+        }
+
+        // Unmap any unused mmapped segments
+        if (SPP_HAVE_MMAP)
+            released += release_unused_segments();
+
+        // On failure, disable autotrim to avoid repeated failed future calls
+        if (released == 0 && _topsize > _trim_check)
+            _trim_check = spp_max_size_t;
+    }
+
+    return (released != 0) ? 1 : 0;
+}
+
+/* Consolidate and bin a chunk. Differs from exported versions
+   of free mainly in that the chunk need not be marked as inuse.
+*/
+void malloc_state::dispose_chunk(mchunkptr p, size_t psize)
+{
+    mchunkptr next = (mchunkptr)p->chunk_plus_offset(psize);
+    if (!p->pinuse())
+    {
+        mchunkptr prev;
+        size_t prevsize = p->_prev_foot;
+        if (p->is_mmapped())
+        {
+            psize += prevsize + SPP_MMAP_FOOT_PAD;
+            if (SPP_CALL_MUNMAP((char*)p - prevsize, psize) == 0)
+                _footprint -= psize;
+            return;
+        }
+        prev = (mchunkptr)p->chunk_minus_offset(prevsize);
+        psize += prevsize;
+        p = prev;
+        if (rtcheck(ok_address(prev)))
+        {
+            // consolidate backward
+            if (p != _dv)
+                unlink_chunk(p, prevsize);
+            else if ((next->_head & INUSE_BITS) == INUSE_BITS)
+            {
+                _dvsize = psize;
+                p->set_free_with_pinuse(psize, next);
+                return;
+            }
+        }
+        else
+        {
+            SPP_ABORT;
+            return;
+        }
+    }
+    if (rtcheck(ok_address(next)))
+    {
+        if (!next->cinuse())
+        {
+            // consolidate forward
+            if (next == _top)
+            {
+                size_t tsize = _topsize += psize;
+                _top = p;
+                p->_head = tsize | PINUSE_BIT;
+                if (p == _dv)
+                {
+                    _dv = 0;
+                    _dvsize = 0;
+                }
+                return;
+            }
+            else if (next == _dv)
+            {
+                size_t dsize = _dvsize += psize;
+                _dv = p;
+                p->set_size_and_pinuse_of_free_chunk(dsize);
+                return;
+            }
+            else
+            {
+                size_t nsize = next->chunksize();
+                psize += nsize;
+                unlink_chunk(next, nsize);
+                p->set_size_and_pinuse_of_free_chunk(psize);
+                if (p == _dv)
+                {
+                    _dvsize = psize;
+                    return;
+                }
+            }
+        }
+        else
+            p->set_free_with_pinuse(psize, next);
+        insert_chunk(p, psize);
+    }
+    else
+        SPP_ABORT;
+}
+
+/* ---------------------------- malloc --------------------------- */
+
+// allocate a large request from the best fitting chunk in a treebin
+void* malloc_state::tmalloc_large(size_t nb)
+{
+    tchunkptr v = 0;
+    size_t rsize = -nb; // Unsigned negation
+    tchunkptr t;
+    bindex_t idx = compute_tree_index(nb);
+    if ((t = *treebin_at(idx)) != 0)
+    {
+        // Traverse tree for this bin looking for node with size == nb
+        size_t sizebits = nb << leftshift_for_tree_index(idx);
+        tchunkptr rst = 0;  // The deepest untaken right subtree
+        for (;;)
+        {
+            tchunkptr rt;
+            size_t trem = t->chunksize() - nb;
+            if (trem < rsize)
+            {
+                v = t;
+                if ((rsize = trem) == 0)
+                    break;
+            }
+            rt = t->_child[1];
+            t = t->_child[(sizebits >> (spp_size_t_bitsize - 1)) & 1];
+            if (rt != 0 && rt != t)
+                rst = rt;
+            if (t == 0)
+            {
+                t = rst; // set t to least subtree holding sizes > nb
+                break;
+            }
+            sizebits <<= 1;
+        }
+    }
+    if (t == 0 && v == 0)
+    {
+        // set t to root of next non-empty treebin
+        binmap_t leftbits = left_bits(idx2bit(idx)) & _treemap;
+        if (leftbits != 0)
+        {
+            binmap_t leastbit = least_bit(leftbits);
+            bindex_t i = compute_bit2idx(leastbit);
+            t = *treebin_at(i);
+        }
+    }
+
+    while (t != 0)
+    {
+        // find smallest of tree or subtree
+        size_t trem = t->chunksize() - nb;
+        if (trem < rsize)
+        {
+            rsize = trem;
+            v = t;
+        }
+        t = t->leftmost_child();
+    }
+
+    //  If dv is a better fit, return 0 so malloc will use it
+    if (v != 0 && rsize < (size_t)(_dvsize - nb))
+    {
+        if (rtcheck(ok_address(v)))
+        {
+            // split
+            mchunkptr r = (mchunkptr)v->chunk_plus_offset(nb);
+            assert(v->chunksize() == rsize + nb);
+            if (rtcheck(ok_next(v, r)))
+            {
+                unlink_large_chunk(v);
+                if (rsize < MIN_CHUNK_SIZE)
+                    set_inuse_and_pinuse(v, (rsize + nb));
+                else
+                {
+                    set_size_and_pinuse_of_inuse_chunk(v, nb);
+                    r->set_size_and_pinuse_of_free_chunk(rsize);
+                    insert_chunk(r, rsize);
+                }
+                return chunk2mem(v);
+            }
+        }
+        SPP_ABORT;
+    }
+    return 0;
+}
+
+// allocate a small request from the best fitting chunk in a treebin
+void* malloc_state::tmalloc_small(size_t nb)
+{
+    tchunkptr t, v;
+    size_t rsize;
+    binmap_t leastbit = least_bit(_treemap);
+    bindex_t i = compute_bit2idx(leastbit);
+    v = t = *treebin_at(i);
+    rsize = t->chunksize() - nb;
+
+    while ((t = t->leftmost_child()) != 0)
+    {
+        size_t trem = t->chunksize() - nb;
+        if (trem < rsize)
+        {
+            rsize = trem;
+            v = t;
+        }
+    }
+
+    if (rtcheck(ok_address(v)))
+    {
+        mchunkptr r = (mchunkptr)v->chunk_plus_offset(nb);
+        assert(v->chunksize() == rsize + nb);
+        if (rtcheck(ok_next(v, r)))
+        {
+            unlink_large_chunk(v);
+            if (rsize < MIN_CHUNK_SIZE)
+                set_inuse_and_pinuse(v, (rsize + nb));
+            else
+            {
+                set_size_and_pinuse_of_inuse_chunk(v, nb);
+                r->set_size_and_pinuse_of_free_chunk(rsize);
+                replace_dv(r, rsize);
+            }
+            return chunk2mem(v);
+        }
+    }
+
+    SPP_ABORT;
+    return 0;
+}
+
+/* ---------------------------- malloc --------------------------- */
+
+void* malloc_state::_malloc(size_t bytes)
+{
+    if (1)
+    {
+        void* mem;
+        size_t nb;
+        if (bytes <= MAX_SMALL_REQUEST)
+        {
+            bindex_t idx;
+            binmap_t smallbits;
+            nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
+            idx = small_index(nb);
+            smallbits = _smallmap >> idx;
+
+            if ((smallbits & 0x3U) != 0)
+            {
+                // Remainderless fit to a smallbin.
+                mchunkptr b, p;
+                idx += ~smallbits & 1;       // Uses next bin if idx empty
+                b = smallbin_at(idx);
+                p = b->_fd;
+                assert(p->chunksize() == small_index2size(idx));
+                unlink_first_small_chunk(b, p, idx);
+                set_inuse_and_pinuse(p, small_index2size(idx));
+                mem = chunk2mem(p);
+                check_malloced_chunk(mem, nb);
+                goto postaction;
+            }
+
+            else if (nb > _dvsize)
+            {
+                if (smallbits != 0)
+                {
+                    // Use chunk in next nonempty smallbin
+                    mchunkptr b, p, r;
+                    size_t rsize;
+                    binmap_t leftbits = (smallbits << idx) & left_bits(malloc_state::idx2bit(idx));
+                    binmap_t leastbit = least_bit(leftbits);
+                    bindex_t i = compute_bit2idx(leastbit);
+                    b = smallbin_at(i);
+                    p = b->_fd;
+                    assert(p->chunksize() == small_index2size(i));
+                    unlink_first_small_chunk(b, p, i);
+                    rsize = small_index2size(i) - nb;
+                    // Fit here cannot be remainderless if 4byte sizes
+                    if (sizeof(size_t) != 4 && rsize < MIN_CHUNK_SIZE)
+                        set_inuse_and_pinuse(p, small_index2size(i));
+                    else
+                    {
+                        set_size_and_pinuse_of_inuse_chunk(p, nb);
+                        r = (mchunkptr)p->chunk_plus_offset(nb);
+                        r->set_size_and_pinuse_of_free_chunk(rsize);
+                        replace_dv(r, rsize);
+                    }
+                    mem = chunk2mem(p);
+                    check_malloced_chunk(mem, nb);
+                    goto postaction;
+                }
+
+                else if (_treemap != 0 && (mem = tmalloc_small(nb)) != 0)
+                {
+                    check_malloced_chunk(mem, nb);
+                    goto postaction;
+                }
+            }
+        }
+        else if (bytes >= MAX_REQUEST)
+            nb = spp_max_size_t; // Too big to allocate. Force failure (in sys alloc)
+        else
+        {
+            nb = pad_request(bytes);
+            if (_treemap != 0 && (mem = tmalloc_large(nb)) != 0)
+            {
+                check_malloced_chunk(mem, nb);
+                goto postaction;
+            }
+        }
+
+        if (nb <= _dvsize)
+        {
+            size_t rsize = _dvsize - nb;
+            mchunkptr p = _dv;
+            if (rsize >= MIN_CHUNK_SIZE)
+            {
+                // split dv
+                mchunkptr r = _dv = (mchunkptr)p->chunk_plus_offset(nb);
+                _dvsize = rsize;
+                r->set_size_and_pinuse_of_free_chunk(rsize);
+                set_size_and_pinuse_of_inuse_chunk(p, nb);
+            }
+            else   // exhaust dv
+            {
+                size_t dvs = _dvsize;
+                _dvsize = 0;
+                _dv = 0;
+                set_inuse_and_pinuse(p, dvs);
+            }
+            mem = chunk2mem(p);
+            check_malloced_chunk(mem, nb);
+            goto postaction;
+        }
+
+        else if (nb < _topsize)
+        {
+            // Split top
+            size_t rsize = _topsize -= nb;
+            mchunkptr p = _top;
+            mchunkptr r = _top = (mchunkptr)p->chunk_plus_offset(nb);
+            r->_head = rsize | PINUSE_BIT;
+            set_size_and_pinuse_of_inuse_chunk(p, nb);
+            mem = chunk2mem(p);
+            check_top_chunk(_top);
+            check_malloced_chunk(mem, nb);
+            goto postaction;
+        }
+
+        mem = sys_alloc(nb);
+
+postaction:
+        return mem;
+    }
+
+    return 0;
+}
+
+/* ---------------------------- free --------------------------- */
+
+void malloc_state::_free(mchunkptr p)
+{
+    if (1)
+    {
+        check_inuse_chunk(p);
+        if (rtcheck(ok_address(p) && ok_inuse(p)))
+        {
+            size_t psize = p->chunksize();
+            mchunkptr next = (mchunkptr)p->chunk_plus_offset(psize);
+            if (!p->pinuse())
+            {
+                size_t prevsize = p->_prev_foot;
+                if (p->is_mmapped())
+                {
+                    psize += prevsize + SPP_MMAP_FOOT_PAD;
+                    if (SPP_CALL_MUNMAP((char*)p - prevsize, psize) == 0)
+                        _footprint -= psize;
+                    goto postaction;
+                }
+                else
+                {
+                    mchunkptr prev = (mchunkptr)p->chunk_minus_offset(prevsize);
+                    psize += prevsize;
+                    p = prev;
+                    if (rtcheck(ok_address(prev)))
+                    {
+                        // consolidate backward
+                        if (p != _dv)
+                            unlink_chunk(p, prevsize);
+                        else if ((next->_head & INUSE_BITS) == INUSE_BITS)
+                        {
+                            _dvsize = psize;
+                            p->set_free_with_pinuse(psize, next);
+                            goto postaction;
+                        }
+                    }
+                    else
+                        goto erroraction;
+                }
+            }
+
+            if (rtcheck(ok_next(p, next) && ok_pinuse(next)))
+            {
+                if (!next->cinuse())
+                {
+                    // consolidate forward
+                    if (next == _top)
+                    {
+                        size_t tsize = _topsize += psize;
+                        _top = p;
+                        p->_head = tsize | PINUSE_BIT;
+                        if (p == _dv)
+                        {
+                            _dv = 0;
+                            _dvsize = 0;
+                        }
+                        if (should_trim(tsize))
+                            sys_trim(0);
+                        goto postaction;
+                    }
+                    else if (next == _dv)
+                    {
+                        size_t dsize = _dvsize += psize;
+                        _dv = p;
+                        p->set_size_and_pinuse_of_free_chunk(dsize);
+                        goto postaction;
+                    }
+                    else
+                    {
+                        size_t nsize = next->chunksize();
+                        psize += nsize;
+                        unlink_chunk(next, nsize);
+                        p->set_size_and_pinuse_of_free_chunk(psize);
+                        if (p == _dv)
+                        {
+                            _dvsize = psize;
+                            goto postaction;
+                        }
+                    }
+                }
+                else
+                    p->set_free_with_pinuse(psize, next);
+
+                if (is_small(psize))
+                {
+                    insert_small_chunk(p, psize);
+                    check_free_chunk(p);
+                }
+                else
+                {
+                    tchunkptr tp = (tchunkptr)p;
+                    insert_large_chunk(tp, psize);
+                    check_free_chunk(p);
+                    if (--_release_checks == 0)
+                        release_unused_segments();
+                }
+                goto postaction;
+            }
+        }
+erroraction:
+        SPP_USAGE_ERROR_ACTION(this, p);
+postaction:
+        ;
+    }
+}
+
+/* ------------ Internal support for realloc, memalign, etc -------------- */
+
+// Try to realloc; only in-place unless can_move true
+mchunkptr malloc_state::try_realloc_chunk(mchunkptr p, size_t nb, int can_move)
+{
+    mchunkptr newp = 0;
+    size_t oldsize = p->chunksize();
+    mchunkptr next = (mchunkptr)p->chunk_plus_offset(oldsize);
+    if (rtcheck(ok_address(p) && ok_inuse(p) &&
+                ok_next(p, next) && ok_pinuse(next)))
+    {
+        if (p->is_mmapped())
+            newp = mmap_resize(p, nb, can_move);
+        else if (oldsize >= nb)
+        {
+            // already big enough
+            size_t rsize = oldsize - nb;
+            if (rsize >= MIN_CHUNK_SIZE)
+            {
+                // split off remainder
+                mchunkptr r = (mchunkptr)p->chunk_plus_offset(nb);
+                set_inuse(p, nb);
+                set_inuse(r, rsize);
+                dispose_chunk(r, rsize);
+            }
+            newp = p;
+        }
+        else if (next == _top)
+        {
+            // extend into top
+            if (oldsize + _topsize > nb)
+            {
+                size_t newsize = oldsize + _topsize;
+                size_t newtopsize = newsize - nb;
+                mchunkptr newtop = (mchunkptr)p->chunk_plus_offset(nb);
+                set_inuse(p, nb);
+                newtop->_head = newtopsize | PINUSE_BIT;
+                _top = newtop;
+                _topsize = newtopsize;
+                newp = p;
+            }
+        }
+        else if (next == _dv)
+        {
+            // extend into dv
+            size_t dvs = _dvsize;
+            if (oldsize + dvs >= nb)
+            {
+                size_t dsize = oldsize + dvs - nb;
+                if (dsize >= MIN_CHUNK_SIZE)
+                {
+                    mchunkptr r = (mchunkptr)p->chunk_plus_offset(nb);
+                    mchunkptr n = (mchunkptr)r->chunk_plus_offset(dsize);
+                    set_inuse(p, nb);
+                    r->set_size_and_pinuse_of_free_chunk(dsize);
+                    n->clear_pinuse();
+                    _dvsize = dsize;
+                    _dv = r;
+                }
+                else
+                {
+                    // exhaust dv
+                    size_t newsize = oldsize + dvs;
+                    set_inuse(p, newsize);
+                    _dvsize = 0;
+                    _dv = 0;
+                }
+                newp = p;
+            }
+        }
+        else if (!next->cinuse())
+        {
+            // extend into next free chunk
+            size_t nextsize = next->chunksize();
+            if (oldsize + nextsize >= nb)
+            {
+                size_t rsize = oldsize + nextsize - nb;
+                unlink_chunk(next, nextsize);
+                if (rsize < MIN_CHUNK_SIZE)
+                {
+                    size_t newsize = oldsize + nextsize;
+                    set_inuse(p, newsize);
+                }
+                else
+                {
+                    mchunkptr r = (mchunkptr)p->chunk_plus_offset(nb);
+                    set_inuse(p, nb);
+                    set_inuse(r, rsize);
+                    dispose_chunk(r, rsize);
+                }
+                newp = p;
+            }
+        }
+    }
+    else
+        SPP_USAGE_ERROR_ACTION(m, chunk2mem(p));
+    return newp;
+}
+
+void* malloc_state::internal_memalign(size_t alignment, size_t bytes)
+{
+    void* mem = 0;
+    if (alignment < MIN_CHUNK_SIZE) // must be at least a minimum chunk size
+        alignment = MIN_CHUNK_SIZE;
+    if ((alignment & (alignment - 1)) != 0)
+    {
+        // Ensure a power of 2
+        size_t a = SPP_MALLOC_ALIGNMENT << 1;
+        while (a < alignment)
+            a <<= 1;
+        alignment = a;
+    }
+    if (bytes >= MAX_REQUEST - alignment)
+        SPP_MALLOC_FAILURE_ACTION;
+    else
+    {
+        size_t nb = request2size(bytes);
+        size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
+        mem = internal_malloc(req);
+        if (mem != 0)
+        {
+            mchunkptr p = mem2chunk(mem);
+            if ((((size_t)(mem)) & (alignment - 1)) != 0)
+            {
+                // misaligned
+                /*
+                  Find an aligned spot inside chunk.  Since we need to give
+                  back leading space in a chunk of at least MIN_CHUNK_SIZE, if
+                  the first calculation places us at a spot with less than
+                  MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
+                  We've allocated enough total room so that this is always
+                  possible.
+                */
+                char* br = (char*)mem2chunk((void *)(((size_t)((char*)mem + alignment - 1)) &
+                                                     -alignment));
+                char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE) ?
+                            br : br + alignment;
+                mchunkptr newp = (mchunkptr)pos;
+                size_t leadsize = pos - (char*)(p);
+                size_t newsize = p->chunksize() - leadsize;
+
+                if (p->is_mmapped())
+                {
+                    // For mmapped chunks, just adjust offset
+                    newp->_prev_foot = p->_prev_foot + leadsize;
+                    newp->_head = newsize;
+                }
+                else
+                {
+                    // Otherwise, give back leader, use the rest
+                    set_inuse(newp, newsize);
+                    set_inuse(p, leadsize);
+                    dispose_chunk(p, leadsize);
+                }
+                p = newp;
+            }
+
+            // Give back spare room at the end
+            if (!p->is_mmapped())
+            {
+                size_t size = p->chunksize();
+                if (size > nb + MIN_CHUNK_SIZE)
+                {
+                    size_t remainder_size = size - nb;
+                    mchunkptr remainder = (mchunkptr)p->chunk_plus_offset(nb);
+                    set_inuse(p, nb);
+                    set_inuse(remainder, remainder_size);
+                    dispose_chunk(remainder, remainder_size);
+                }
+            }
+
+            mem = chunk2mem(p);
+            assert(p->chunksize() >= nb);
+            assert(((size_t)mem & (alignment - 1)) == 0);
+            check_inuse_chunk(p);
+        }
+    }
+    return mem;
+}
+
+/*
+  Common support for independent_X routines, handling
+    all of the combinations that can result.
+  The opts arg has:
+    bit 0 set if all elements are same size (using sizes[0])
+    bit 1 set if elements should be zeroed
+*/
+void** malloc_state::ialloc(size_t n_elements, size_t* sizes, int opts,
+                            void* chunks[])
+{
+
+    size_t    element_size;   // chunksize of each element, if all same
+    size_t    contents_size;  // total size of elements
+    size_t    array_size;     // request size of pointer array
+    void*     mem;            // malloced aggregate space
+    mchunkptr p;              // corresponding chunk
+    size_t    remainder_size; // remaining bytes while splitting
+    void**    marray;         // either "chunks" or malloced ptr array
+    mchunkptr array_chunk;    // chunk for malloced ptr array
+    flag_t    was_enabled;    // to disable mmap
+    size_t    size;
+    size_t    i;
+
+    mparams.ensure_initialization();
+    // compute array length, if needed
+    if (chunks != 0)
+    {
+        if (n_elements == 0)
+            return chunks; // nothing to do
+        marray = chunks;
+        array_size = 0;
+    }
+    else
+    {
+        // if empty req, must still return chunk representing empty array
+        if (n_elements == 0)
+            return (void**)internal_malloc(0);
+        marray = 0;
+        array_size = request2size(n_elements * (sizeof(void*)));
+    }
+
+    // compute total element size
+    if (opts & 0x1)
+    {
+        // all-same-size
+        element_size = request2size(*sizes);
+        contents_size = n_elements * element_size;
+    }
+    else
+    {
+        // add up all the sizes
+        element_size = 0;
+        contents_size = 0;
+        for (i = 0; i != n_elements; ++i)
+            contents_size += request2size(sizes[i]);
+    }
+
+    size = contents_size + array_size;
+
+    /*
+      Allocate the aggregate chunk.  First disable direct-mmapping so
+      malloc won't use it, since we would not be able to later
+      free/realloc space internal to a segregated mmap region.
+    */
+    was_enabled = use_mmap();
+    disable_mmap();
+    mem = internal_malloc(size - CHUNK_OVERHEAD);
+    if (was_enabled)
+        enable_mmap();
+    if (mem == 0)
+        return 0;
+
+    p = mem2chunk(mem);
+    remainder_size = p->chunksize();
+
+    assert(!p->is_mmapped());
+
+    if (opts & 0x2)
+    {
+        // optionally clear the elements
+        memset((size_t*)mem, 0, remainder_size - sizeof(size_t) - array_size);
+    }
+
+    // If not provided, allocate the pointer array as final part of chunk
+    if (marray == 0)
+    {
+        size_t  array_chunk_size;
+        array_chunk = (mchunkptr)p->chunk_plus_offset(contents_size);
+        array_chunk_size = remainder_size - contents_size;
+        marray = (void**)(chunk2mem(array_chunk));
+        set_size_and_pinuse_of_inuse_chunk(array_chunk, array_chunk_size);
+        remainder_size = contents_size;
+    }
+
+    // split out elements
+    for (i = 0; ; ++i)
+    {
+        marray[i] = chunk2mem(p);
+        if (i != n_elements - 1)
+        {
+            if (element_size != 0)
+                size = element_size;
+            else
+                size = request2size(sizes[i]);
+            remainder_size -= size;
+            set_size_and_pinuse_of_inuse_chunk(p, size);
+            p = (mchunkptr)p->chunk_plus_offset(size);
+        }
+        else
+        {
+            // the final element absorbs any overallocation slop
+            set_size_and_pinuse_of_inuse_chunk(p, remainder_size);
+            break;
+        }
+    }
+
+#if SPP_DEBUG
+    if (marray != chunks)
+    {
+        // final element must have exactly exhausted chunk
+        if (element_size != 0)
+            assert(remainder_size == element_size);
+        else
+            assert(remainder_size == request2size(sizes[i]));
+        check_inuse_chunk(mem2chunk(marray));
+    }
+    for (i = 0; i != n_elements; ++i)
+        check_inuse_chunk(mem2chunk(marray[i]));
+
+#endif
+
+    return marray;
+}
+
+/* Try to free all pointers in the given array.
+   Note: this could be made faster, by delaying consolidation,
+   at the price of disabling some user integrity checks, We
+   still optimize some consolidations by combining adjacent
+   chunks before freeing, which will occur often if allocated
+   with ialloc or the array is sorted.
+*/
+size_t malloc_state::internal_bulk_free(void* array[], size_t nelem)
+{
+    size_t unfreed = 0;
+    if (1)
+    {
+        void** a;
+        void** fence = &(array[nelem]);
+        for (a = array; a != fence; ++a)
+        {
+            void* mem = *a;
+            if (mem != 0)
+            {
+                mchunkptr p = mem2chunk(mem);
+                size_t psize = p->chunksize();
+#if SPP_FOOTERS
+                if (get_mstate_for(p) != m)
+                {
+                    ++unfreed;
+                    continue;
+                }
+#endif
+                check_inuse_chunk(p);
+                *a = 0;
+                if (rtcheck(ok_address(p) && ok_inuse(p)))
+                {
+                    void ** b = a + 1; // try to merge with next chunk
+                    mchunkptr next = (mchunkptr)p->next_chunk();
+                    if (b != fence && *b == chunk2mem(next))
+                    {
+                        size_t newsize = next->chunksize() + psize;
+                        set_inuse(p, newsize);
+                        *b = chunk2mem(p);
+                    }
+                    else
+                        dispose_chunk(p, psize);
+                }
+                else
+                {
+                    SPP_ABORT;
+                    break;
+                }
+            }
+        }
+        if (should_trim(_topsize))
+            sys_trim(0);
+    }
+    return unfreed;
+}
+
+void malloc_state::init(char* tbase, size_t tsize)
+{
+    _seg._base = _least_addr = tbase;
+    _seg._size = _footprint = _max_footprint = tsize;
+    _magic    = mparams._magic;
+    _release_checks = SPP_MAX_RELEASE_CHECK_RATE;
+    _mflags   = mparams._default_mflags;
+    _extp     = 0;
+    _exts     = 0;
+    disable_contiguous();
+    init_bins();
+    mchunkptr mn = (mchunkptr)mem2chunk(this)->next_chunk();
+    init_top(mn, (size_t)((tbase + tsize) - (char*)mn) - top_foot_size());
+    check_top_chunk(_top);
+}
+
+/* Traversal */
+#if SPP_MALLOC_INSPECT_ALL
+void malloc_state::internal_inspect_all(void(*handler)(void *start, void *end,
+                                        size_t used_bytes,
+                                        void* callback_arg),
+                                        void* arg)
+{
+    if (is_initialized())
+    {
+        mchunkptr top = top;
+        msegmentptr s;
+        for (s = &seg; s != 0; s = s->next)
+        {
+            mchunkptr q = align_as_chunk(s->base);
+            while (segment_holds(s, q) && q->head != FENCEPOST_HEAD)
+            {
+                mchunkptr next = (mchunkptr)q->next_chunk();
+                size_t sz = q->chunksize();
+                size_t used;
+                void* start;
+                if (q->is_inuse())
+                {
+                    used = sz - CHUNK_OVERHEAD; // must not be mmapped
+                    start = chunk2mem(q);
+                }
+                else
+                {
+                    used = 0;
+                    if (is_small(sz))
+                    {
+                        // offset by possible bookkeeping
+                        start = (void*)((char*)q + sizeof(struct malloc_chunk));
+                    }
+                    else
+                        start = (void*)((char*)q + sizeof(struct malloc_tree_chunk));
+                }
+                if (start < (void*)next)  // skip if all space is bookkeeping
+                    handler(start, next, used, arg);
+                if (q == top)
+                    break;
+                q = next;
+            }
+        }
+    }
+}
+#endif // SPP_MALLOC_INSPECT_ALL
+
+
+
+/* ----------------------------- user mspaces ---------------------------- */
+
+static mstate init_user_mstate(char* tbase, size_t tsize)
+{
+    size_t msize = pad_request(sizeof(malloc_state));
+    mchunkptr msp = align_as_chunk(tbase);
+    mstate m = (mstate)(chunk2mem(msp));
+    memset(m, 0, msize);
+    msp->_head = (msize | INUSE_BITS);
+    m->init(tbase, tsize);
+    return m;
+}
+
+SPP_API mspace create_mspace(size_t capacity, int locked)
+{
+    mstate m = 0;
+    size_t msize;
+    mparams.ensure_initialization();
+    msize = pad_request(sizeof(malloc_state));
+    if (capacity < (size_t) - (msize + top_foot_size() + mparams._page_size))
+    {
+        size_t rs = ((capacity == 0) ? mparams._granularity :
+                     (capacity + top_foot_size() + msize));
+        size_t tsize = mparams.granularity_align(rs);
+        char* tbase = (char*)(SPP_CALL_MMAP(tsize));
+        if (tbase != cmfail)
+        {
+            m = init_user_mstate(tbase, tsize);
+            m->_seg._sflags = USE_MMAP_BIT;
+            m->set_lock(locked);
+        }
+    }
+    return (mspace)m;
+}
+
+SPP_API size_t destroy_mspace(mspace msp)
+{
+    size_t freed = 0;
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+    {
+        msegmentptr sp = &ms->_seg;
+        while (sp != 0)
+        {
+            char* base = sp->_base;
+            size_t size = sp->_size;
+            flag_t flag = sp->_sflags;
+            (void)base; // placate people compiling -Wunused-variable
+            sp = sp->_next;
+            if ((flag & USE_MMAP_BIT) && !(flag & EXTERN_BIT) &&
+                SPP_CALL_MUNMAP(base, size) == 0)
+                freed += size;
+        }
+    }
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+    return freed;
+}
+
+/* ----------------------------  mspace versions of malloc/calloc/free routines -------------------- */
+SPP_API void* mspace_malloc(mspace msp, size_t bytes)
+{
+    mstate ms = (mstate)msp;
+    if (!ms->ok_magic())
+    {
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+        return 0;
+    }
+    return ms->_malloc(bytes);
+}
+
+SPP_API void mspace_free(mspace msp, void* mem)
+{
+    if (mem != 0)
+    {
+        mchunkptr p  = mem2chunk(mem);
+#if SPP_FOOTERS
+        mstate fm = get_mstate_for(p);
+        (void)msp; // placate people compiling -Wunused
+#else
+        mstate fm = (mstate)msp;
+#endif
+        if (!fm->ok_magic())
+        {
+            SPP_USAGE_ERROR_ACTION(fm, p);
+            return;
+        }
+        fm->_free(p);
+    }
+}
+
+SPP_API inline void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size)
+{
+    void* mem;
+    size_t req = 0;
+    mstate ms = (mstate)msp;
+    if (!ms->ok_magic())
+    {
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+        return 0;
+    }
+    if (n_elements != 0)
+    {
+        req = n_elements * elem_size;
+        if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+                (req / n_elements != elem_size))
+            req = spp_max_size_t; // force downstream failure on overflow
+    }
+    mem = ms->internal_malloc(req);
+    if (mem != 0 && mem2chunk(mem)->calloc_must_clear())
+        memset(mem, 0, req);
+    return mem;
+}
+
+SPP_API inline void* mspace_realloc(mspace msp, void* oldmem, size_t bytes)
+{
+    void* mem = 0;
+    if (oldmem == 0)
+        mem = mspace_malloc(msp, bytes);
+    else if (bytes >= MAX_REQUEST)
+        SPP_MALLOC_FAILURE_ACTION;
+#ifdef REALLOC_ZERO_BYTES_FREES
+    else if (bytes == 0)
+        mspace_free(msp, oldmem);
+#endif
+    else
+    {
+        size_t nb = request2size(bytes);
+        mchunkptr oldp = mem2chunk(oldmem);
+#if ! SPP_FOOTERS
+        mstate m = (mstate)msp;
+#else
+        mstate m = get_mstate_for(oldp);
+        if (!m->ok_magic())
+        {
+            SPP_USAGE_ERROR_ACTION(m, oldmem);
+            return 0;
+        }
+#endif
+        if (1)
+        {
+            mchunkptr newp = m->try_realloc_chunk(oldp, nb, 1);
+            if (newp != 0)
+            {
+                m->check_inuse_chunk(newp);
+                mem = chunk2mem(newp);
+            }
+            else
+            {
+                mem = mspace_malloc(m, bytes);
+                if (mem != 0)
+                {
+                    size_t oc = oldp->chunksize() - oldp->overhead_for();
+                    memcpy(mem, oldmem, (oc < bytes) ? oc : bytes);
+                    mspace_free(m, oldmem);
+                }
+            }
+        }
+    }
+    return mem;
+}
+
+#if 0
+
+SPP_API mspace create_mspace_with_base(void* base, size_t capacity, int locked)
+{
+    mstate m = 0;
+    size_t msize;
+    mparams.ensure_initialization();
+    msize = pad_request(sizeof(malloc_state));
+    if (capacity > msize + top_foot_size() &&
+        capacity < (size_t) - (msize + top_foot_size() + mparams._page_size))
+    {
+        m = init_user_mstate((char*)base, capacity);
+        m->_seg._sflags = EXTERN_BIT;
+        m->set_lock(locked);
+    }
+    return (mspace)m;
+}
+
+SPP_API int mspace_track_large_chunks(mspace msp, int enable)
+{
+    int ret = 0;
+    mstate ms = (mstate)msp;
+    if (1)
+    {
+        if (!ms->use_mmap())
+            ret = 1;
+        if (!enable)
+            ms->enable_mmap();
+        else
+            ms->disable_mmap();
+    }
+    return ret;
+}
+
+SPP_API void* mspace_realloc_in_place(mspace msp, void* oldmem, size_t bytes)
+{
+    void* mem = 0;
+    if (oldmem != 0)
+    {
+        if (bytes >= MAX_REQUEST)
+            SPP_MALLOC_FAILURE_ACTION;
+        else
+        {
+            size_t nb = request2size(bytes);
+            mchunkptr oldp = mem2chunk(oldmem);
+#if ! SPP_FOOTERS
+            mstate m = (mstate)msp;
+#else
+            mstate m = get_mstate_for(oldp);
+            (void)msp; // placate people compiling -Wunused
+            if (!m->ok_magic())
+            {
+                SPP_USAGE_ERROR_ACTION(m, oldmem);
+                return 0;
+            }
+#endif
+            if (1)
+            {
+                mchunkptr newp = m->try_realloc_chunk(oldp, nb, 0);
+                if (newp == oldp)
+                {
+                    m->check_inuse_chunk(newp);
+                    mem = oldmem;
+                }
+            }
+        }
+    }
+    return mem;
+}
+
+SPP_API void* mspace_memalign(mspace msp, size_t alignment, size_t bytes)
+{
+    mstate ms = (mstate)msp;
+    if (!ms->ok_magic())
+    {
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+        return 0;
+    }
+    if (alignment <= SPP_MALLOC_ALIGNMENT)
+        return mspace_malloc(msp, bytes);
+    return ms->internal_memalign(alignment, bytes);
+}
+
+SPP_API void** mspace_independent_calloc(mspace msp, size_t n_elements,
+                                        size_t elem_size, void* chunks[])
+{
+    size_t sz = elem_size; // serves as 1-element array
+    mstate ms = (mstate)msp;
+    if (!ms->ok_magic())
+    {
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+        return 0;
+    }
+    return ms->ialloc(n_elements, &sz, 3, chunks);
+}
+
+SPP_API void** mspace_independent_comalloc(mspace msp, size_t n_elements,
+                                          size_t sizes[], void* chunks[])
+{
+    mstate ms = (mstate)msp;
+    if (!ms->ok_magic())
+    {
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+        return 0;
+    }
+    return ms->ialloc(n_elements, sizes, 0, chunks);
+}
+
+#endif
+
+SPP_API inline size_t mspace_bulk_free(mspace msp, void* array[], size_t nelem)
+{
+    return ((mstate)msp)->internal_bulk_free(array, nelem);
+}
+
+#if SPP_MALLOC_INSPECT_ALL
+SPP_API void mspace_inspect_all(mspace msp,
+                                void(*handler)(void *start,
+                                               void *end,
+                                               size_t used_bytes,
+                                               void* callback_arg),
+                                void* arg)
+{
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+        internal_inspect_all(ms, handler, arg);
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+}
+#endif
+
+SPP_API inline int mspace_trim(mspace msp, size_t pad)
+{
+    int result = 0;
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+        result = ms->sys_trim(pad);
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+    return result;
+}
+
+SPP_API inline size_t mspace_footprint(mspace msp)
+{
+    size_t result = 0;
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+        result = ms->_footprint;
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+    return result;
+}
+
+SPP_API inline size_t mspace_max_footprint(mspace msp)
+{
+    size_t result = 0;
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+        result = ms->_max_footprint;
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+    return result;
+}
+
+SPP_API inline size_t mspace_footprint_limit(mspace msp)
+{
+    size_t result = 0;
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+    {
+        size_t maf = ms->_footprint_limit;
+        result = (maf == 0) ? spp_max_size_t : maf;
+    }
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+    return result;
+}
+
+SPP_API inline size_t mspace_set_footprint_limit(mspace msp, size_t bytes)
+{
+    size_t result = 0;
+    mstate ms = (mstate)msp;
+    if (ms->ok_magic())
+    {
+        if (bytes == 0)
+            result = mparams.granularity_align(1); // Use minimal size
+        if (bytes == spp_max_size_t)
+            result = 0;                    // disable
+        else
+            result = mparams.granularity_align(bytes);
+        ms->_footprint_limit = result;
+    }
+    else
+        SPP_USAGE_ERROR_ACTION(ms, ms);
+    return result;
+}
+
+SPP_API inline size_t mspace_usable_size(const void* mem)
+{
+    if (mem != 0)
+    {
+        mchunkptr p = mem2chunk(mem);
+        if (p->is_inuse())
+            return p->chunksize() - p->overhead_for();
+    }
+    return 0;
+}
+
+SPP_API inline int mspace_mallopt(int param_number, int value)
+{
+    return mparams.change(param_number, value);
+}
+
+} // spp_ namespace
+
+
+#endif // SPP_EXCLUDE_IMPLEMENTATION
+
+#endif // spp_dlalloc__h_
diff --git a/examples/others/sparsepp/spp_memory.h b/examples/others/sparsepp/spp_memory.h
new file mode 100644
index 00000000..cfaa108d
--- /dev/null
+++ b/examples/others/sparsepp/spp_memory.h
@@ -0,0 +1,190 @@
+#if !defined(spp_memory_h_guard)
+#define spp_memory_h_guard
+
+#include <cstdint>
+#include <cstring>
+#include <cstdlib>
+
+#if defined(_WIN32) || defined( __CYGWIN__)
+    #define SPP_WIN
+#endif
+
+#ifdef SPP_WIN
+    #include <windows.h>
+    #include <Psapi.h>
+    #undef min
+    #undef max
+#elif defined(__linux__)
+    #include <sys/types.h>
+    #include <sys/sysinfo.h>
+#elif defined(__FreeBSD__)
+    #include <paths.h>
+    #include <fcntl.h>
+    #include <kvm.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+    #include <sys/user.h>
+#endif
+
+namespace spp
+{
+    uint64_t GetSystemMemory()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPageFile);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo (&memInfo);
+        auto totalVirtualMem = memInfo.totalram;
+
+        totalVirtualMem += memInfo.totalswap;
+        totalVirtualMem *= memInfo.mem_unit;
+        return static_cast<uint64_t>(totalVirtualMem);
+#elif defined(__FreeBSD__)
+        kvm_t *kd;
+        u_int pageCnt;
+        size_t pageCntLen = sizeof(pageCnt);
+        u_int pageSize;
+        struct kvm_swap kswap;
+        uint64_t totalVirtualMem;
+
+        pageSize = static_cast<u_int>(getpagesize());
+
+        sysctlbyname("vm.stats.vm.v_page_count", &pageCnt, &pageCntLen, NULL, 0);
+        totalVirtualMem = pageCnt * pageSize;
+
+        kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
+        kvm_getswapinfo(kd, &kswap, 1, 0);
+        kvm_close(kd);
+        totalVirtualMem += kswap.ksw_total * pageSize;
+
+        return totalVirtualMem;
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetTotalMemoryUsed()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPageFile - memInfo.ullAvailPageFile);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo(&memInfo);
+        auto virtualMemUsed = memInfo.totalram - memInfo.freeram;
+
+        virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
+        virtualMemUsed *= memInfo.mem_unit;
+
+        return static_cast<uint64_t>(virtualMemUsed);
+#elif defined(__FreeBSD__)
+        kvm_t *kd;
+        u_int pageSize;
+        u_int pageCnt, freeCnt;
+        size_t pageCntLen = sizeof(pageCnt);
+        size_t freeCntLen = sizeof(freeCnt);
+        struct kvm_swap kswap;
+        uint64_t virtualMemUsed;
+
+        pageSize = static_cast<u_int>(getpagesize());
+
+        sysctlbyname("vm.stats.vm.v_page_count", &pageCnt, &pageCntLen, NULL, 0);
+        sysctlbyname("vm.stats.vm.v_free_count", &freeCnt, &freeCntLen, NULL, 0);
+        virtualMemUsed = (pageCnt - freeCnt) * pageSize;
+
+        kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
+        kvm_getswapinfo(kd, &kswap, 1, 0);
+        kvm_close(kd);
+        virtualMemUsed += kswap.ksw_used * pageSize;
+
+        return virtualMemUsed;
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetProcessMemoryUsed()
+    {
+#ifdef SPP_WIN
+        PROCESS_MEMORY_COUNTERS_EX pmc;
+        GetProcessMemoryInfo(GetCurrentProcess(), reinterpret_cast<PPROCESS_MEMORY_COUNTERS>(&pmc), sizeof(pmc));
+        return static_cast<uint64_t>(pmc.PrivateUsage);
+#elif defined(__linux__)
+        auto parseLine = 
+            [](char* line)->int
+            {
+                auto i = strlen(line);
+				
+                while(*line < '0' || *line > '9') 
+                {
+                    line++;
+                }
+
+                line[i-3] = '\0';
+                i = atoi(line);
+                return i;
+            };
+
+        auto file = fopen("/proc/self/status", "r");
+        auto result = -1;
+        char line[128];
+
+        while(fgets(line, 128, file) != nullptr)
+        {
+            if(strncmp(line, "VmSize:", 7) == 0)
+            {
+                result = parseLine(line);
+                break;
+            }
+        }
+
+        fclose(file);
+        return static_cast<uint64_t>(result) * 1024;
+#elif defined(__FreeBSD__)
+        struct kinfo_proc info;
+        size_t infoLen = sizeof(info);
+        int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid() };
+
+        sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &infoLen, NULL, 0);
+        return static_cast<uint64_t>(info.ki_rssize * getpagesize());
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetPhysicalMemory()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPhys);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo(&memInfo);
+
+        auto totalPhysMem = memInfo.totalram;
+
+        totalPhysMem *= memInfo.mem_unit;
+        return static_cast<uint64_t>(totalPhysMem);
+#elif defined(__FreeBSD__)
+        u_long physMem;
+        size_t physMemLen = sizeof(physMem);
+        int mib[] = { CTL_HW, HW_PHYSMEM };
+
+        sysctl(mib, sizeof(mib) / sizeof(*mib), &physMem, &physMemLen, NULL, 0);
+        return physMem;
+#else
+        return 0;
+#endif
+    }
+
+}
+
+#endif // spp_memory_h_guard
diff --git a/examples/others/sparsepp/spp_smartptr.h b/examples/others/sparsepp/spp_smartptr.h
new file mode 100644
index 00000000..fba3acfb
--- /dev/null
+++ b/examples/others/sparsepp/spp_smartptr.h
@@ -0,0 +1,71 @@
+#if !defined(spp_smartptr_h_guard)
+#define spp_smartptr_h_guard
+
+
+/* -----------------------------------------------------------------------------------------------
+ * quick version of intrusive_ptr
+ * -----------------------------------------------------------------------------------------------
+ */
+
+#include <cassert>
+#include "spp_config.h"
+
+// ------------------------------------------------------------------------
+class spp_rc
+{
+public:
+    spp_rc() : _cnt(0) {}
+    spp_rc(const spp_rc &) : _cnt(0) {}
+    void increment() const { ++_cnt; }
+    void decrement() const { assert(_cnt); if (--_cnt == 0) delete this; }
+    unsigned count() const { return _cnt; }
+
+protected:
+    virtual ~spp_rc() {}
+
+private:
+    mutable unsigned _cnt;
+};
+
+// ------------------------------------------------------------------------
+template <class T>
+class spp_sptr
+{
+public:
+    spp_sptr() : _p(0) {}
+    spp_sptr(T *p) : _p(p)                  { if (_p) _p->increment(); }
+    spp_sptr(const spp_sptr &o) : _p(o._p)  { if (_p) _p->increment(); }
+#ifndef SPP_NO_CXX11_RVALUE_REFERENCES 
+    spp_sptr(spp_sptr &&o) : _p(o._p)       { o._p = (T *)0; }
+    spp_sptr& operator=(spp_sptr &&o)       { this->swap(o); return *this; }
+#endif    
+    ~spp_sptr()                             { if (_p) _p->decrement(); }
+    spp_sptr& operator=(const spp_sptr &o)  { reset(o._p); return *this; }
+    T* get() const                          { return _p; }
+    void swap(spp_sptr &o)                  { T *tmp = _p; _p = o._p; o._p = tmp; }
+    void reset(const T *p = 0)             
+    { 
+        if (p == _p) 
+            return; 
+        if (_p) _p->decrement(); 
+        _p = (T *)p; 
+        if (_p) _p->increment();
+    }
+    T*   operator->() const { return const_cast<T *>(_p); }
+    bool operator!()  const { return _p == 0; }
+
+private:
+    T *_p;
+};    
+
+// ------------------------------------------------------------------------
+namespace std
+{
+    template <class T>
+    inline void swap(spp_sptr<T> &a, spp_sptr<T> &b)
+    {
+        a.swap(b);
+    }
+}
+
+#endif // spp_smartptr_h_guard
diff --git a/examples/others/sparsepp/spp_stdint.h b/examples/others/sparsepp/spp_stdint.h
new file mode 100644
index 00000000..3adced9c
--- /dev/null
+++ b/examples/others/sparsepp/spp_stdint.h
@@ -0,0 +1,16 @@
+#if !defined(spp_stdint_h_guard)
+#define spp_stdint_h_guard
+
+#include "spp_config.h"
+
+#if defined(SPP_HAS_CSTDINT) && (__cplusplus >= 201103)
+    #include <cstdint>
+#else
+    #if defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
+        #include <inttypes.h>
+    #else
+        #include <stdint.h>
+    #endif
+#endif
+
+#endif // spp_stdint_h_guard
diff --git a/examples/others/sparsepp/spp_timer.h b/examples/others/sparsepp/spp_timer.h
new file mode 100644
index 00000000..48180f4d
--- /dev/null
+++ b/examples/others/sparsepp/spp_timer.h
@@ -0,0 +1,58 @@
+/**
+   Copyright (c) 2016 Mariano Gonzalez
+
+   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 spp_timer_h_guard
+#define spp_timer_h_guard
+
+#include <chrono>
+
+namespace spp
+{
+    template<typename time_unit = std::milli>
+    class Timer 
+    {
+    public:
+        Timer()                 { reset(); }
+        void reset()            { _start = _snap = clock::now();  }
+        void snap()             { _snap = clock::now();  }
+
+        float get_total() const { return get_diff<float>(_start, clock::now()); }
+        float get_delta() const { return get_diff<float>(_snap, clock::now());  }
+        
+    private:
+        using clock = std::chrono::high_resolution_clock;
+        using point = std::chrono::time_point<clock>;
+
+        template<typename T>
+        static T get_diff(const point& start, const point& end) 
+        {
+            using duration_t = std::chrono::duration<T, time_unit>;
+
+            return std::chrono::duration_cast<duration_t>(end - start).count();
+        }
+
+        point _start;
+        point _snap;
+    };
+}
+
+#endif // spp_timer_h_guard
diff --git a/examples/others/sparsepp/spp_traits.h b/examples/others/sparsepp/spp_traits.h
new file mode 100644
index 00000000..792f52f2
--- /dev/null
+++ b/examples/others/sparsepp/spp_traits.h
@@ -0,0 +1,125 @@
+#if !defined(spp_traits_h_guard)
+#define spp_traits_h_guard
+
+#include "spp_config.h"
+
+template<int S, int H> class HashObject; // for Google's benchmark, not in spp namespace!
+
+namespace spp_
+{
+
+// ---------------------------------------------------------------------------
+//                       type_traits we need
+// ---------------------------------------------------------------------------
+template<class T, T v>
+struct integral_constant { static const T value = v; };
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, false> false_type;
+
+typedef integral_constant<int, 0>      zero_type;
+typedef integral_constant<int, 1>      one_type;
+typedef integral_constant<int, 2>      two_type;
+typedef integral_constant<int, 3>      three_type;
+
+template<typename T, typename U> struct is_same : public false_type { };
+template<typename T> struct is_same<T, T> : public true_type { };
+
+template<typename T> struct remove_const { typedef T type; };
+template<typename T> struct remove_const<T const> { typedef T type; };
+
+template<typename T> struct remove_volatile { typedef T type; };
+template<typename T> struct remove_volatile<T volatile> { typedef T type; };
+
+template<typename T> struct remove_cv 
+{
+    typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+};
+
+// ---------------- is_integral ----------------------------------------
+template <class T> struct is_integral;
+template <class T> struct is_integral         : false_type { };
+template<> struct is_integral<bool>           : true_type { };
+template<> struct is_integral<char>           : true_type { };
+template<> struct is_integral<unsigned char>  : true_type { };
+template<> struct is_integral<signed char>    : true_type { };
+template<> struct is_integral<short>          : true_type { };
+template<> struct is_integral<unsigned short> : true_type { };
+template<> struct is_integral<int>            : true_type { };
+template<> struct is_integral<unsigned int>   : true_type { };
+template<> struct is_integral<long>           : true_type { };
+template<> struct is_integral<unsigned long>  : true_type { };
+#ifdef SPP_HAS_LONG_LONG
+    template<> struct is_integral<long long>  : true_type { };
+    template<> struct is_integral<unsigned long long> : true_type { };
+#endif
+template <class T> struct is_integral<const T>          : is_integral<T> { };
+template <class T> struct is_integral<volatile T>       : is_integral<T> { };
+template <class T> struct is_integral<const volatile T> : is_integral<T> { };
+
+// ---------------- is_floating_point ----------------------------------------
+template <class T> struct is_floating_point;
+template <class T> struct is_floating_point      : false_type { };
+template<> struct is_floating_point<float>       : true_type { };
+template<> struct is_floating_point<double>      : true_type { };
+template<> struct is_floating_point<long double> : true_type { };
+template <class T> struct is_floating_point<const T> :        is_floating_point<T> { };
+template <class T> struct is_floating_point<volatile T>       : is_floating_point<T> { };
+template <class T> struct is_floating_point<const volatile T> : is_floating_point<T> { };
+
+//  ---------------- is_pointer ----------------------------------------
+template <class T> struct is_pointer;
+template <class T> struct is_pointer     : false_type { };
+template <class T> struct is_pointer<T*> : true_type { };
+template <class T> struct is_pointer<const T>          : is_pointer<T> { };
+template <class T> struct is_pointer<volatile T>       : is_pointer<T> { };
+template <class T> struct is_pointer<const volatile T> : is_pointer<T> { };
+
+//  ---------------- is_reference ----------------------------------------
+template <class T> struct is_reference;
+template<typename T> struct is_reference     : false_type {};
+template<typename T> struct is_reference<T&> : true_type {};
+
+//  ---------------- is_relocatable ----------------------------------------
+// relocatable values can be moved around in memory using memcpy and remain
+// correct. Most types are relocatable, an example of a type who is not would
+// be a struct which contains a pointer to a buffer inside itself - this is the
+// case for std::string in gcc 5.
+// ------------------------------------------------------------------------
+template <class T> struct is_relocatable;
+template <class T> struct is_relocatable :
+     integral_constant<bool, (is_integral<T>::value ||
+                              is_floating_point<T>::value ||
+                              is_pointer<T>::value
+                             )>
+{ };
+
+template<int S, int H> struct is_relocatable<HashObject<S, H> > : true_type { };
+
+template <class T> struct is_relocatable<const T>          : is_relocatable<T> { };
+template <class T> struct is_relocatable<volatile T>       : is_relocatable<T> { };
+template <class T> struct is_relocatable<const volatile T> : is_relocatable<T> { };
+template <class A, int N> struct is_relocatable<A[N]>      : is_relocatable<A> { };
+template <class T, class U> struct is_relocatable<std::pair<T, U> > :
+     integral_constant<bool, (is_relocatable<T>::value && is_relocatable<U>::value)>
+{ };
+
+// A template helper used to select A or B based on a condition.
+// ------------------------------------------------------------
+template<bool cond, typename A, typename B>
+struct if_
+{
+    typedef A type;
+};
+
+template<typename A, typename B>
+struct if_<false, A, B> 
+{
+    typedef B type;
+};
+
+}  // spp_ namespace
+
+#endif // spp_traits_h_guard
diff --git a/examples/others/sparsepp/spp_utils.h b/examples/others/sparsepp/spp_utils.h
new file mode 100644
index 00000000..4f2e9257
--- /dev/null
+++ b/examples/others/sparsepp/spp_utils.h
@@ -0,0 +1,477 @@
+// ----------------------------------------------------------------------
+// Copyright (c) 2016, Steven Gregory Popovitch - [email protected]
+// All rights reserved.
+//
+// Code derived derived from Boost libraries.
+// Boost software licence reproduced below.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * The name of Steven Gregory Popovitch may not be used to
+// endorse or promote products derived from this software without
+// specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// ----------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Boost Software License - Version 1.0 - August 17th, 2003
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+//
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+//
+// 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+// ---------------------------------------------------------------------------
+
+//  ----------------------------------------------------------------------
+//                  H A S H    F U N C T I O N S
+//                  ----------------------------
+//
+//    Implements spp::spp_hash() and spp::hash_combine()
+//  ----------------------------------------------------------------------
+
+#if !defined(spp_utils_h_guard_)
+#define spp_utils_h_guard_
+
+#if defined(_MSC_VER)
+    #if (_MSC_VER >= 1600 )                      // vs2010 (1900 is vs2015)
+        #include <functional>
+        #define SPP_HASH_CLASS std::hash
+    #else
+        #include  <hash_map>
+        #define SPP_HASH_CLASS stdext::hash_compare
+    #endif
+    #if (_MSC_FULL_VER < 190021730)
+        #define SPP_NO_CXX11_NOEXCEPT
+    #endif
+#elif defined __clang__
+    #if __has_feature(cxx_noexcept) || defined(SPP_CXX11) // define SPP_CXX11 if your compiler has <functional>
+       #include <functional>
+       #define SPP_HASH_CLASS  std::hash
+    #else
+       #include <tr1/functional>
+       #define SPP_HASH_CLASS std::tr1::hash
+    #endif
+
+    #if !__has_feature(cxx_noexcept)
+        #define SPP_NO_CXX11_NOEXCEPT
+    #endif
+#elif defined(__GNUC__)
+    #if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
+        #include <functional>
+        #define SPP_HASH_CLASS std::hash
+
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) < 40600
+            #define SPP_NO_CXX11_NOEXCEPT
+        #endif
+    #else
+        #include <tr1/unordered_map>
+        #define SPP_HASH_CLASS std::tr1::hash
+        #define SPP_NO_CXX11_NOEXCEPT
+    #endif
+#else
+    #include <functional>
+    #define SPP_HASH_CLASS  std::hash
+#endif
+
+#ifdef SPP_NO_CXX11_NOEXCEPT
+    #define SPP_NOEXCEPT
+#else
+    #define SPP_NOEXCEPT noexcept
+#endif
+
+#ifdef SPP_NO_CXX11_CONSTEXPR
+    #define SPP_CONSTEXPR
+#else
+    #define SPP_CONSTEXPR constexpr
+#endif
+
+#ifdef SPP_NO_CXX14_CONSTEXPR
+    #define SPP_CXX14_CONSTEXPR
+#else
+    #define SPP_CXX14_CONSTEXPR constexpr
+#endif
+
+#define SPP_INLINE
+
+#ifndef spp_
+    #define spp_ spp
+#endif
+
+namespace spp_
+{
+
+template <class T>  T spp_min(T a, T b) { return a < b  ? a : b; }
+template <class T>  T spp_max(T a, T b) { return a >= b ? a : b; }
+
+template <class T>
+struct spp_hash
+{
+    SPP_INLINE size_t operator()(const T &__v) const SPP_NOEXCEPT
+    {
+        SPP_HASH_CLASS<T> hasher;
+        return hasher(__v);
+    }
+};
+
+template <class T>
+struct spp_hash<T *>
+{
+    static size_t spp_log2 (size_t val) SPP_NOEXCEPT
+    {
+        size_t res = 0;
+        while (val > 1)
+        {
+            val >>= 1;
+            res++;
+        }
+        return res;
+    }
+
+    SPP_INLINE size_t operator()(const T *__v) const SPP_NOEXCEPT
+    {
+        static const size_t shift = 3; // spp_log2(1 + sizeof(T)); // T might be incomplete!
+        const uintptr_t i = (const uintptr_t)__v;
+        return static_cast<size_t>(i >> shift);
+    }
+};
+
+// from http://burtleburtle.net/bob/hash/integer.html
+// fast and efficient for power of two table sizes where we always
+// consider the last bits.
+// ---------------------------------------------------------------
+inline size_t spp_mix_32(uint32_t a)
+{
+    a = a ^ (a >> 4);
+    a = (a ^ 0xdeadbeef) + (a << 5);
+    a = a ^ (a >> 11);
+    return static_cast<size_t>(a);
+}
+
+// More thorough scrambling as described in
+// https://gist.github.com/badboy/6267743
+// ----------------------------------------
+inline size_t spp_mix_64(uint64_t a)
+{
+    a = (~a) + (a << 21); // a = (a << 21) - a - 1;
+    a = a ^ (a >> 24);
+    a = (a + (a << 3)) + (a << 8); // a * 265
+    a = a ^ (a >> 14);
+    a = (a + (a << 2)) + (a << 4); // a * 21
+    a = a ^ (a >> 28);
+    a = a + (a << 31);
+    return static_cast<size_t>(a);
+}
+
+template<class ArgumentType, class ResultType>
+struct spp_unary_function
+{
+    typedef ArgumentType argument_type;
+    typedef ResultType result_type;
+};
+
+template <>
+struct spp_hash<bool> : public spp_unary_function<bool, size_t>
+{
+    SPP_INLINE size_t operator()(bool __v) const SPP_NOEXCEPT
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct spp_hash<char> : public spp_unary_function<char, size_t>
+{
+    SPP_INLINE size_t operator()(char __v) const SPP_NOEXCEPT
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct spp_hash<signed char> : public spp_unary_function<signed char, size_t>
+{
+    SPP_INLINE size_t operator()(signed char __v) const SPP_NOEXCEPT
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct spp_hash<unsigned char> : public spp_unary_function<unsigned char, size_t>
+{
+    SPP_INLINE size_t operator()(unsigned char __v) const SPP_NOEXCEPT
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct spp_hash<wchar_t> : public spp_unary_function<wchar_t, size_t>
+{
+    SPP_INLINE size_t operator()(wchar_t __v) const SPP_NOEXCEPT
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct spp_hash<int16_t> : public spp_unary_function<int16_t, size_t>
+{
+    SPP_INLINE size_t operator()(int16_t __v) const SPP_NOEXCEPT
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct spp_hash<uint16_t> : public spp_unary_function<uint16_t, size_t>
+{
+    SPP_INLINE size_t operator()(uint16_t __v) const SPP_NOEXCEPT
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct spp_hash<int32_t> : public spp_unary_function<int32_t, size_t>
+{
+    SPP_INLINE size_t operator()(int32_t __v) const SPP_NOEXCEPT
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct spp_hash<uint32_t> : public spp_unary_function<uint32_t, size_t>
+{
+    SPP_INLINE size_t operator()(uint32_t __v) const SPP_NOEXCEPT
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct spp_hash<int64_t> : public spp_unary_function<int64_t, size_t>
+{
+    SPP_INLINE size_t operator()(int64_t __v) const SPP_NOEXCEPT
+    { return spp_mix_64(static_cast<uint64_t>(__v)); }
+};
+
+template <>
+struct spp_hash<uint64_t> : public spp_unary_function<uint64_t, size_t>
+{
+    SPP_INLINE size_t operator()(uint64_t __v) const SPP_NOEXCEPT
+    { return spp_mix_64(static_cast<uint64_t>(__v)); }
+};
+
+template <>
+struct spp_hash<float> : public spp_unary_function<float, size_t>
+{
+    SPP_INLINE size_t operator()(float __v) const SPP_NOEXCEPT
+    {
+        // -0.0 and 0.0 should return same hash
+        uint32_t *as_int = reinterpret_cast<uint32_t *>(&__v);
+        return (__v == 0) ? static_cast<size_t>(0) : spp_mix_32(*as_int);
+    }
+};
+
+template <>
+struct spp_hash<double> : public spp_unary_function<double, size_t>
+{
+    SPP_INLINE size_t operator()(double __v) const SPP_NOEXCEPT
+    {
+        // -0.0 and 0.0 should return same hash
+        uint64_t *as_int = reinterpret_cast<uint64_t *>(&__v);
+        return (__v == 0) ? static_cast<size_t>(0) : spp_mix_64(*as_int);
+    }
+};
+
+template <class T, int sz> struct Combiner
+{
+    inline void operator()(T& seed, T value);
+};
+
+template <class T> struct Combiner<T, 4>
+{
+    inline void  operator()(T& seed, T value)
+    {
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    }
+};
+
+template <class T> struct Combiner<T, 8>
+{
+    inline void  operator()(T& seed, T value)
+    {
+        seed ^= value + T(0xc6a4a7935bd1e995) + (seed << 6) + (seed >> 2);
+    }
+};
+
+template <class T>
+inline void hash_combine(std::size_t& seed, T const& v)
+{
+    spp_::spp_hash<T> hasher;
+    Combiner<std::size_t, sizeof(std::size_t)> combiner;
+
+    combiner(seed, hasher(v));
+}
+
+static inline uint32_t s_spp_popcount_default(uint32_t i) SPP_NOEXCEPT
+{
+    i = i - ((i >> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
+    return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+
+static inline uint32_t s_spp_popcount_default(uint64_t x) SPP_NOEXCEPT
+{
+    const uint64_t m1  = uint64_t(0x5555555555555555); // binary: 0101...
+    const uint64_t m2  = uint64_t(0x3333333333333333); // binary: 00110011..
+    const uint64_t m4  = uint64_t(0x0f0f0f0f0f0f0f0f); // binary:  4 zeros,  4 ones ...
+    const uint64_t h01 = uint64_t(0x0101010101010101); // the sum of 256 to the power of 0,1,2,3...
+
+    x -= (x >> 1) & m1;             // put count of each 2 bits into those 2 bits
+    x = (x & m2) + ((x >> 2) & m2); // put count of each 4 bits into those 4 bits 
+    x = (x + (x >> 4)) & m4;        // put count of each 8 bits into those 8 bits 
+    return (x * h01)>>56;           // returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24)+...
+}
+
+#ifdef __APPLE__
+    static inline uint32_t count_trailing_zeroes(size_t v) SPP_NOEXCEPT
+    {
+        size_t x = (v & -v) - 1;
+        // sadly sizeof() required to build on macos 
+        return sizeof(size_t) == 8 ? s_spp_popcount_default((uint64_t)x) : s_spp_popcount_default((uint32_t)x);
+    }
+
+    static inline uint32_t s_popcount(size_t v) SPP_NOEXCEPT
+    {
+        // sadly sizeof() required to build on macos 
+        return sizeof(size_t) == 8 ? s_spp_popcount_default((uint64_t)v) : s_spp_popcount_default((uint32_t)v);
+    }
+#else
+    static inline uint32_t count_trailing_zeroes(size_t v) SPP_NOEXCEPT
+    {
+        return s_spp_popcount_default((v & -(intptr_t)v) - 1);
+    }
+
+    static inline uint32_t s_popcount(size_t v) SPP_NOEXCEPT
+    {
+        return s_spp_popcount_default(v);
+    }
+#endif
+
+// -----------------------------------------------------------
+// -----------------------------------------------------------
+template<class T>
+class libc_allocator
+{
+public:
+    typedef T         value_type;
+    typedef T*        pointer;
+    typedef ptrdiff_t difference_type;
+    typedef const T*  const_pointer;
+    typedef size_t    size_type;
+
+    libc_allocator() {}
+    libc_allocator(const libc_allocator&) {}
+
+    template<class U>
+    libc_allocator(const libc_allocator<U> &) {}
+
+    libc_allocator& operator=(const libc_allocator &) { return *this; }
+
+    template<class U>
+    libc_allocator& operator=(const libc_allocator<U> &) { return *this; }
+
+#ifndef SPP_NO_CXX11_RVALUE_REFERENCES    
+    libc_allocator(libc_allocator &&) {}
+    libc_allocator& operator=(libc_allocator &&) { return *this; }
+#endif
+
+    pointer allocate(size_t n, const_pointer  /* unused */= 0) 
+    {
+        pointer res = static_cast<pointer>(malloc(n * sizeof(T)));
+        if (!res)
+            throw std::bad_alloc();
+        return res;
+    }
+
+    void deallocate(pointer p, size_t /* unused */) 
+    {
+        free(p);
+    }
+
+    pointer reallocate(pointer p, size_t new_size) 
+    {
+        pointer res = static_cast<pointer>(realloc(p, new_size * sizeof(T)));
+        if (!res)
+            throw std::bad_alloc();
+        return res;
+    }
+
+    // extra API to match spp_allocator interface
+    pointer reallocate(pointer p, size_t /* old_size */, size_t new_size) 
+    {
+        return static_cast<pointer>(realloc(p, new_size * sizeof(T)));
+    }
+
+    size_type max_size() const
+    {
+        return static_cast<size_type>(-1) / sizeof(value_type);
+    }
+
+    void construct(pointer p, const value_type& val)
+    {
+        new(p) value_type(val);
+    }
+
+    void destroy(pointer p) { p->~value_type(); }
+
+    template<class U>
+    struct rebind
+    {
+        typedef spp_::libc_allocator<U> other;
+    };
+
+};
+
+// forward declaration
+// -------------------
+template<class T>
+class spp_allocator;
+
+}
+
+template<class T>
+inline bool operator==(const spp_::libc_allocator<T> &, const spp_::libc_allocator<T> &)
+{
+    return true;
+}
+
+template<class T>
+inline bool operator!=(const spp_::libc_allocator<T> &, const spp_::libc_allocator<T> &)
+{
+    return false;
+}
+
+#endif // spp_utils_h_guard_
+