diff --git a/include/boost/unordered/detail/fwd.hpp b/include/boost/unordered/detail/fwd.hpp
index 74419062..6a842042 100644
--- a/include/boost/unordered/detail/fwd.hpp
+++ b/include/boost/unordered/detail/fwd.hpp
@@ -15,21 +15,21 @@
 // Already defined.
 #elif defined(BOOST_LIBSTDCXX11)
 // https://github.com/gcc-mirror/gcc/blob/gcc-4_6-branch/libstdc++-v3/include/bits/stl_pair.h#L70
-#   if BOOST_LIBSTDCXX_VERSION > 40600
-#       define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
-#   endif
+#if BOOST_LIBSTDCXX_VERSION > 40600
+#define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
+#endif
 #elif defined(_LIBCPP_VERSION)
 // https://github.com/llvm-mirror/libcxx/blob/release_30/include/utility#L206
-#   if LIBCPP_VERSION >= 3000
-#       define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
-#   endif
+#if LIBCPP_VERSION >= 3000
+#define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
+#endif
 #elif defined(BOOST_MSVC)
 // Apparently C++11 standard supported in Visual Studio 2012
 // https://msdn.microsoft.com/en-us/library/hh567368.aspx#stl
 // 2012 = VC+11 = BOOST_MSVC 1700 Hopefully!
-#   if BOOST_MSVC >= 1700
-#       define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
-#   endif
+#if BOOST_MSVC >= 1700
+#define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
+#endif
 #endif
 
 #if !defined(BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT)
@@ -40,16 +40,16 @@
 #include <utility>
 #endif
 
-namespace boost
-{
-namespace unordered
-{
+namespace boost {
+namespace unordered {
 #if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
-    using std::piecewise_construct_t;
-    using std::piecewise_construct;
+using std::piecewise_construct_t;
+using std::piecewise_construct;
 #else
-    struct piecewise_construct_t {};
-    const piecewise_construct_t piecewise_construct = piecewise_construct_t();
+struct piecewise_construct_t
+{
+};
+const piecewise_construct_t piecewise_construct = piecewise_construct_t();
 #endif
 }
 }
diff --git a/include/boost/unordered/detail/implementation.hpp b/include/boost/unordered/detail/implementation.hpp
index ec5d129e..78850bba 100644
--- a/include/boost/unordered/detail/implementation.hpp
+++ b/include/boost/unordered/detail/implementation.hpp
@@ -10,84 +10,89 @@
 #pragma once
 #endif
 
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_empty.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/assert.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
 #include <boost/detail/select_type.hpp>
+#include <boost/detail/select_type.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/limits.hpp>
 #include <boost/move/move.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/swap.hpp>
-#include <boost/unordered/detail/fwd.hpp>
 #include <boost/move/move.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/type_traits/is_class.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/swap.hpp>
+#include <boost/swap.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/tuple/tuple.hpp>
 #include <boost/type_traits/add_lvalue_reference.hpp>
 #include <boost/type_traits/aligned_storage.hpp>
 #include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_empty.hpp>
 #include <boost/type_traits/is_nothrow_move_assignable.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/unordered/detail/fwd.hpp>
 #include <boost/utility/addressof.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/select_type.hpp>
-#include <boost/swap.hpp>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <iterator>
-#include <utility>
+#include <boost/utility/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <cmath>
+#include <iterator>
 #include <stdexcept>
+#include <utility>
 
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE)
 #include <tuple>
 #endif
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    static const float minimum_max_load_factor = 1e-3f;
-    static const std::size_t default_bucket_count = 11;
-    struct move_tag {};
-    struct empty_emplace {};
+static const float minimum_max_load_factor = 1e-3f;
+static const std::size_t default_bucket_count = 11;
+struct move_tag
+{
+};
+struct empty_emplace
+{
+};
 
-    namespace func {
-        template <class T>
-        inline void ignore_unused_variable_warning(T const&) {}
-    }
+namespace func {
+template <class T> inline void ignore_unused_variable_warning(T const&) {}
+}
 
-    ////////////////////////////////////////////////////////////////////////////
-    // iterator SFINAE
+////////////////////////////////////////////////////////////////////////////
+// iterator SFINAE
 
-    template <typename I>
-    struct is_forward :
-        boost::is_convertible<
-            typename boost::iterator_traversal<I>::type,
-            boost::forward_traversal_tag>
-    {};
+template <typename I>
+struct is_forward
+    : boost::is_convertible<typename boost::iterator_traversal<I>::type,
+          boost::forward_traversal_tag>
+{
+};
 
-    template <typename I, typename ReturnType>
-    struct enable_if_forward :
-        boost::enable_if_c<
-            boost::unordered::detail::is_forward<I>::value,
-            ReturnType>
-    {};
+template <typename I, typename ReturnType>
+struct enable_if_forward
+    : boost::enable_if_c<boost::unordered::detail::is_forward<I>::value,
+          ReturnType>
+{
+};
 
-    template <typename I, typename ReturnType>
-    struct disable_if_forward :
-        boost::disable_if_c<
-            boost::unordered::detail::is_forward<I>::value,
-            ReturnType>
-    {};
+template <typename I, typename ReturnType>
+struct disable_if_forward
+    : boost::disable_if_c<boost::unordered::detail::is_forward<I>::value,
+          ReturnType>
+{
+};
 
-    ////////////////////////////////////////////////////////////////////////////
-    // primes
+////////////////////////////////////////////////////////////////////////////
+// primes
 
 // clang-format off
 #define BOOST_UNORDERED_PRIMES \
@@ -100,242 +105,268 @@ namespace boost { namespace unordered { namespace detail {
     (1610612741ul)(3221225473ul)(4294967291ul)
 // clang-format on
 
-    template<class T> struct prime_list_template
-    {
-        static std::size_t const value[];
+template <class T> struct prime_list_template
+{
+    static std::size_t const value[];
 
 #if !defined(SUNPRO_CC)
-        static std::ptrdiff_t const length;
+    static std::ptrdiff_t const length;
 #else
-        static std::ptrdiff_t const length
-            = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+    static std::ptrdiff_t const length =
+        BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
 #endif
-    };
+};
 
-    template<class T>
-    std::size_t const prime_list_template<T>::value[] = {
-        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)
-    };
+template <class T>
+std::size_t const prime_list_template<T>::value[] = {
+    BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)};
 
 #if !defined(SUNPRO_CC)
-    template<class T>
-    std::ptrdiff_t const prime_list_template<T>::length
-        = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+template <class T>
+std::ptrdiff_t const prime_list_template<T>::length = BOOST_PP_SEQ_SIZE(
+    BOOST_UNORDERED_PRIMES);
 #endif
 
 #undef BOOST_UNORDERED_PRIMES
 
-    typedef prime_list_template<std::size_t> prime_list;
+typedef prime_list_template<std::size_t> prime_list;
 
-    // no throw
-    inline std::size_t next_prime(std::size_t num) {
-        std::size_t const* const prime_list_begin = prime_list::value;
-        std::size_t const* const prime_list_end = prime_list_begin +
-            prime_list::length;
-        std::size_t const* bound =
-            std::lower_bound(prime_list_begin, prime_list_end, num);
-        if(bound == prime_list_end)
-            bound--;
-        return *bound;
+// no throw
+inline std::size_t next_prime(std::size_t num)
+{
+    std::size_t const* const prime_list_begin = prime_list::value;
+    std::size_t const* const prime_list_end =
+        prime_list_begin + prime_list::length;
+    std::size_t const* bound =
+        std::lower_bound(prime_list_begin, prime_list_end, num);
+    if (bound == prime_list_end)
+        bound--;
+    return *bound;
+}
+
+// no throw
+inline std::size_t prev_prime(std::size_t num)
+{
+    std::size_t const* const prime_list_begin = prime_list::value;
+    std::size_t const* const prime_list_end =
+        prime_list_begin + prime_list::length;
+    std::size_t const* bound =
+        std::upper_bound(prime_list_begin, prime_list_end, num);
+    if (bound != prime_list_begin)
+        bound--;
+    return *bound;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// insert_size/initial_size
+
+template <class I>
+inline std::size_t insert_size(I i, I j,
+    typename boost::unordered::detail::enable_if_forward<I, void*>::type = 0)
+{
+    return static_cast<std::size_t>(std::distance(i, j));
+}
+
+template <class I>
+inline std::size_t insert_size(I, I,
+    typename boost::unordered::detail::disable_if_forward<I, void*>::type = 0)
+{
+    return 1;
+}
+
+template <class I>
+inline std::size_t initial_size(I i, I j,
+    std::size_t num_buckets = boost::unordered::detail::default_bucket_count)
+{
+    // TODO: Why +1?
+    return (std::max)(
+        boost::unordered::detail::insert_size(i, j) + 1, num_buckets);
+}
+
+////////////////////////////////////////////////////////////////////////////
+// compressed
+
+template <typename T, int Index> struct compressed_base : private T
+{
+    compressed_base(T const& x) : T(x) {}
+    compressed_base(T& x, move_tag) : T(boost::move(x)) {}
+
+    T& get() { return *this; }
+    T const& get() const { return *this; }
+};
+
+template <typename T, int Index> struct uncompressed_base
+{
+    uncompressed_base(T const& x) : value_(x) {}
+    uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {}
+
+    T& get() { return value_; }
+    T const& get() const { return value_; }
+  private:
+    T value_;
+};
+
+template <typename T, int Index>
+struct generate_base
+    : boost::detail::if_true<boost::is_empty<T>::value>::BOOST_NESTED_TEMPLATE
+          then<boost::unordered::detail::compressed_base<T, Index>,
+              boost::unordered::detail::uncompressed_base<T, Index> >
+{
+};
+
+template <typename T1, typename T2>
+struct compressed
+    : private boost::unordered::detail::generate_base<T1, 1>::type,
+      private boost::unordered::detail::generate_base<T2, 2>::type
+{
+    typedef typename generate_base<T1, 1>::type base1;
+    typedef typename generate_base<T2, 2>::type base2;
+
+    typedef T1 first_type;
+    typedef T2 second_type;
+
+    first_type& first() { return static_cast<base1*>(this)->get(); }
+
+    first_type const& first() const
+    {
+        return static_cast<base1 const*>(this)->get();
     }
 
-    // no throw
-    inline std::size_t prev_prime(std::size_t num) {
-        std::size_t const* const prime_list_begin = prime_list::value;
-        std::size_t const* const prime_list_end = prime_list_begin +
-            prime_list::length;
-        std::size_t const* bound =
-            std::upper_bound(prime_list_begin,prime_list_end, num);
-        if(bound != prime_list_begin)
-            bound--;
-        return *bound;
+    second_type& second() { return static_cast<base2*>(this)->get(); }
+
+    second_type const& second() const
+    {
+        return static_cast<base2 const*>(this)->get();
     }
 
-    ////////////////////////////////////////////////////////////////////////////
-    // insert_size/initial_size
-
-    template <class I>
-    inline std::size_t insert_size(I i, I j, typename
-        boost::unordered::detail::enable_if_forward<I, void*>::type = 0)
+    template <typename First, typename Second>
+    compressed(First const& x1, Second const& x2) : base1(x1), base2(x2)
     {
-        return static_cast<std::size_t>(std::distance(i, j));
     }
 
-    template <class I>
-    inline std::size_t insert_size(I, I, typename
-        boost::unordered::detail::disable_if_forward<I, void*>::type = 0)
+    compressed(compressed const& x) : base1(x.first()), base2(x.second()) {}
+
+    compressed(compressed& x, move_tag m)
+        : base1(x.first(), m), base2(x.second(), m)
     {
-        return 1;
     }
 
-    template <class I>
-    inline std::size_t initial_size(I i, I j,
-        std::size_t num_buckets =
-            boost::unordered::detail::default_bucket_count)
+    void assign(compressed const& x)
     {
-        // TODO: Why +1?
-        return (std::max)(
-            boost::unordered::detail::insert_size(i, j) + 1,
-            num_buckets);
+        first() = x.first();
+        second() = x.second();
     }
 
-    ////////////////////////////////////////////////////////////////////////////
-    // compressed
-
-    template <typename T, int Index>
-    struct compressed_base : private T
+    void move_assign(compressed& x)
     {
-        compressed_base(T const& x) : T(x) {}
-        compressed_base(T& x, move_tag) : T(boost::move(x)) {}
+        first() = boost::move(x.first());
+        second() = boost::move(x.second());
+    }
 
-        T& get() { return *this; }
-        T const& get() const { return *this; }
-    };
-
-    template <typename T, int Index>
-    struct uncompressed_base
+    void swap(compressed& x)
     {
-        uncompressed_base(T const& x) : value_(x) {}
-        uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {}
+        boost::swap(first(), x.first());
+        boost::swap(second(), x.second());
+    }
 
-        T& get() { return value_; }
-        T const& get() const { return value_; }
-    private:
-        T value_;
-    };
-
-    template <typename T, int Index>
-    struct generate_base
-      : boost::detail::if_true<
-            boost::is_empty<T>::value
-        >:: BOOST_NESTED_TEMPLATE then<
-            boost::unordered::detail::compressed_base<T, Index>,
-            boost::unordered::detail::uncompressed_base<T, Index>
-        >
-    {};
-
-    template <typename T1, typename T2>
-    struct compressed
-      : private boost::unordered::detail::generate_base<T1, 1>::type,
-        private boost::unordered::detail::generate_base<T2, 2>::type
-    {
-        typedef typename generate_base<T1, 1>::type base1;
-        typedef typename generate_base<T2, 2>::type base2;
-
-        typedef T1 first_type;
-        typedef T2 second_type;
-
-        first_type& first() {
-            return static_cast<base1*>(this)->get();
-        }
-
-        first_type const& first() const {
-            return static_cast<base1 const*>(this)->get();
-        }
-
-        second_type& second() {
-            return static_cast<base2*>(this)->get();
-        }
-
-        second_type const& second() const {
-            return static_cast<base2 const*>(this)->get();
-        }
-
-        template <typename First, typename Second>
-        compressed(First const& x1, Second const& x2)
-            : base1(x1), base2(x2) {}
-
-        compressed(compressed const& x)
-            : base1(x.first()), base2(x.second()) {}
-
-        compressed(compressed& x, move_tag m)
-            : base1(x.first(), m), base2(x.second(), m) {}
-
-        void assign(compressed const& x)
-        {
-            first() = x.first();
-            second() = x.second();
-        }
-
-        void move_assign(compressed& x)
-        {
-            first() = boost::move(x.first());
-            second() = boost::move(x.second());
-        }
-
-        void swap(compressed& x)
-        {
-            boost::swap(first(), x.first());
-            boost::swap(second(), x.second());
-        }
-
-    private:
-        // Prevent assignment just to make use of assign or
-        // move_assign explicit.
-        compressed& operator=(compressed const&);
-    };
-}}}
+  private:
+    // Prevent assignment just to make use of assign or
+    // move_assign explicit.
+    compressed& operator=(compressed const&);
+};
+}
+}
+}
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4512) // assignment operator could not be generated.
-#pragma warning(disable:4345) // behavior change: an object of POD type
-                              // constructed with an initializer of the form ()
-                              // will be default-initialized.
+#pragma warning(disable : 4512) // assignment operator could not be generated.
+#pragma warning(disable : 4345) // behavior change: an object of POD type
+// constructed with an initializer of the form ()
+// will be default-initialized.
 #endif
 
 // Maximum number of arguments supported by emplace + 1.
 #define BOOST_UNORDERED_EMPLACE_LIMIT 11
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Bits and pieces for implementing traits
+////////////////////////////////////////////////////////////////////////////
+// Bits and pieces for implementing traits
 
-    template <typename T> typename boost::add_lvalue_reference<T>::type make();
-    struct choice9 { typedef char (&type)[9]; };
-    struct choice8 : choice9 { typedef char (&type)[8]; };
-    struct choice7 : choice8 { typedef char (&type)[7]; };
-    struct choice6 : choice7 { typedef char (&type)[6]; };
-    struct choice5 : choice6 { typedef char (&type)[5]; };
-    struct choice4 : choice5 { typedef char (&type)[4]; };
-    struct choice3 : choice4 { typedef char (&type)[3]; };
-    struct choice2 : choice3 { typedef char (&type)[2]; };
-    struct choice1 : choice2 { typedef char (&type)[1]; };
-    choice1 choose();
+template <typename T> typename boost::add_lvalue_reference<T>::type make();
+struct choice9
+{
+    typedef char (&type)[9];
+};
+struct choice8 : choice9
+{
+    typedef char (&type)[8];
+};
+struct choice7 : choice8
+{
+    typedef char (&type)[7];
+};
+struct choice6 : choice7
+{
+    typedef char (&type)[6];
+};
+struct choice5 : choice6
+{
+    typedef char (&type)[5];
+};
+struct choice4 : choice5
+{
+    typedef char (&type)[4];
+};
+struct choice3 : choice4
+{
+    typedef char (&type)[3];
+};
+struct choice2 : choice3
+{
+    typedef char (&type)[2];
+};
+struct choice1 : choice2
+{
+    typedef char (&type)[1];
+};
+choice1 choose();
 
-    typedef choice1::type yes_type;
-    typedef choice2::type no_type;
+typedef choice1::type yes_type;
+typedef choice2::type no_type;
 
-    struct private_type
-    {
-       private_type const &operator,(int) const;
-    };
+struct private_type
+{
+    private_type const& operator,(int) const;
+};
 
-    template <typename T>
-    no_type is_private_type(T const&);
-    yes_type is_private_type(private_type const&);
+template <typename T> no_type is_private_type(T const&);
+yes_type is_private_type(private_type const&);
 
-    struct convert_from_anything {
-        template <typename T>
-        convert_from_anything(T const&);
-    };
+struct convert_from_anything
+{
+    template <typename T> convert_from_anything(T const&);
+};
 
-    namespace func {
-        // This is a bit nasty, when constructing the individual members
-        // of a std::pair, need to cast away 'const'. For modern compilers,
-        // should be able to use std::piecewise_construct instead.
-        template <typename T> T* const_cast_pointer(T* x) { return x; }
-        template <typename T> T* const_cast_pointer(T const* x) {
-            return const_cast<T*>(x);
-        }
-    }
+namespace func {
+// This is a bit nasty, when constructing the individual members
+// of a std::pair, need to cast away 'const'. For modern compilers,
+// should be able to use std::piecewise_construct instead.
+template <typename T> T* const_cast_pointer(T* x) { return x; }
+template <typename T> T* const_cast_pointer(T const* x)
+{
+    return const_cast<T*>(x);
+}
+}
 
-    ////////////////////////////////////////////////////////////////////////////
-    // emplace_args
-    //
-    // Either forwarding variadic arguments, or storing the arguments in
-    // emplace_args##n
+////////////////////////////////////////////////////////////////////////////
+// emplace_args
+//
+// Either forwarding variadic arguments, or storing the arguments in
+// emplace_args##n
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -359,21 +390,20 @@ namespace boost { namespace unordered { namespace detail {
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
-#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
-    typedef BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(Arg, n);         \
+#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                                  \
+    typedef BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(Arg, n);            \
     BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
 
 #else
 
-#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                               \
-    typedef typename boost::add_lvalue_reference<BOOST_PP_CAT(A, n)>::type  \
-        BOOST_PP_CAT(Arg, n);                                               \
+#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _)                                  \
+    typedef typename boost::add_lvalue_reference<BOOST_PP_CAT(A, n)>::type     \
+        BOOST_PP_CAT(Arg, n);                                                  \
     BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
 
 #endif
 
-template <typename A0>
-struct emplace_args1
+template <typename A0> struct emplace_args1
 {
     BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
 
@@ -381,15 +411,13 @@ struct emplace_args1
 };
 
 template <typename A0>
-inline emplace_args1<A0> create_emplace_args(
-        BOOST_FWD_REF(A0) b0)
+inline emplace_args1<A0> create_emplace_args(BOOST_FWD_REF(A0) b0)
 {
     emplace_args1<A0> e(b0);
     return e;
 }
 
-template <typename A0, typename A1>
-struct emplace_args2
+template <typename A0, typename A1> struct emplace_args2
 {
     BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
     BOOST_UNORDERED_EARGS_MEMBER(1, 1, _)
@@ -399,15 +427,13 @@ struct emplace_args2
 
 template <typename A0, typename A1>
 inline emplace_args2<A0, A1> create_emplace_args(
-        BOOST_FWD_REF(A0) b0,
-        BOOST_FWD_REF(A1) b1)
+    BOOST_FWD_REF(A0) b0, BOOST_FWD_REF(A1) b1)
 {
     emplace_args2<A0, A1> e(b0, b1);
     return e;
 }
 
-template <typename A0, typename A1, typename A2>
-struct emplace_args3
+template <typename A0, typename A1, typename A2> struct emplace_args3
 {
     BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
     BOOST_UNORDERED_EARGS_MEMBER(1, 1, _)
@@ -418,58 +444,53 @@ struct emplace_args3
 
 template <typename A0, typename A1, typename A2>
 inline emplace_args3<A0, A1, A2> create_emplace_args(
-        BOOST_FWD_REF(A0) b0,
-        BOOST_FWD_REF(A1) b1,
-        BOOST_FWD_REF(A2) b2)
+    BOOST_FWD_REF(A0) b0, BOOST_FWD_REF(A1) b1, BOOST_FWD_REF(A2) b2)
 {
     emplace_args3<A0, A1, A2> e(b0, b1, b2);
     return e;
 }
 
-#define BOOST_UNORDERED_FWD_PARAM(z, n, a) \
+#define BOOST_UNORDERED_FWD_PARAM(z, n, a)                                     \
     BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(a, n)
 
-#define BOOST_UNORDERED_CALL_FORWARD(z, i, a) \
-    boost::forward<BOOST_PP_CAT(A,i)>(BOOST_PP_CAT(a,i))
+#define BOOST_UNORDERED_CALL_FORWARD(z, i, a)                                  \
+    boost::forward<BOOST_PP_CAT(A, i)>(BOOST_PP_CAT(a, i))
 
-#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                 \
-BOOST_PP_CAT(a, n)(BOOST_PP_CAT(b, n))
+#define BOOST_UNORDERED_EARGS_INIT(z, n, _)                                    \
+    BOOST_PP_CAT(a, n)(BOOST_PP_CAT(b, n))
 
-#define BOOST_UNORDERED_EARGS(z, n, _)                                      \
-    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
-    struct BOOST_PP_CAT(emplace_args, n)                                    \
-    {                                                                       \
-        BOOST_PP_REPEAT_##z(n, BOOST_UNORDERED_EARGS_MEMBER, _)             \
-        BOOST_PP_CAT(emplace_args, n) (                                     \
-            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, b)                     \
-        ) : BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_EARGS_INIT, _)             \
-        {}                                                                  \
-                                                                            \
-    };                                                                      \
-                                                                            \
-    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                     \
-    inline BOOST_PP_CAT(emplace_args, n) <                                  \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
-    > create_emplace_args(                                                  \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, b)                  \
-    )                                                                       \
-    {                                                                       \
-        BOOST_PP_CAT(emplace_args, n) <                                     \
-            BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                 \
-        > e(BOOST_PP_ENUM_PARAMS_Z(z, n, b));                               \
-        return e;                                                           \
+#define BOOST_UNORDERED_EARGS(z, n, _)                                         \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    struct BOOST_PP_CAT(emplace_args, n)                                       \
+    {                                                                          \
+        BOOST_PP_REPEAT_##z(n, BOOST_UNORDERED_EARGS_MEMBER, _) BOOST_PP_CAT(  \
+            emplace_args, n)(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, b))      \
+            : BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_EARGS_INIT, _)              \
+        {                                                                      \
+        }                                                                      \
+    };                                                                         \
+                                                                               \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    inline BOOST_PP_CAT(emplace_args, n)<BOOST_PP_ENUM_PARAMS_Z(z, n, A)>      \
+        create_emplace_args(                                                   \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, b))                \
+    {                                                                          \
+        BOOST_PP_CAT(emplace_args, n)<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> e(      \
+            BOOST_PP_ENUM_PARAMS_Z(z, n, b));                                  \
+        return e;                                                              \
     }
 
-BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS,
-    _)
+BOOST_PP_REPEAT_FROM_TO(
+    4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS, _)
 
 #undef BOOST_UNORDERED_DEFINE_EMPLACE_ARGS
 #undef BOOST_UNORDERED_EARGS_MEMBER
 #undef BOOST_UNORDERED_EARGS_INIT
 
 #endif
-
-}}}
+}
+}
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -480,19 +501,19 @@ BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS,
 // 2 = boost::container::allocator_traits
 
 #if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
-#   if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#       define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 1
-#   elif defined(BOOST_MSVC)
-#       if BOOST_MSVC < 1400
-            // Use container's allocator_traits for older versions of Visual
-            // C++ as I don't test with them.
-#           define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
-#       endif
-#   endif
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 1
+#elif defined(BOOST_MSVC)
+#if BOOST_MSVC < 1400
+// Use container's allocator_traits for older versions of Visual
+// C++ as I don't test with them.
+#define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
+#endif
+#endif
 #endif
 
 #if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
-#   define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
+#define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -501,134 +522,156 @@ BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS,
 // they're always defined.
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-#  include <type_traits>
+#include <type_traits>
 #endif
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Integral_constrant, true_type, false_type
-    //
-    // Uses the standard versions if available.
+////////////////////////////////////////////////////////////////////////////
+// Integral_constrant, true_type, false_type
+//
+// Uses the standard versions if available.
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
 
-    using std::integral_constant;
-    using std::true_type;
-    using std::false_type;
+using std::integral_constant;
+using std::true_type;
+using std::false_type;
 
 #else
 
-    template <typename T, T Value>
-    struct integral_constant { enum { value = Value }; };
+template <typename T, T Value> struct integral_constant
+{
+    enum
+    {
+        value = Value
+    };
+};
 
-    typedef boost::unordered::detail::integral_constant<bool, true> true_type;
-    typedef boost::unordered::detail::integral_constant<bool, false> false_type;
+typedef boost::unordered::detail::integral_constant<bool, true> true_type;
+typedef boost::unordered::detail::integral_constant<bool, false> false_type;
 
 #endif
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Explicitly call a destructor
+////////////////////////////////////////////////////////////////////////////
+// Explicitly call a destructor
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
+#pragma warning(disable : 4100) // unreferenced formal parameter
 #endif
 
-    namespace func {
-        template <class T>
-        inline void destroy(T* x) {
-            x->~T();
-        }
-    }
+namespace func {
+template <class T> inline void destroy(T* x) { x->~T(); }
+}
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Expression test mechanism
-    //
-    // When SFINAE expressions are available, define
-    // BOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
-    // supported by a class, otherwise define BOOST_UNORDERED_HAS_MEMBER which
-    // can detect if a class has the specified member, but not that it has the
-    // correct type, this is good enough for a passable impression of
-    // allocator_traits.
+////////////////////////////////////////////////////////////////////////////
+// Expression test mechanism
+//
+// When SFINAE expressions are available, define
+// BOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
+// supported by a class, otherwise define BOOST_UNORDERED_HAS_MEMBER which
+// can detect if a class has the specified member, but not that it has the
+// correct type, this is good enough for a passable impression of
+// allocator_traits.
 
 #if !defined(BOOST_NO_SFINAE_EXPR)
 
-    template <typename T, long unsigned int> struct expr_test;
-    template <typename T> struct expr_test<T, sizeof(char)> : T {};
+template <typename T, long unsigned int> struct expr_test;
+template <typename T> struct expr_test<T, sizeof(char)> : T
+{
+};
 
-#   define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)      \
-        template <typename U>                                               \
-        static typename boost::unordered::detail::expr_test<                \
-            BOOST_PP_CAT(choice, result),                                   \
-            sizeof(for_expr_test((                                          \
-                (expression),                                               \
-            0)))>::type test(                                               \
-            BOOST_PP_CAT(choice, count))
+#define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)            \
+    template <typename U>                                                      \
+    static typename boost::unordered::detail::expr_test<BOOST_PP_CAT(          \
+                                                            choice, result),   \
+        sizeof(for_expr_test(((expression), 0)))>::type                        \
+        test(BOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                \
-        template <typename U>                                               \
-        static BOOST_PP_CAT(choice, result)::type test(                     \
-            BOOST_PP_CAT(choice, count))
+#define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                      \
+    template <typename U>                                                      \
+    static BOOST_PP_CAT(choice, result)::type test(                            \
+        BOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)               \
-    struct BOOST_PP_CAT(has_, name)                                         \
-    {                                                                       \
-        template <typename U> static char for_expr_test(U const&);          \
-        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1,                              \
-            boost::unordered::detail::make< thing >().name args);           \
-        BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                           \
-                                                                            \
-        enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };\
+#define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)                     \
+    struct BOOST_PP_CAT(has_, name)                                            \
+    {                                                                          \
+        template <typename U> static char for_expr_test(U const&);             \
+        BOOST_UNORDERED_CHECK_EXPRESSION(                                      \
+            1, 1, boost::unordered::detail::make<thing>().name args);          \
+        BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                              \
+                                                                               \
+        enum                                                                   \
+        {                                                                      \
+            value = sizeof(test<T>(choose())) == sizeof(choice1::type)         \
+        };                                                                     \
     }
 
 #else
 
-    template <typename T> struct identity { typedef T type; };
+template <typename T> struct identity
+{
+    typedef T type;
+};
 
-#   define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)        \
-                                                                            \
-    typedef typename boost::unordered::detail::identity<member>::type       \
-        BOOST_PP_CAT(check, count);                                         \
-                                                                            \
-    template <BOOST_PP_CAT(check, count) e>                                 \
-    struct BOOST_PP_CAT(test, count) {                                      \
-        typedef BOOST_PP_CAT(choice, result) type;                          \
-    };                                                                      \
-                                                                            \
-    template <class U> static typename                                      \
-        BOOST_PP_CAT(test, count)<&U::name>::type                           \
-        test(BOOST_PP_CAT(choice, count))
+#define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)              \
+                                                                               \
+    typedef typename boost::unordered::detail::identity<member>::type          \
+        BOOST_PP_CAT(check, count);                                            \
+                                                                               \
+    template <BOOST_PP_CAT(check, count) e> struct BOOST_PP_CAT(test, count)   \
+    {                                                                          \
+        typedef BOOST_PP_CAT(choice, result) type;                             \
+    };                                                                         \
+                                                                               \
+    template <class U>                                                         \
+    static typename BOOST_PP_CAT(test, count)<&U::name>::type test(            \
+        BOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_DEFAULT_MEMBER(count, result)                    \
-    template <class U> static BOOST_PP_CAT(choice, result)::type            \
-        test(BOOST_PP_CAT(choice, count))
+#define BOOST_UNORDERED_DEFAULT_MEMBER(count, result)                          \
+    template <class U>                                                         \
+    static BOOST_PP_CAT(choice, result)::type test(                            \
+        BOOST_PP_CAT(choice, count))
 
-#   define BOOST_UNORDERED_HAS_MEMBER(name)                                 \
-    struct BOOST_PP_CAT(has_, name)                                         \
-    {                                                                       \
-        struct impl {                                                       \
-            struct base_mixin { int name; };                                \
-            struct base : public T, public base_mixin {};                   \
-                                                                            \
-            BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*);    \
-            BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                           \
-                                                                            \
-            enum { value = sizeof(choice2::type) ==                         \
-                sizeof(test<base>(choose()))                                \
-            };                                                              \
-        };                                                                  \
-                                                                            \
-        enum { value = impl::value };                                       \
+#define BOOST_UNORDERED_HAS_MEMBER(name)                                       \
+    struct BOOST_PP_CAT(has_, name)                                            \
+    {                                                                          \
+        struct impl                                                            \
+        {                                                                      \
+            struct base_mixin                                                  \
+            {                                                                  \
+                int name;                                                      \
+            };                                                                 \
+            struct base : public T, public base_mixin                          \
+            {                                                                  \
+            };                                                                 \
+                                                                               \
+            BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*);       \
+            BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                              \
+                                                                               \
+            enum                                                               \
+            {                                                                  \
+                value = sizeof(choice2::type) == sizeof(test<base>(choose()))  \
+            };                                                                 \
+        };                                                                     \
+                                                                               \
+        enum                                                                   \
+        {                                                                      \
+            value = impl::value                                                \
+        };                                                                     \
     }
 
 #endif
-
-}}}
+}
+}
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -638,445 +681,434 @@ namespace boost { namespace unordered { namespace detail {
 
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
 
-#   include <boost/limits.hpp>
-#   include <boost/utility/enable_if.hpp>
-#   include <boost/pointer_to_other.hpp>
-#   if defined(BOOST_NO_SFINAE_EXPR)
-#       include <boost/type_traits/is_same.hpp>
-#   endif
+#include <boost/limits.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/pointer_to_other.hpp>
+#if defined(BOOST_NO_SFINAE_EXPR)
+#include <boost/type_traits/is_same.hpp>
+#endif
 
-#   if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-        !defined(BOOST_NO_SFINAE_EXPR)
-#       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
-#   else
-#       define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
-#   endif
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) &&                             \
+    !defined(BOOST_NO_SFINAE_EXPR)
+#define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+#else
+#define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+#endif
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    template <typename Alloc, typename T>
-    struct rebind_alloc;
+template <typename Alloc, typename T> struct rebind_alloc;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <template<typename, typename...> class Alloc,
-        typename U, typename T, typename... Args>
-    struct rebind_alloc<Alloc<U, Args...>, T>
-    {
-        typedef Alloc<T, Args...> type;
-    };
+template <template <typename, typename...> class Alloc, typename U, typename T,
+    typename... Args>
+struct rebind_alloc<Alloc<U, Args...>, T>
+{
+    typedef Alloc<T, Args...> type;
+};
 
 #else
 
-    template <
-        template<typename> class Alloc,
-        typename U, typename T>
-    struct rebind_alloc<Alloc<U>, T>
-    {
-        typedef Alloc<T> type;
-    };
+template <template <typename> class Alloc, typename U, typename T>
+struct rebind_alloc<Alloc<U>, T>
+{
+    typedef Alloc<T> type;
+};
 
-    template <
-        template<typename, typename> class Alloc,
-        typename U, typename T,
-        typename A0>
-    struct rebind_alloc<Alloc<U, A0>, T>
-    {
-        typedef Alloc<T, A0> type;
-    };
+template <template <typename, typename> class Alloc, typename U, typename T,
+    typename A0>
+struct rebind_alloc<Alloc<U, A0>, T>
+{
+    typedef Alloc<T, A0> type;
+};
 
-    template <
-        template<typename, typename, typename> class Alloc,
-        typename U, typename T,
-        typename A0, typename A1>
-    struct rebind_alloc<Alloc<U, A0, A1>, T>
-    {
-        typedef Alloc<T, A0, A1> type;
-    };
+template <template <typename, typename, typename> class Alloc, typename U,
+    typename T, typename A0, typename A1>
+struct rebind_alloc<Alloc<U, A0, A1>, T>
+{
+    typedef Alloc<T, A0, A1> type;
+};
 
 #endif
 
-    template <typename Alloc, typename T>
-    struct rebind_wrap
+template <typename Alloc, typename T> struct rebind_wrap
+{
+    template <typename X>
+    static choice1::type test(
+        choice1, typename X::BOOST_NESTED_TEMPLATE rebind<T>::other* = 0);
+    template <typename X> static choice2::type test(choice2, void* = 0);
+
+    enum
     {
-        template <typename X>
-        static choice1::type test(choice1,
-            typename X::BOOST_NESTED_TEMPLATE rebind<T>::other* = 0);
-        template <typename X>
-        static choice2::type test(choice2, void* = 0);
-
-        enum { value = (1 == sizeof(test<Alloc>(choose()))) };
-
-        struct fallback {
-            template <typename U>
-            struct rebind {
-                typedef typename rebind_alloc<Alloc, T>::type other;
-            };
-        };
-
-        typedef typename boost::detail::if_true<value>::
-            BOOST_NESTED_TEMPLATE then<Alloc, fallback>
-            ::type::BOOST_NESTED_TEMPLATE rebind<T>::other type;
+        value = (1 == sizeof(test<Alloc>(choose())))
     };
 
-#   if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+    struct fallback
+    {
+        template <typename U> struct rebind
+        {
+            typedef typename rebind_alloc<Alloc, T>::type other;
+        };
+    };
 
-#       define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
-    template <typename Tp, typename Default>                                \
-    struct default_type_ ## tname {                                         \
-                                                                            \
-        template <typename X>                                               \
-        static choice1::type test(choice1, typename X::tname* = 0);         \
-                                                                            \
-        template <typename X>                                               \
-        static choice2::type test(choice2, void* = 0);                      \
-                                                                            \
-        struct DefaultWrap { typedef Default tname; };                      \
-                                                                            \
-        enum { value = (1 == sizeof(test<Tp>(choose()))) };                 \
-                                                                            \
-        typedef typename boost::detail::if_true<value>::                    \
-            BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
-            ::type::tname type;                                             \
+    typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE then<
+        Alloc, fallback>::type::BOOST_NESTED_TEMPLATE rebind<T>::other type;
+};
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+
+#define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                              \
+    template <typename Tp, typename Default> struct default_type_##tname       \
+    {                                                                          \
+                                                                               \
+        template <typename X>                                                  \
+        static choice1::type test(choice1, typename X::tname* = 0);            \
+                                                                               \
+        template <typename X> static choice2::type test(choice2, void* = 0);   \
+                                                                               \
+        struct DefaultWrap                                                     \
+        {                                                                      \
+            typedef Default tname;                                             \
+        };                                                                     \
+                                                                               \
+        enum                                                                   \
+        {                                                                      \
+            value = (1 == sizeof(test<Tp>(choose())))                          \
+        };                                                                     \
+                                                                               \
+        typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE  \
+            then<Tp, DefaultWrap>::type::tname type;                           \
     }
 
-#   else
+#else
 
-    template <typename T, typename T2>
-    struct sfinae : T2 {};
+template <typename T, typename T2> struct sfinae : T2
+{
+};
 
-#       define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                    \
-    template <typename Tp, typename Default>                                \
-    struct default_type_ ## tname {                                         \
-                                                                            \
-        template <typename X>                                               \
-        static typename boost::unordered::detail::sfinae<                   \
-                typename X::tname, choice1>::type                           \
-            test(choice1);                                                  \
-                                                                            \
-        template <typename X>                                               \
-        static choice2::type test(choice2);                                 \
-                                                                            \
-        struct DefaultWrap { typedef Default tname; };                      \
-                                                                            \
-        enum { value = (1 == sizeof(test<Tp>(choose()))) };                 \
-                                                                            \
-        typedef typename boost::detail::if_true<value>::                    \
-            BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                     \
-            ::type::tname type;                                             \
+#define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                              \
+    template <typename Tp, typename Default> struct default_type_##tname       \
+    {                                                                          \
+                                                                               \
+        template <typename X>                                                  \
+        static typename boost::unordered::detail::sfinae<typename X::tname,    \
+            choice1>::type test(choice1);                                      \
+                                                                               \
+        template <typename X> static choice2::type test(choice2);              \
+                                                                               \
+        struct DefaultWrap                                                     \
+        {                                                                      \
+            typedef Default tname;                                             \
+        };                                                                     \
+                                                                               \
+        enum                                                                   \
+        {                                                                      \
+            value = (1 == sizeof(test<Tp>(choose())))                          \
+        };                                                                     \
+                                                                               \
+        typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE  \
+            then<Tp, DefaultWrap>::type::tname type;                           \
     }
 
-#   endif
+#endif
 
-#   define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg)                   \
-    typename default_type_ ## tname<T, arg>::type
+#define BOOST_UNORDERED_DEFAULT_TYPE(T, tname, arg)                            \
+    typename default_type_##tname<T, arg>::type
 
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
-    BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
+BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
 
-#   if !defined(BOOST_NO_SFINAE_EXPR)
+#if !defined(BOOST_NO_SFINAE_EXPR)
+
+template <typename T>
+BOOST_UNORDERED_HAS_FUNCTION(
+    select_on_container_copy_construction, U const, (), 0);
+
+template <typename T> BOOST_UNORDERED_HAS_FUNCTION(max_size, U const, (), 0);
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename T, typename ValueType, typename... Args>
+BOOST_UNORDERED_HAS_FUNCTION(
+    construct, U, (boost::unordered::detail::make<ValueType*>(),
+                      boost::unordered::detail::make<Args const>()...),
+    2);
+
+#else
+
+template <typename T, typename ValueType>
+BOOST_UNORDERED_HAS_FUNCTION(
+    construct, U, (boost::unordered::detail::make<ValueType*>(),
+                      boost::unordered::detail::make<ValueType const>()),
+    2);
+
+#endif
+
+template <typename T, typename ValueType>
+BOOST_UNORDERED_HAS_FUNCTION(
+    destroy, U, (boost::unordered::detail::make<ValueType*>()), 1);
+
+#else
+
+template <typename T>
+BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
+
+template <typename T> BOOST_UNORDERED_HAS_MEMBER(max_size);
+
+template <typename T, typename ValueType> BOOST_UNORDERED_HAS_MEMBER(construct);
+
+template <typename T, typename ValueType> BOOST_UNORDERED_HAS_MEMBER(destroy);
+
+#endif
+
+namespace func {
+
+template <typename Alloc>
+inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+    typename boost::enable_if_c<
+        boost::unordered::detail::has_select_on_container_copy_construction<
+            Alloc>::value,
+        void*>::type = 0)
+{
+    return rhs.select_on_container_copy_construction();
+}
+
+template <typename Alloc>
+inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+    typename boost::disable_if_c<
+        boost::unordered::detail::has_select_on_container_copy_construction<
+            Alloc>::value,
+        void*>::type = 0)
+{
+    return rhs;
+}
+
+template <typename SizeType, typename Alloc>
+inline SizeType call_max_size(const Alloc& a,
+    typename boost::enable_if_c<
+        boost::unordered::detail::has_max_size<Alloc>::value, void*>::type = 0)
+{
+    return a.max_size();
+}
+
+template <typename SizeType, typename Alloc>
+inline SizeType call_max_size(const Alloc&,
+    typename boost::disable_if_c<
+        boost::unordered::detail::has_max_size<Alloc>::value, void*>::type = 0)
+{
+    return (std::numeric_limits<SizeType>::max)();
+}
+
+} // namespace func.
+
+template <typename Alloc> struct allocator_traits
+{
+    typedef Alloc allocator_type;
+    typedef typename Alloc::value_type value_type;
+
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*) pointer;
 
     template <typename T>
-    BOOST_UNORDERED_HAS_FUNCTION(
-        select_on_container_copy_construction, U const, (), 0
-    );
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_FUNCTION(
-        max_size, U const, (), 0
-    );
-
-#       if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-    template <typename T, typename ValueType, typename... Args>
-    BOOST_UNORDERED_HAS_FUNCTION(
-    construct, U, (
-        boost::unordered::detail::make<ValueType*>(),
-        boost::unordered::detail::make<Args const>()...), 2
-    );
-
-#       else
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_FUNCTION(
-    construct, U, (
-        boost::unordered::detail::make<ValueType*>(),
-        boost::unordered::detail::make<ValueType const>()), 2
-    );
-
-#       endif
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_FUNCTION(
-        destroy, U, (boost::unordered::detail::make<ValueType*>()), 1
-    );
-
-#   else
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
-
-    template <typename T>
-    BOOST_UNORDERED_HAS_MEMBER(max_size);
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_MEMBER(construct);
-
-    template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_MEMBER(destroy);
-
-#   endif
-
-    namespace func
+    struct pointer_to_other : boost::pointer_to_other<pointer, T>
     {
+    };
 
-    template <typename Alloc>
-    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
-        typename boost::enable_if_c<
-            boost::unordered::detail::
-            has_select_on_container_copy_construction<Alloc>::value, void*
-        >::type = 0)
-    {
-        return rhs.select_on_container_copy_construction();
-    }
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
+        typename pointer_to_other<const value_type>::type) const_pointer;
 
-    template <typename Alloc>
-    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
-        typename boost::disable_if_c<
-            boost::unordered::detail::
-            has_select_on_container_copy_construction<Alloc>::value, void*
-        >::type = 0)
-    {
-        return rhs;
-    }
+    // typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
+    //    typename pointer_to_other<void>::type)
+    //    void_pointer;
+    //
+    // typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
+    //    typename pointer_to_other<const void>::type)
+    //    const_void_pointer;
 
-    template <typename SizeType, typename Alloc>
-    inline SizeType call_max_size(const Alloc& a,
-        typename boost::enable_if_c<
-            boost::unordered::detail::has_max_size<Alloc>::value, void*
-        >::type = 0)
-    {
-        return a.max_size();
-    }
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(
+        Alloc, difference_type, std::ptrdiff_t) difference_type;
 
-    template <typename SizeType, typename Alloc>
-    inline SizeType call_max_size(const Alloc&, typename boost::disable_if_c<
-            boost::unordered::detail::has_max_size<Alloc>::value, void*
-        >::type = 0)
-    {
-        return (std::numeric_limits<SizeType>::max)();
-    }
-
-    } // namespace func.
-
-    template <typename Alloc>
-    struct allocator_traits
-    {
-        typedef Alloc allocator_type;
-        typedef typename Alloc::value_type value_type;
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
-            pointer;
-
-        template <typename T>
-        struct pointer_to_other : boost::pointer_to_other<pointer, T> {};
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
-            typename pointer_to_other<const value_type>::type)
-            const_pointer;
-
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
-        //    typename pointer_to_other<void>::type)
-        //    void_pointer;
-        //
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
-        //    typename pointer_to_other<const void>::type)
-        //    const_void_pointer;
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
-            std::ptrdiff_t) difference_type;
-
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
-            size_type;
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(
+        Alloc, size_type, std::size_t) size_type;
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-        template <typename T>
-        using rebind_alloc = typename rebind_wrap<Alloc, T>::type;
+    template <typename T>
+    using rebind_alloc = typename rebind_wrap<Alloc, T>::type;
 
-        template <typename T>
-        using rebind_traits =
-            boost::unordered::detail::allocator_traits<rebind_alloc<T> >;
+    template <typename T>
+    using rebind_traits =
+        boost::unordered::detail::allocator_traits<rebind_alloc<T> >;
 #endif
 
-        static pointer allocate(Alloc& a, size_type n)
-            { return a.allocate(n); }
+    static pointer allocate(Alloc& a, size_type n) { return a.allocate(n); }
 
-        // I never use this, so I'll just comment it out for now.
-        //
-        //static pointer allocate(Alloc& a, size_type n,
-        //        const_void_pointer hint)
-        //    { return DEFAULT_FUNC(allocate, pointer)(a, n, hint); }
+    // I never use this, so I'll just comment it out for now.
+    //
+    // static pointer allocate(Alloc& a, size_type n,
+    //        const_void_pointer hint)
+    //    { return DEFAULT_FUNC(allocate, pointer)(a, n, hint); }
 
-        static void deallocate(Alloc& a, pointer p, size_type n)
-            { a.deallocate(p, n); }
+    static void deallocate(Alloc& a, pointer p, size_type n)
+    {
+        a.deallocate(p, n);
+    }
 
-    public:
+  public:
+#if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
 
-#   if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+    template <typename T, typename... Args>
+    static typename boost::enable_if_c<
+        boost::unordered::detail::has_construct<Alloc, T, Args...>::value>::type
+    construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
+    {
+        a.construct(p, boost::forward<Args>(x)...);
+    }
 
-        template <typename T, typename... Args>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T, Args...>
-                ::value>::type
-            construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
-        {
-            a.construct(p, boost::forward<Args>(x)...);
-        }
+    template <typename T, typename... Args>
+    static typename boost::disable_if_c<
+        boost::unordered::detail::has_construct<Alloc, T, Args...>::value>::type
+    construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
+    {
+        new (static_cast<void*>(p)) T(boost::forward<Args>(x)...);
+    }
 
-        template <typename T, typename... Args>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T, Args...>
-                ::value>::type
-            construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
-        {
-            new (static_cast<void*>(p)) T(boost::forward<Args>(x)...);
-        }
+    template <typename T>
+    static typename boost::enable_if_c<
+        boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+    destroy(Alloc& a, T* p)
+    {
+        a.destroy(p);
+    }
 
-        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc& a, T* p)
-        {
-            a.destroy(p);
-        }
+    template <typename T>
+    static typename boost::disable_if_c<
+        boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+    destroy(Alloc&, T* p)
+    {
+        boost::unordered::detail::func::destroy(p);
+    }
 
-        template <typename T>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc&, T* p)
-        {
-            boost::unordered::detail::func::destroy(p);
-        }
+#elif !defined(BOOST_NO_SFINAE_EXPR)
 
-#   elif !defined(BOOST_NO_SFINAE_EXPR)
+    template <typename T>
+    static typename boost::enable_if_c<
+        boost::unordered::detail::has_construct<Alloc, T>::value>::type
+    construct(Alloc& a, T* p, T const& x)
+    {
+        a.construct(p, x);
+    }
 
-        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value>::type
-            construct(Alloc& a, T* p, T const& x)
-        {
-            a.construct(p, x);
-        }
+    template <typename T>
+    static typename boost::disable_if_c<
+        boost::unordered::detail::has_construct<Alloc, T>::value>::type
+    construct(Alloc&, T* p, T const& x)
+    {
+        new (static_cast<void*>(p)) T(x);
+    }
 
-        template <typename T>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value>::type
-            construct(Alloc&, T* p, T const& x)
-        {
-            new (static_cast<void*>(p)) T(x);
-        }
+    template <typename T>
+    static typename boost::enable_if_c<
+        boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+    destroy(Alloc& a, T* p)
+    {
+        a.destroy(p);
+    }
 
-        template <typename T>
-        static typename boost::enable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc& a, T* p)
-        {
-            a.destroy(p);
-        }
+    template <typename T>
+    static typename boost::disable_if_c<
+        boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+    destroy(Alloc&, T* p)
+    {
+        boost::unordered::detail::func::destroy(p);
+    }
 
-        template <typename T>
-        static typename boost::disable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
-            destroy(Alloc&, T* p)
-        {
-            boost::unordered::detail::func::destroy(p);
-        }
+#else
 
-#   else
+    // If we don't have SFINAE expressions, only call construct for the
+    // copy constructor for the allocator's value_type - as that's
+    // the only construct method that old fashioned allocators support.
 
-        // If we don't have SFINAE expressions, only call construct for the
-        // copy constructor for the allocator's value_type - as that's
-        // the only construct method that old fashioned allocators support.
-
-        template <typename T>
-        static void construct(Alloc& a, T* p, T const& x,
-            typename boost::enable_if_c<
-                    boost::unordered::detail::has_construct<Alloc, T>::value &&
-                    boost::is_same<T, value_type>::value,
-                    void*>::type = 0)
-        {
-            a.construct(p, x);
-        }
-
-        template <typename T>
-        static void construct(Alloc&, T* p, T const& x,
-            typename boost::disable_if_c<
-                boost::unordered::detail::has_construct<Alloc, T>::value &&
+    template <typename T>
+    static void construct(Alloc& a, T* p, T const& x,
+        typename boost::enable_if_c<
+            boost::unordered::detail::has_construct<Alloc, T>::value &&
                 boost::is_same<T, value_type>::value,
-                void*>::type = 0)
-        {
-            new (static_cast<void*>(p)) T(x);
-        }
+            void*>::type = 0)
+    {
+        a.construct(p, x);
+    }
 
-        template <typename T>
-        static void destroy(Alloc& a, T* p,
-            typename boost::enable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value &&
+    template <typename T>
+    static void construct(Alloc&, T* p, T const& x,
+        typename boost::disable_if_c<
+            boost::unordered::detail::has_construct<Alloc, T>::value &&
                 boost::is_same<T, value_type>::value,
-                void*>::type = 0)
-        {
-            a.destroy(p);
-        }
+            void*>::type = 0)
+    {
+        new (static_cast<void*>(p)) T(x);
+    }
 
-        template <typename T>
-        static void destroy(Alloc&, T* p,
-            typename boost::disable_if_c<
-                boost::unordered::detail::has_destroy<Alloc, T>::value &&
+    template <typename T>
+    static void destroy(Alloc& a, T* p,
+        typename boost::enable_if_c<
+            boost::unordered::detail::has_destroy<Alloc, T>::value &&
                 boost::is_same<T, value_type>::value,
-                void*>::type = 0)
-        {
-            boost::unordered::detail::func::destroy(p);
-        }
+            void*>::type = 0)
+    {
+        a.destroy(p);
+    }
 
-#   endif
+    template <typename T>
+    static void destroy(Alloc&, T* p,
+        typename boost::disable_if_c<
+            boost::unordered::detail::has_destroy<Alloc, T>::value &&
+                boost::is_same<T, value_type>::value,
+            void*>::type = 0)
+    {
+        boost::unordered::detail::func::destroy(p);
+    }
 
-        static size_type max_size(const Alloc& a)
-        {
-            return boost::unordered::detail::func::
-                call_max_size<size_type>(a);
-        }
+#endif
 
-        // Allocator propagation on construction
+    static size_type max_size(const Alloc& a)
+    {
+        return boost::unordered::detail::func::call_max_size<size_type>(a);
+    }
 
-        static Alloc select_on_container_copy_construction(Alloc const& rhs)
-        {
-            return boost::unordered::detail::func::
-                call_select_on_container_copy_construction(rhs);
-        }
+    // Allocator propagation on construction
 
-        // Allocator propagation on assignment and swap.
-        // Return true if lhs is modified.
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
-            Alloc, propagate_on_container_copy_assignment, false_type)
-            propagate_on_container_copy_assignment;
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
-            Alloc,propagate_on_container_move_assignment, false_type)
-            propagate_on_container_move_assignment;
-        typedef BOOST_UNORDERED_DEFAULT_TYPE(
-            Alloc,propagate_on_container_swap,false_type)
-            propagate_on_container_swap;
-    };
-}}}
+    static Alloc select_on_container_copy_construction(Alloc const& rhs)
+    {
+        return boost::unordered::detail::func::
+            call_select_on_container_copy_construction(rhs);
+    }
 
-#   undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
-#   undef BOOST_UNORDERED_DEFAULT_TYPE
+    // Allocator propagation on assignment and swap.
+    // Return true if lhs is modified.
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc,
+        propagate_on_container_copy_assignment,
+        false_type) propagate_on_container_copy_assignment;
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc,
+        propagate_on_container_move_assignment,
+        false_type) propagate_on_container_move_assignment;
+    typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, propagate_on_container_swap,
+        false_type) propagate_on_container_swap;
+};
+}
+}
+}
+
+#undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
+#undef BOOST_UNORDERED_DEFAULT_TYPE
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -1084,22 +1116,26 @@ namespace boost { namespace unordered { namespace detail {
 
 #elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
 
-#   include <memory>
+#include <memory>
 
-#   define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+#define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    template <typename Alloc>
-    struct allocator_traits : std::allocator_traits<Alloc> {};
+template <typename Alloc> struct allocator_traits : std::allocator_traits<Alloc>
+{
+};
 
-    template <typename Alloc, typename T>
-    struct rebind_wrap
-    {
-        typedef typename std::allocator_traits<Alloc>::
-            template rebind_alloc<T> type;
-    };
-}}}
+template <typename Alloc, typename T> struct rebind_wrap
+{
+    typedef typename std::allocator_traits<Alloc>::template rebind_alloc<T>
+        type;
+};
+}
+}
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -1107,23 +1143,27 @@ namespace boost { namespace unordered { namespace detail {
 
 #elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
 
-#   include <boost/container/allocator_traits.hpp>
+#include <boost/container/allocator_traits.hpp>
 
-#   define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+#define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    template <typename Alloc>
-    struct allocator_traits :
-        boost::container::allocator_traits<Alloc> {};
+template <typename Alloc>
+struct allocator_traits : boost::container::allocator_traits<Alloc>
+{
+};
 
-    template <typename Alloc, typename T>
-    struct rebind_wrap :
-        boost::container::allocator_traits<Alloc>::
-            template portable_rebind_alloc<T>
-    {};
-
-}}}
+template <typename Alloc, typename T>
+struct rebind_wrap : boost::container::allocator_traits<
+                         Alloc>::template portable_rebind_alloc<T>
+{
+};
+}
+}
+}
 
 #else
 
@@ -1131,162 +1171,156 @@ namespace boost { namespace unordered { namespace detail {
 
 #endif
 
+namespace boost {
+namespace unordered {
+namespace detail {
+namespace func {
 
-namespace boost { namespace unordered { namespace detail { namespace func {
-
-    ////////////////////////////////////////////////////////////////////////////
-    // call_construct
+////////////////////////////////////////////////////////////////////////////
+// call_construct
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#   if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+#if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
 
-    template <typename Alloc, typename T, typename... Args>
-    inline void call_construct(Alloc& alloc, T* address,
-        BOOST_FWD_REF(Args)... args)
-    {
-        boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
-            address, boost::forward<Args>(args)...);
-    }
+template <typename Alloc, typename T, typename... Args>
+inline void call_construct(
+    Alloc& alloc, T* address, BOOST_FWD_REF(Args)... args)
+{
+    boost::unordered::detail::allocator_traits<Alloc>::construct(
+        alloc, address, boost::forward<Args>(args)...);
+}
 
-    template <typename Alloc, typename T>
-    inline void call_destroy(Alloc& alloc, T* x) {
-        boost::unordered::detail::allocator_traits<Alloc>::destroy(alloc, x);
-    }
-
-
-#   else
-
-    template <typename Alloc, typename T, typename... Args>
-    inline void call_construct(Alloc&, T* address,
-        BOOST_FWD_REF(Args)... args)
-    {
-        new((void*) address) T(boost::forward<Args>(args)...);
-    }
-
-    template <typename Alloc, typename T>
-    inline void call_destroy(Alloc&, T* x) {
-        boost::unordered::detail::func::destroy(x);
-    }
-
-
-#   endif
+template <typename Alloc, typename T>
+inline void call_destroy(Alloc& alloc, T* x)
+{
+    boost::unordered::detail::allocator_traits<Alloc>::destroy(alloc, x);
+}
 
 #else
-    template <typename Alloc, typename T>
-    inline void call_construct(Alloc&, T* address)
-    {
-        new ((void*) address) T();
-    }
 
-    template <typename Alloc, typename T, typename A0>
-    inline void call_construct(Alloc&, T* address,
-        BOOST_FWD_REF(A0) a0)
-    {
-        new ((void*) address) T(boost::forward<A0>(a0));
-    }
+template <typename Alloc, typename T, typename... Args>
+inline void call_construct(Alloc&, T* address, BOOST_FWD_REF(Args)... args)
+{
+    new ((void*)address) T(boost::forward<Args>(args)...);
+}
 
-    template <typename Alloc, typename T>
-    inline void call_destroy(Alloc&, T* x) {
-        boost::unordered::detail::func::destroy(x);
-    }
+template <typename Alloc, typename T> inline void call_destroy(Alloc&, T* x)
+{
+    boost::unordered::detail::func::destroy(x);
+}
 
 #endif
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Construct from tuple
-    //
-    // Used for piecewise construction.
+#else
+template <typename Alloc, typename T>
+inline void call_construct(Alloc&, T* address)
+{
+    new ((void*)address) T();
+}
+
+template <typename Alloc, typename T, typename A0>
+inline void call_construct(Alloc&, T* address, BOOST_FWD_REF(A0) a0)
+{
+    new ((void*)address) T(boost::forward<A0>(a0));
+}
+
+template <typename Alloc, typename T> inline void call_destroy(Alloc&, T* x)
+{
+    boost::unordered::detail::func::destroy(x);
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////
+// Construct from tuple
+//
+// Used for piecewise construction.
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
-    template<typename Alloc, typename T>                                    \
-    void construct_from_tuple(Alloc& alloc, T* ptr, namespace_ tuple<>)     \
-    {                                                                       \
-        boost::unordered::detail::func::call_construct(alloc, ptr);         \
-    }                                                                       \
-                                                                            \
-    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
-        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)                    \
+    template <typename Alloc, typename T>                                      \
+    void construct_from_tuple(Alloc& alloc, T* ptr, namespace_ tuple<>)        \
+    {                                                                          \
+        boost::unordered::detail::func::call_construct(alloc, ptr);            \
+    }                                                                          \
+                                                                               \
+    BOOST_PP_REPEAT_FROM_TO(                                                   \
+        1, n, BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
-    template<typename Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
-    void construct_from_tuple(Alloc& alloc, T* ptr,                         \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
-    {                                                                       \
-        boost::unordered::detail::func::call_construct(alloc, ptr,          \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
-        );                                                                  \
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)            \
+    template <typename Alloc, typename T,                                      \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                              \
+    void construct_from_tuple(Alloc& alloc, T* ptr,                            \
+        namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)            \
+    {                                                                          \
+        boost::unordered::detail::func::call_construct(alloc, ptr,             \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_));  \
     }
 
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
-    namespace_ get<n>(x)
+#define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) namespace_ get<n>(x)
 
 #elif !defined(__SUNPRO_CC)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
-    template<typename Alloc, typename T>                                    \
-    void construct_from_tuple(Alloc&, T* ptr, namespace_ tuple<>)           \
-    {                                                                       \
-        new ((void*) ptr) T();                                              \
-    }                                                                       \
-                                                                            \
-    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
-        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)                    \
+    template <typename Alloc, typename T>                                      \
+    void construct_from_tuple(Alloc&, T* ptr, namespace_ tuple<>)              \
+    {                                                                          \
+        new ((void*)ptr) T();                                                  \
+    }                                                                          \
+                                                                               \
+    BOOST_PP_REPEAT_FROM_TO(                                                   \
+        1, n, BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
-    template<typename Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
-    void construct_from_tuple(Alloc&, T* ptr,                               \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
-    {                                                                       \
-        new ((void*) ptr) T(                                                \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
-        );                                                                  \
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)            \
+    template <typename Alloc, typename T,                                      \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                              \
+    void construct_from_tuple(Alloc&, T* ptr,                                  \
+        namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)            \
+    {                                                                          \
+        new ((void*)ptr) T(                                                    \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_));  \
     }
 
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
-    namespace_ get<n>(x)
+#define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) namespace_ get<n>(x)
 
 #else
 
-    template <int N> struct length {};
+template <int N> struct length
+{
+};
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)              \
-    template<typename Alloc, typename T>                                    \
-    void construct_from_tuple_impl(                                         \
-            boost::unordered::detail::func::length<0>, Alloc&, T* ptr,      \
-            namespace_ tuple<>)                                             \
-    {                                                                       \
-        new ((void*) ptr) T();                                              \
-    }                                                                       \
-                                                                            \
-    BOOST_PP_REPEAT_FROM_TO(1, n,                                           \
-        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_)                    \
+    template <typename Alloc, typename T>                                      \
+    void construct_from_tuple_impl(boost::unordered::detail::func::length<0>,  \
+        Alloc&, T* ptr, namespace_ tuple<>)                                    \
+    {                                                                          \
+        new ((void*)ptr) T();                                                  \
+    }                                                                          \
+                                                                               \
+    BOOST_PP_REPEAT_FROM_TO(                                                   \
+        1, n, BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
 
-#   define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)      \
-    template<typename Alloc, typename T,                                    \
-        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                           \
-    void construct_from_tuple_impl(                                         \
-            boost::unordered::detail::func::length<n>, Alloc&, T* ptr,      \
-            namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)     \
-    {                                                                       \
-        new ((void*) ptr) T(                                                \
-            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
-        );                                                                  \
+#define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_)            \
+    template <typename Alloc, typename T,                                      \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                              \
+    void construct_from_tuple_impl(boost::unordered::detail::func::length<n>,  \
+        Alloc&, T* ptr,                                                        \
+        namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x)            \
+    {                                                                          \
+        new ((void*)ptr) T(                                                    \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_));  \
     }
 
-#   define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_)                  \
-    namespace_ get<n>(x)
+#define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) namespace_ get<n>(x)
 
 #endif
 
 BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
 
 #if !defined(__SUNPRO_CC) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
-   BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::)
+BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::)
 #endif
 
 #undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
@@ -1295,1696 +1329,1693 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
 
 #if defined(__SUNPRO_CC)
 
-    template <typename Alloc, typename T, typename Tuple>
-    void construct_from_tuple(Alloc& alloc, T* ptr, Tuple const& x)
-    {
-        construct_from_tuple_impl(
-            boost::unordered::detail::func::length<
-                boost::tuples::length<Tuple>::value>(),
-            alloc, ptr, x);
-    }
+template <typename Alloc, typename T, typename Tuple>
+void construct_from_tuple(Alloc& alloc, T* ptr, Tuple const& x)
+{
+    construct_from_tuple_impl(boost::unordered::detail::func::length<
+                                  boost::tuples::length<Tuple>::value>(),
+        alloc, ptr, x);
+}
 
 #endif
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Trait to check for piecewise construction.
+////////////////////////////////////////////////////////////////////////////
+// Trait to check for piecewise construction.
 
-    template <typename A0>
-    struct use_piecewise {
-        static choice1::type test(choice1,
-            boost::unordered::piecewise_construct_t);
+template <typename A0> struct use_piecewise
+{
+    static choice1::type test(choice1, boost::unordered::piecewise_construct_t);
 
-        static choice2::type test(choice2, ...);
+    static choice2::type test(choice2, ...);
 
-        enum { value = sizeof(choice1::type) ==
-            sizeof(test(choose(), boost::unordered::detail::make<A0>())) };
+    enum
+    {
+        value = sizeof(choice1::type) ==
+                sizeof(test(choose(), boost::unordered::detail::make<A0>()))
     };
+};
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Construct from variadic parameters
+////////////////////////////////////////////////////////////////////////////
+// Construct from variadic parameters
 
-    // For the standard pair constructor.
+// For the standard pair constructor.
 
-    template <typename Alloc, typename T, typename... Args>
-    inline void construct_from_args(Alloc& alloc, T* address,
-        BOOST_FWD_REF(Args)... args)
+template <typename Alloc, typename T, typename... Args>
+inline void construct_from_args(
+    Alloc& alloc, T* address, BOOST_FWD_REF(Args)... args)
+{
+    boost::unordered::detail::func::call_construct(
+        alloc, address, boost::forward<Args>(args)...);
+}
+
+// Special case for piece_construct
+//
+// TODO: When possible, it might be better to use std::pair's
+// constructor for std::piece_construct with std::tuple.
+
+template <typename Alloc, typename A, typename B, typename A0, typename A1,
+    typename A2>
+inline typename enable_if<use_piecewise<A0>, void>::type construct_from_args(
+    Alloc& alloc, std::pair<A, B>* address, BOOST_FWD_REF(A0),
+    BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+{
+    boost::unordered::detail::func::construct_from_tuple(
+        alloc, boost::unordered::detail::func::const_cast_pointer(
+                   boost::addressof(address->first)),
+        boost::forward<A1>(a1));
+    BOOST_TRY
     {
-        boost::unordered::detail::func::call_construct(alloc,
-            address, boost::forward<Args>(args)...);
+        boost::unordered::detail::func::construct_from_tuple(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(address->second)),
+            boost::forward<A2>(a2));
     }
-
-    // Special case for piece_construct
-    //
-    // TODO: When possible, it might be better to use std::pair's
-    // constructor for std::piece_construct with std::tuple.
-
-    template <typename Alloc, typename A, typename B,
-        typename A0, typename A1, typename A2>
-    inline typename enable_if<use_piecewise<A0>, void>::type
-        construct_from_args(Alloc& alloc, std::pair<A, B>* address,
-            BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    BOOST_CATCH(...)
     {
-        boost::unordered::detail::func::construct_from_tuple(alloc,
-            boost::unordered::detail::func::const_cast_pointer(
-                boost::addressof(address->first)),
-            boost::forward<A1>(a1));
-        BOOST_TRY {
-            boost::unordered::detail::func::construct_from_tuple(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(address->second)),
-                boost::forward<A2>(a2));
-        }
-        BOOST_CATCH(...) {
-            boost::unordered::detail::func::call_destroy(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(address->first)));
-            BOOST_RETHROW;
-        }
-        BOOST_CATCH_END
+        boost::unordered::detail::func::call_destroy(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(address->first)));
+        BOOST_RETHROW;
     }
+    BOOST_CATCH_END
+}
 
 #else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Construct from emplace_args
+////////////////////////////////////////////////////////////////////////////
+// Construct from emplace_args
 
-    // Explicitly write out first three overloads for the sake of sane
-    // error messages.
+// Explicitly write out first three overloads for the sake of sane
+// error messages.
 
-    template <typename Alloc, typename T, typename A0>
-    inline void construct_from_args(Alloc&, T* address,
-            emplace_args1<A0> const& args)
-    {
-        new((void*) address) T(boost::forward<A0>(args.a0));
+template <typename Alloc, typename T, typename A0>
+inline void construct_from_args(
+    Alloc&, T* address, emplace_args1<A0> const& args)
+{
+    new ((void*)address) T(boost::forward<A0>(args.a0));
+}
+
+template <typename Alloc, typename T, typename A0, typename A1>
+inline void construct_from_args(
+    Alloc&, T* address, emplace_args2<A0, A1> const& args)
+{
+    new ((void*)address)
+        T(boost::forward<A0>(args.a0), boost::forward<A1>(args.a1));
+}
+
+template <typename Alloc, typename T, typename A0, typename A1, typename A2>
+inline void construct_from_args(
+    Alloc&, T* address, emplace_args3<A0, A1, A2> const& args)
+{
+    new ((void*)address) T(boost::forward<A0>(args.a0),
+        boost::forward<A1>(args.a1), boost::forward<A2>(args.a2));
+}
+
+// Use a macro for the rest.
+
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                       \
+    template <typename Alloc, typename T,                                      \
+        BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)>                     \
+    inline void construct_from_args(Alloc&, T* address,                        \
+        boost::unordered::detail::BOOST_PP_CAT(emplace_args, num_params) <     \
+            BOOST_PP_ENUM_PARAMS_Z(z, num_params, A) > const& args)            \
+    {                                                                          \
+        new ((void*)address) T(BOOST_PP_ENUM_##z(                              \
+            num_params, BOOST_UNORDERED_CALL_FORWARD, args.a));                \
     }
 
-    template <typename Alloc, typename T, typename A0, typename A1>
-    inline void construct_from_args(Alloc&, T* address,
-            emplace_args2<A0, A1> const& args)
-    {
-        new((void*) address) T(
-            boost::forward<A0>(args.a0),
-            boost::forward<A1>(args.a1)
-        );
-    }
-
-    template <typename Alloc, typename T, typename A0, typename A1, typename A2>
-    inline void construct_from_args(Alloc&, T* address,
-            emplace_args3<A0, A1, A2> const& args)
-    {
-        new((void*) address) T(
-            boost::forward<A0>(args.a0),
-            boost::forward<A1>(args.a1),
-            boost::forward<A2>(args.a2)
-        );
-    }
-
-    // Use a macro for the rest.
-
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                    \
-    template <                                                              \
-        typename Alloc, typename T,                                         \
-        BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A)                   \
-    >                                                                       \
-    inline void construct_from_args(Alloc&, T* address,                     \
-        boost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) <   \
-            BOOST_PP_ENUM_PARAMS_Z(z, num_params, A)                        \
-        > const& args)                                                      \
-    {                                                                       \
-        new((void*) address) T(                                             \
-            BOOST_PP_ENUM_##z(num_params, BOOST_UNORDERED_CALL_FORWARD,     \
-                args.a));                                                   \
-    }
-
-    BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-        BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+BOOST_PP_REPEAT_FROM_TO(
+    4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_CONSTRUCT_IMPL, _)
 
 #undef BOOST_UNORDERED_CONSTRUCT_IMPL
 
-    // Construct with piece_construct
+// Construct with piece_construct
 
-    template <typename Alloc, typename A, typename B,
-        typename A0, typename A1, typename A2>
-    inline void construct_from_args(Alloc& alloc, std::pair<A, B>* address,
-            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
-            typename enable_if<use_piecewise<A0>, void*>::type = 0)
+template <typename Alloc, typename A, typename B, typename A0, typename A1,
+    typename A2>
+inline void construct_from_args(Alloc& alloc, std::pair<A, B>* address,
+    boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+    typename enable_if<use_piecewise<A0>, void*>::type = 0)
+{
+    boost::unordered::detail::func::construct_from_tuple(
+        alloc, boost::unordered::detail::func::const_cast_pointer(
+                   boost::addressof(address->first)),
+        args.a1);
+    BOOST_TRY
     {
-        boost::unordered::detail::func::construct_from_tuple(alloc,
-            boost::unordered::detail::func::const_cast_pointer(
-                boost::addressof(address->first)),
-            args.a1);
-        BOOST_TRY {
-            boost::unordered::detail::func::construct_from_tuple(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(address->second)),
-                args.a2);
-        }
-        BOOST_CATCH(...) {
-            boost::unordered::detail::func::call_destroy(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(address->first)));
-            BOOST_RETHROW;
-        }
-        BOOST_CATCH_END
+        boost::unordered::detail::func::construct_from_tuple(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(address->second)),
+            args.a2);
     }
+    BOOST_CATCH(...)
+    {
+        boost::unordered::detail::func::call_destroy(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(address->first)));
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+}
 
 #endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+}
+}
+}
+}
 
-}}}}
+namespace boost {
+namespace unordered {
+namespace detail {
 
-namespace boost { namespace unordered { namespace detail {
+///////////////////////////////////////////////////////////////////
+//
+// Node construction
 
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Node construction
+template <typename NodeAlloc> struct node_constructor
+{
+    typedef NodeAlloc node_allocator;
+    typedef boost::unordered::detail::allocator_traits<NodeAlloc>
+        node_allocator_traits;
+    typedef typename node_allocator_traits::value_type node;
+    typedef typename node_allocator_traits::pointer node_pointer;
+    typedef typename node::value_type value_type;
 
-    template <typename NodeAlloc>
-    struct node_constructor
+    node_allocator& alloc_;
+    node_pointer node_;
+    bool node_constructed_;
+
+    node_constructor(node_allocator& n)
+        : alloc_(n), node_(), node_constructed_(false)
     {
-        typedef NodeAlloc node_allocator;
-        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
-            node_allocator_traits;
-        typedef typename node_allocator_traits::value_type node;
-        typedef typename node_allocator_traits::pointer node_pointer;
-        typedef typename node::value_type value_type;
-
-        node_allocator& alloc_;
-        node_pointer node_;
-        bool node_constructed_;
-
-        node_constructor(node_allocator& n) :
-            alloc_(n),
-            node_(),
-            node_constructed_(false)
-        {
-        }
-
-        ~node_constructor();
-
-        void create_node();
-
-        // no throw
-        node_pointer release()
-        {
-            BOOST_ASSERT(node_ && node_constructed_);
-            node_pointer p = node_;
-            node_ = node_pointer();
-            return p;
-        }
-
-        void reclaim(node_pointer p) {
-            BOOST_ASSERT(!node_);
-            node_ = p;
-            node_constructed_ = true;
-            boost::unordered::detail::func::call_destroy(alloc_,
-                node_->value_ptr());
-        }
-
-    private:
-        node_constructor(node_constructor const&);
-        node_constructor& operator=(node_constructor const&);
-    };
-
-    template <typename Alloc>
-    node_constructor<Alloc>::~node_constructor()
-    {
-        if (node_) {
-            if (node_constructed_) {
-                boost::unordered::detail::func::destroy(
-                    boost::addressof(*node_));
-            }
-
-            node_allocator_traits::deallocate(alloc_, node_, 1);
-        }
     }
 
-    template <typename Alloc>
-    void node_constructor<Alloc>::create_node()
+    ~node_constructor();
+
+    void create_node();
+
+    // no throw
+    node_pointer release()
+    {
+        BOOST_ASSERT(node_ && node_constructed_);
+        node_pointer p = node_;
+        node_ = node_pointer();
+        return p;
+    }
+
+    void reclaim(node_pointer p)
     {
         BOOST_ASSERT(!node_);
-        node_constructed_ = false;
-
-        node_ = node_allocator_traits::allocate(alloc_, 1);
-
-        new ((void*) boost::addressof(*node_)) node();
-        node_->init(node_);
+        node_ = p;
         node_constructed_ = true;
+        boost::unordered::detail::func::call_destroy(
+            alloc_, node_->value_ptr());
     }
 
-    template <typename NodeAlloc>
-    struct node_tmp
-    {
-        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
-            node_allocator_traits;
-        typedef typename node_allocator_traits::pointer node_pointer;
+  private:
+    node_constructor(node_constructor const&);
+    node_constructor& operator=(node_constructor const&);
+};
 
-        NodeAlloc& alloc_;
-        node_pointer node_;
-
-        explicit node_tmp(node_pointer n, NodeAlloc& a):
-            alloc_(a),
-            node_(n)
-        {
+template <typename Alloc> node_constructor<Alloc>::~node_constructor()
+{
+    if (node_) {
+        if (node_constructed_) {
+            boost::unordered::detail::func::destroy(boost::addressof(*node_));
         }
 
-        ~node_tmp();
-
-        // no throw
-        node_pointer release()
-        {
-            node_pointer p = node_;
-            node_ = node_pointer();
-            return p;
-        }
-    };
-
-    template <typename Alloc>
-    node_tmp<Alloc>::~node_tmp()
-    {
-        if (node_) {
-            boost::unordered::detail::func::call_destroy(alloc_,
-                node_->value_ptr());
-            boost::unordered::detail::func::destroy(
-                boost::addressof(*node_));
-            node_allocator_traits::deallocate(alloc_, node_, 1);
-        }
+        node_allocator_traits::deallocate(alloc_, node_, 1);
     }
-}}}
+}
 
-namespace boost { namespace unordered { namespace detail { namespace func {
+template <typename Alloc> void node_constructor<Alloc>::create_node()
+{
+    BOOST_ASSERT(!node_);
+    node_constructed_ = false;
 
-    // Some nicer construct_node functions, might try to
-    // improve implementation later.
+    node_ = node_allocator_traits::allocate(alloc_, 1);
 
-    template <typename Alloc, BOOST_UNORDERED_EMPLACE_TEMPLATE>
-    inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
-    construct_node_from_args(Alloc& alloc, BOOST_UNORDERED_EMPLACE_ARGS)
+    new ((void*)boost::addressof(*node_)) node();
+    node_->init(node_);
+    node_constructed_ = true;
+}
+
+template <typename NodeAlloc> struct node_tmp
+{
+    typedef boost::unordered::detail::allocator_traits<NodeAlloc>
+        node_allocator_traits;
+    typedef typename node_allocator_traits::pointer node_pointer;
+
+    NodeAlloc& alloc_;
+    node_pointer node_;
+
+    explicit node_tmp(node_pointer n, NodeAlloc& a) : alloc_(a), node_(n) {}
+
+    ~node_tmp();
+
+    // no throw
+    node_pointer release()
     {
-        node_constructor<Alloc> a(alloc);
-        a.create_node();
-        construct_from_args(alloc, a.node_->value_ptr(),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
-        return a.release();
+        node_pointer p = node_;
+        node_ = node_pointer();
+        return p;
     }
+};
 
-    template <typename Alloc, typename U>
-    inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
-    construct_node(Alloc& alloc, BOOST_FWD_REF(U) x)
+template <typename Alloc> node_tmp<Alloc>::~node_tmp()
+{
+    if (node_) {
+        boost::unordered::detail::func::call_destroy(
+            alloc_, node_->value_ptr());
+        boost::unordered::detail::func::destroy(boost::addressof(*node_));
+        node_allocator_traits::deallocate(alloc_, node_, 1);
+    }
+}
+}
+}
+}
+
+namespace boost {
+namespace unordered {
+namespace detail {
+namespace func {
+
+// Some nicer construct_node functions, might try to
+// improve implementation later.
+
+template <typename Alloc, BOOST_UNORDERED_EMPLACE_TEMPLATE>
+inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
+construct_node_from_args(Alloc& alloc, BOOST_UNORDERED_EMPLACE_ARGS)
+{
+    node_constructor<Alloc> a(alloc);
+    a.create_node();
+    construct_from_args(
+        alloc, a.node_->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
+    return a.release();
+}
+
+template <typename Alloc, typename U>
+inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
+construct_node(Alloc& alloc, BOOST_FWD_REF(U) x)
+{
+    node_constructor<Alloc> a(alloc);
+    a.create_node();
+    boost::unordered::detail::func::call_construct(
+        alloc, a.node_->value_ptr(), boost::forward<U>(x));
+    return a.release();
+}
+
+// TODO: When possible, it might be better to use std::pair's
+// constructor for std::piece_construct with std::tuple.
+template <typename Alloc, typename Key>
+inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
+construct_node_pair(Alloc& alloc, BOOST_FWD_REF(Key) k)
+{
+    node_constructor<Alloc> a(alloc);
+    a.create_node();
+    boost::unordered::detail::func::call_construct(
+        alloc, boost::unordered::detail::func::const_cast_pointer(
+                   boost::addressof(a.node_->value_ptr()->first)),
+        boost::forward<Key>(k));
+    BOOST_TRY
     {
-        node_constructor<Alloc> a(alloc);
-        a.create_node();
         boost::unordered::detail::func::call_construct(
-                alloc, a.node_->value_ptr(), boost::forward<U>(x));
-        return a.release();
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(a.node_->value_ptr()->second)));
     }
-
-    // TODO: When possible, it might be better to use std::pair's
-    // constructor for std::piece_construct with std::tuple.
-    template <typename Alloc, typename Key>
-    inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
-    construct_node_pair(Alloc& alloc, BOOST_FWD_REF(Key) k)
+    BOOST_CATCH(...)
     {
-        node_constructor<Alloc> a(alloc);
-        a.create_node();
-        boost::unordered::detail::func::call_construct(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(a.node_->value_ptr()->first)),
-                boost::forward<Key>(k));
-        BOOST_TRY {
-            boost::unordered::detail::func::call_construct(alloc,
-                    boost::unordered::detail::func::const_cast_pointer(
-                        boost::addressof(a.node_->value_ptr()->second)));
-        }
-        BOOST_CATCH(...) {
-            boost::unordered::detail::func::call_destroy(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(a.node_->value_ptr()->first)));
-            BOOST_RETHROW;
-        }
-        BOOST_CATCH_END
-        return a.release();
+        boost::unordered::detail::func::call_destroy(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(a.node_->value_ptr()->first)));
+        BOOST_RETHROW;
     }
+    BOOST_CATCH_END
+    return a.release();
+}
 
-    template <typename Alloc, typename Key, typename Mapped>
-    inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
-    construct_node_pair(Alloc& alloc, BOOST_FWD_REF(Key) k, BOOST_FWD_REF(Mapped) m)
+template <typename Alloc, typename Key, typename Mapped>
+inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
+construct_node_pair(Alloc& alloc, BOOST_FWD_REF(Key) k, BOOST_FWD_REF(Mapped) m)
+{
+    node_constructor<Alloc> a(alloc);
+    a.create_node();
+    boost::unordered::detail::func::call_construct(
+        alloc, boost::unordered::detail::func::const_cast_pointer(
+                   boost::addressof(a.node_->value_ptr()->first)),
+        boost::forward<Key>(k));
+    BOOST_TRY
     {
-        node_constructor<Alloc> a(alloc);
-        a.create_node();
-        boost::unordered::detail::func::call_construct(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(a.node_->value_ptr()->first)),
-                boost::forward<Key>(k));
-        BOOST_TRY {
-            boost::unordered::detail::func::call_construct(alloc,
-                    boost::unordered::detail::func::const_cast_pointer(
-                        boost::addressof(a.node_->value_ptr()->second)),
-                    boost::forward<Mapped>(m));
-        }
-        BOOST_CATCH(...) {
-            boost::unordered::detail::func::call_destroy(alloc,
-                boost::unordered::detail::func::const_cast_pointer(
-                    boost::addressof(a.node_->value_ptr()->first)));
-            BOOST_RETHROW;
-        }
-        BOOST_CATCH_END
-        return a.release();
+        boost::unordered::detail::func::call_construct(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(a.node_->value_ptr()->second)),
+            boost::forward<Mapped>(m));
     }
-}}}}
+    BOOST_CATCH(...)
+    {
+        boost::unordered::detail::func::call_destroy(
+            alloc, boost::unordered::detail::func::const_cast_pointer(
+                       boost::addressof(a.node_->value_ptr()->first)));
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    return a.release();
+}
+}
+}
+}
+}
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    template <typename Types> struct table;
-    template <typename NodePointer> struct bucket;
-    struct ptr_bucket;
-    template <typename Types> struct table_impl;
-    template <typename Types> struct grouped_table_impl;
-
-}}}
+template <typename Types> struct table;
+template <typename NodePointer> struct bucket;
+struct ptr_bucket;
+template <typename Types> struct table_impl;
+template <typename Types> struct grouped_table_impl;
+}
+}
+}
 
 // The 'iterator_detail' namespace was a misguided attempt at avoiding ADL
 // in the detail namespace. It didn't work because the template parameters
 // were in detail. I'm not changing it at the moment to be safe. I might
 // do in the future if I change the iterator types.
-namespace boost { namespace unordered { namespace iterator_detail {
+namespace boost {
+namespace unordered {
+namespace iterator_detail {
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Iterators
-    //
-    // all no throw
+////////////////////////////////////////////////////////////////////////////
+// Iterators
+//
+// all no throw
 
-    template <typename Node> struct iterator;
-    template <typename Node> struct c_iterator;
-    template <typename Node, typename Policy> struct l_iterator;
-    template <typename Node, typename Policy>
-        struct cl_iterator;
+template <typename Node> struct iterator;
+template <typename Node> struct c_iterator;
+template <typename Node, typename Policy> struct l_iterator;
+template <typename Node, typename Policy> struct cl_iterator;
 
-    // Local Iterators
-    //
-    // all no throw
+// Local Iterators
+//
+// all no throw
 
-    template <typename Node, typename Policy>
-    struct l_iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type*,
-            typename Node::value_type&>
-    {
+template <typename Node, typename Policy>
+struct l_iterator : public std::iterator<std::forward_iterator_tag,
+                        typename Node::value_type, std::ptrdiff_t,
+                        typename Node::value_type*, typename Node::value_type&>
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename Node2, typename Policy2>
-        friend struct boost::unordered::iterator_detail::cl_iterator;
-    private:
+    template <typename Node2, typename Policy2>
+    friend struct boost::unordered::iterator_detail::cl_iterator;
+
+  private:
 #endif
-        typedef typename Node::node_pointer node_pointer;
-        node_pointer ptr_;
-        std::size_t bucket_;
-        std::size_t bucket_count_;
+    typedef typename Node::node_pointer node_pointer;
+    node_pointer ptr_;
+    std::size_t bucket_;
+    std::size_t bucket_count_;
 
-    public:
+  public:
+    typedef typename Node::value_type value_type;
 
-        typedef typename Node::value_type value_type;
+    l_iterator() BOOST_NOEXCEPT : ptr_() {}
 
-        l_iterator() BOOST_NOEXCEPT : ptr_() {}
-
-        l_iterator(node_pointer n, std::size_t b, std::size_t c) BOOST_NOEXCEPT
-            : ptr_(n), bucket_(b), bucket_count_(c) {}
-
-        value_type& operator*() const {
-            return ptr_->value();
-        }
-
-        value_type* operator->() const {
-            return ptr_->value_ptr();
-        }
-
-        l_iterator& operator++() {
-            ptr_ = static_cast<node_pointer>(ptr_->next_);
-            if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_)
-                    != bucket_)
-                ptr_ = node_pointer();
-            return *this;
-        }
-
-        l_iterator operator++(int) {
-            l_iterator tmp(*this);
-            ++(*this);
-            return tmp;
-        }
-
-        bool operator==(l_iterator x) const BOOST_NOEXCEPT {
-            return ptr_ == x.ptr_;
-        }
-
-        bool operator!=(l_iterator x) const BOOST_NOEXCEPT {
-            return ptr_ != x.ptr_;
-        }
-    };
-
-    template <typename Node, typename Policy>
-    struct cl_iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type const*,
-            typename Node::value_type const&>
+    l_iterator(node_pointer n, std::size_t b, std::size_t c) BOOST_NOEXCEPT
+        : ptr_(n),
+          bucket_(b),
+          bucket_count_(c)
     {
-        friend struct boost::unordered::iterator_detail::l_iterator
-            <Node, Policy>;
-    private:
+    }
 
-        typedef typename Node::node_pointer node_pointer;
-        node_pointer ptr_;
-        std::size_t bucket_;
-        std::size_t bucket_count_;
+    value_type& operator*() const { return ptr_->value(); }
 
-    public:
+    value_type* operator->() const { return ptr_->value_ptr(); }
 
-        typedef typename Node::value_type value_type;
-
-        cl_iterator() BOOST_NOEXCEPT : ptr_() {}
-
-        cl_iterator(node_pointer n, std::size_t b, std::size_t c) BOOST_NOEXCEPT :
-            ptr_(n), bucket_(b), bucket_count_(c) {}
-
-        cl_iterator(boost::unordered::iterator_detail::l_iterator<
-                Node, Policy> const& x) BOOST_NOEXCEPT :
-            ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_)
-        {}
-
-        value_type const& operator*() const {
-            return ptr_->value();
-        }
-
-        value_type const* operator->() const {
-            return ptr_->value_ptr();
-        }
-
-        cl_iterator& operator++() {
-            ptr_ = static_cast<node_pointer>(ptr_->next_);
-            if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_)
-                    != bucket_)
-                ptr_ = node_pointer();
-            return *this;
-        }
-
-        cl_iterator operator++(int) {
-            cl_iterator tmp(*this);
-            ++(*this);
-            return tmp;
-        }
-
-        friend bool operator==(cl_iterator const& x, cl_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.ptr_ == y.ptr_;
-        }
-
-        friend bool operator!=(cl_iterator const& x, cl_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.ptr_ != y.ptr_;
-        }
-    };
-
-    template <typename Node>
-    struct iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type*,
-            typename Node::value_type&>
+    l_iterator& operator++()
     {
+        ptr_ = static_cast<node_pointer>(ptr_->next_);
+        if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_) != bucket_)
+            ptr_ = node_pointer();
+        return *this;
+    }
+
+    l_iterator operator++(int)
+    {
+        l_iterator tmp(*this);
+        ++(*this);
+        return tmp;
+    }
+
+    bool operator==(l_iterator x) const BOOST_NOEXCEPT
+    {
+        return ptr_ == x.ptr_;
+    }
+
+    bool operator!=(l_iterator x) const BOOST_NOEXCEPT
+    {
+        return ptr_ != x.ptr_;
+    }
+};
+
+template <typename Node, typename Policy>
+struct cl_iterator
+    : public std::iterator<std::forward_iterator_tag, typename Node::value_type,
+          std::ptrdiff_t, typename Node::value_type const*,
+          typename Node::value_type const&>
+{
+    friend struct boost::unordered::iterator_detail::l_iterator<Node, Policy>;
+
+  private:
+    typedef typename Node::node_pointer node_pointer;
+    node_pointer ptr_;
+    std::size_t bucket_;
+    std::size_t bucket_count_;
+
+  public:
+    typedef typename Node::value_type value_type;
+
+    cl_iterator() BOOST_NOEXCEPT : ptr_() {}
+
+    cl_iterator(node_pointer n, std::size_t b, std::size_t c) BOOST_NOEXCEPT
+        : ptr_(n),
+          bucket_(b),
+          bucket_count_(c)
+    {
+    }
+
+    cl_iterator(
+        boost::unordered::iterator_detail::l_iterator<Node, Policy> const& x)
+        BOOST_NOEXCEPT : ptr_(x.ptr_),
+                         bucket_(x.bucket_),
+                         bucket_count_(x.bucket_count_)
+    {
+    }
+
+    value_type const& operator*() const { return ptr_->value(); }
+
+    value_type const* operator->() const { return ptr_->value_ptr(); }
+
+    cl_iterator& operator++()
+    {
+        ptr_ = static_cast<node_pointer>(ptr_->next_);
+        if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_) != bucket_)
+            ptr_ = node_pointer();
+        return *this;
+    }
+
+    cl_iterator operator++(int)
+    {
+        cl_iterator tmp(*this);
+        ++(*this);
+        return tmp;
+    }
+
+    friend bool operator==(
+        cl_iterator const& x, cl_iterator const& y) BOOST_NOEXCEPT
+    {
+        return x.ptr_ == y.ptr_;
+    }
+
+    friend bool operator!=(
+        cl_iterator const& x, cl_iterator const& y) BOOST_NOEXCEPT
+    {
+        return x.ptr_ != y.ptr_;
+    }
+};
+
+template <typename Node>
+struct iterator : public std::iterator<std::forward_iterator_tag,
+                      typename Node::value_type, std::ptrdiff_t,
+                      typename Node::value_type*, typename Node::value_type&>
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename>
-        friend struct boost::unordered::iterator_detail::c_iterator;
-        template <typename>
-        friend struct boost::unordered::detail::table;
-        template <typename>
-        friend struct boost::unordered::detail::table_impl;
-        template <typename>
-        friend struct boost::unordered::detail::grouped_table_impl;
-    private:
+    template <typename>
+    friend struct boost::unordered::iterator_detail::c_iterator;
+    template <typename> friend struct boost::unordered::detail::table;
+    template <typename> friend struct boost::unordered::detail::table_impl;
+    template <typename>
+    friend struct boost::unordered::detail::grouped_table_impl;
+
+  private:
 #endif
-        typedef typename Node::node_pointer node_pointer;
-        node_pointer node_;
+    typedef typename Node::node_pointer node_pointer;
+    node_pointer node_;
 
-    public:
+  public:
+    typedef typename Node::value_type value_type;
 
-        typedef typename Node::value_type value_type;
+    iterator() BOOST_NOEXCEPT : node_() {}
 
-        iterator() BOOST_NOEXCEPT : node_() {}
-
-        explicit iterator(typename Node::link_pointer x) BOOST_NOEXCEPT :
-            node_(static_cast<node_pointer>(x)) {}
-
-        value_type& operator*() const {
-            return node_->value();
-        }
-
-        value_type* operator->() const {
-            return node_->value_ptr();
-        }
-
-        iterator& operator++() {
-            node_ = static_cast<node_pointer>(node_->next_);
-            return *this;
-        }
-
-        iterator operator++(int) {
-            iterator tmp(node_);
-            node_ = static_cast<node_pointer>(node_->next_);
-            return tmp;
-        }
-
-        bool operator==(iterator const& x) const BOOST_NOEXCEPT {
-            return node_ == x.node_;
-        }
-
-        bool operator!=(iterator const& x) const BOOST_NOEXCEPT {
-            return node_ != x.node_;
-        }
-    };
-
-    template <typename Node>
-    struct c_iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type const*,
-            typename Node::value_type const&>
+    explicit iterator(typename Node::link_pointer x) BOOST_NOEXCEPT
+        : node_(static_cast<node_pointer>(x))
     {
-        friend struct boost::unordered::iterator_detail::iterator<Node>;
+    }
+
+    value_type& operator*() const { return node_->value(); }
+
+    value_type* operator->() const { return node_->value_ptr(); }
+
+    iterator& operator++()
+    {
+        node_ = static_cast<node_pointer>(node_->next_);
+        return *this;
+    }
+
+    iterator operator++(int)
+    {
+        iterator tmp(node_);
+        node_ = static_cast<node_pointer>(node_->next_);
+        return tmp;
+    }
+
+    bool operator==(iterator const& x) const BOOST_NOEXCEPT
+    {
+        return node_ == x.node_;
+    }
+
+    bool operator!=(iterator const& x) const BOOST_NOEXCEPT
+    {
+        return node_ != x.node_;
+    }
+};
+
+template <typename Node>
+struct c_iterator
+    : public std::iterator<std::forward_iterator_tag, typename Node::value_type,
+          std::ptrdiff_t, typename Node::value_type const*,
+          typename Node::value_type const&>
+{
+    friend struct boost::unordered::iterator_detail::iterator<Node>;
 
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename>
-        friend struct boost::unordered::detail::table;
-        template <typename>
-        friend struct boost::unordered::detail::table_impl;
-        template <typename>
-        friend struct boost::unordered::detail::grouped_table_impl;
+    template <typename> friend struct boost::unordered::detail::table;
+    template <typename> friend struct boost::unordered::detail::table_impl;
+    template <typename>
+    friend struct boost::unordered::detail::grouped_table_impl;
 
-    private:
+  private:
 #endif
-        typedef typename Node::node_pointer node_pointer;
-        typedef boost::unordered::iterator_detail::iterator<Node> n_iterator;
-        node_pointer node_;
+    typedef typename Node::node_pointer node_pointer;
+    typedef boost::unordered::iterator_detail::iterator<Node> n_iterator;
+    node_pointer node_;
 
-    public:
+  public:
+    typedef typename Node::value_type value_type;
 
-        typedef typename Node::value_type value_type;
+    c_iterator() BOOST_NOEXCEPT : node_() {}
 
-        c_iterator() BOOST_NOEXCEPT : node_() {}
-
-        explicit c_iterator(typename Node::link_pointer x) BOOST_NOEXCEPT :
-            node_(static_cast<node_pointer>(x)) {}
-
-        c_iterator(n_iterator const& x) BOOST_NOEXCEPT : node_(x.node_) {}
-
-        value_type const& operator*() const {
-            return node_->value();
-        }
-
-        value_type const* operator->() const {
-            return node_->value_ptr();
-        }
-
-        c_iterator& operator++() {
-            node_ = static_cast<node_pointer>(node_->next_);
-            return *this;
-        }
-
-        c_iterator operator++(int) {
-            c_iterator tmp(node_);
-            node_ = static_cast<node_pointer>(node_->next_);
-            return tmp;
-        }
-
-        friend bool operator==(c_iterator const& x, c_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.node_ == y.node_;
-        }
-
-        friend bool operator!=(c_iterator const& x, c_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.node_ != y.node_;
-        }
-    };
-}}}
-
-namespace boost { namespace unordered { namespace detail {
-
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Node Holder
-    //
-    // Temporary store for nodes. Deletes any that aren't used.
-
-    template <typename NodeAlloc>
-    struct node_holder
+    explicit c_iterator(typename Node::link_pointer x) BOOST_NOEXCEPT
+        : node_(static_cast<node_pointer>(x))
     {
-    private:
-        typedef NodeAlloc node_allocator;
-        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
-            node_allocator_traits;
-        typedef typename node_allocator_traits::value_type node;
-        typedef typename node_allocator_traits::pointer node_pointer;
-        typedef typename node::value_type value_type;
-        typedef typename node::link_pointer link_pointer;
-        typedef boost::unordered::iterator_detail::iterator<node> iterator;
+    }
 
-        node_constructor<NodeAlloc> constructor_;
-        node_pointer nodes_;
+    c_iterator(n_iterator const& x) BOOST_NOEXCEPT : node_(x.node_) {}
 
-    public:
+    value_type const& operator*() const { return node_->value(); }
 
-        template <typename Table>
-        explicit node_holder(Table& b) :
-            constructor_(b.node_alloc()),
-            nodes_()
-        {
-            if (b.size_) {
-                typename Table::link_pointer prev = b.get_previous_start();
-                nodes_ = static_cast<node_pointer>(prev->next_);
-                prev->next_ = link_pointer();
-                b.size_ = 0;
-            }
-        }
+    value_type const* operator->() const { return node_->value_ptr(); }
 
-        ~node_holder();
-
-        node_pointer pop_node()
-        {
-            node_pointer n = nodes_;
-            nodes_ = static_cast<node_pointer>(nodes_->next_);
-            n->init(n);
-            n->next_ = link_pointer();
-            return n;
-        }
-
-        template <typename T>
-        inline node_pointer copy_of(T const& v) {
-            if (nodes_) {
-                constructor_.reclaim(pop_node());
-            }
-            else {
-                constructor_.create_node();
-            }
-            boost::unordered::detail::func::call_construct(
-                constructor_.alloc_, constructor_.node_->value_ptr(), v);
-            return constructor_.release();
-        }
-
-        template <typename T>
-        inline node_pointer move_copy_of(T& v) {
-            if (nodes_) {
-                constructor_.reclaim(pop_node());
-            }
-            else {
-                constructor_.create_node();
-            }
-            boost::unordered::detail::func::call_construct(
-                constructor_.alloc_, constructor_.node_->value_ptr(),
-                boost::move(v));
-            return constructor_.release();
-        }
-
-        iterator begin() const
-        {
-            return iterator(nodes_);
-        }
-    };
-
-    template <typename Alloc>
-    node_holder<Alloc>::~node_holder()
+    c_iterator& operator++()
     {
-        while (nodes_) {
-            node_pointer p = nodes_;
-            nodes_ = static_cast<node_pointer>(p->next_);
+        node_ = static_cast<node_pointer>(node_->next_);
+        return *this;
+    }
 
-            boost::unordered::detail::func::call_destroy(constructor_.alloc_,
-                p->value_ptr());
-            boost::unordered::detail::func::destroy(boost::addressof(*p));
-            node_allocator_traits::deallocate(constructor_.alloc_, p, 1);
+    c_iterator operator++(int)
+    {
+        c_iterator tmp(node_);
+        node_ = static_cast<node_pointer>(node_->next_);
+        return tmp;
+    }
+
+    friend bool operator==(
+        c_iterator const& x, c_iterator const& y) BOOST_NOEXCEPT
+    {
+        return x.node_ == y.node_;
+    }
+
+    friend bool operator!=(
+        c_iterator const& x, c_iterator const& y) BOOST_NOEXCEPT
+    {
+        return x.node_ != y.node_;
+    }
+};
+}
+}
+}
+
+namespace boost {
+namespace unordered {
+namespace detail {
+
+///////////////////////////////////////////////////////////////////
+//
+// Node Holder
+//
+// Temporary store for nodes. Deletes any that aren't used.
+
+template <typename NodeAlloc> struct node_holder
+{
+  private:
+    typedef NodeAlloc node_allocator;
+    typedef boost::unordered::detail::allocator_traits<NodeAlloc>
+        node_allocator_traits;
+    typedef typename node_allocator_traits::value_type node;
+    typedef typename node_allocator_traits::pointer node_pointer;
+    typedef typename node::value_type value_type;
+    typedef typename node::link_pointer link_pointer;
+    typedef boost::unordered::iterator_detail::iterator<node> iterator;
+
+    node_constructor<NodeAlloc> constructor_;
+    node_pointer nodes_;
+
+  public:
+    template <typename Table>
+    explicit node_holder(Table& b) : constructor_(b.node_alloc()), nodes_()
+    {
+        if (b.size_) {
+            typename Table::link_pointer prev = b.get_previous_start();
+            nodes_ = static_cast<node_pointer>(prev->next_);
+            prev->next_ = link_pointer();
+            b.size_ = 0;
         }
     }
 
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Bucket
+    ~node_holder();
 
-    template <typename NodePointer>
-    struct bucket
+    node_pointer pop_node()
     {
-        typedef NodePointer link_pointer;
-        link_pointer next_;
+        node_pointer n = nodes_;
+        nodes_ = static_cast<node_pointer>(nodes_->next_);
+        n->init(n);
+        n->next_ = link_pointer();
+        return n;
+    }
 
-        bucket() : next_() {}
-
-        link_pointer first_from_start()
-        {
-            return next_;
-        }
-
-        enum { extra_node = true };
-    };
-
-    struct ptr_bucket
+    template <typename T> inline node_pointer copy_of(T const& v)
     {
-        typedef ptr_bucket* link_pointer;
-        link_pointer next_;
-
-        ptr_bucket() : next_(0) {}
-
-        link_pointer first_from_start()
-        {
-            return this;
+        if (nodes_) {
+            constructor_.reclaim(pop_node());
+        } else {
+            constructor_.create_node();
         }
+        boost::unordered::detail::func::call_construct(
+            constructor_.alloc_, constructor_.node_->value_ptr(), v);
+        return constructor_.release();
+    }
 
-        enum { extra_node = false };
-    };
-
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Hash Policy
-
-    template <typename SizeT>
-    struct prime_policy
+    template <typename T> inline node_pointer move_copy_of(T& v)
     {
-        template <typename Hash, typename T>
-        static inline SizeT apply_hash(Hash const& hf, T const& x) {
-            return hf(x);
+        if (nodes_) {
+            constructor_.reclaim(pop_node());
+        } else {
+            constructor_.create_node();
         }
+        boost::unordered::detail::func::call_construct(constructor_.alloc_,
+            constructor_.node_->value_ptr(), boost::move(v));
+        return constructor_.release();
+    }
 
-        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash) {
-            return hash % bucket_count;
-        }
+    iterator begin() const { return iterator(nodes_); }
+};
 
-        static inline SizeT new_bucket_count(SizeT min) {
-            return boost::unordered::detail::next_prime(min);
-        }
+template <typename Alloc> node_holder<Alloc>::~node_holder()
+{
+    while (nodes_) {
+        node_pointer p = nodes_;
+        nodes_ = static_cast<node_pointer>(p->next_);
 
-        static inline SizeT prev_bucket_count(SizeT max) {
-            return boost::unordered::detail::prev_prime(max);
-        }
-    };
+        boost::unordered::detail::func::call_destroy(
+            constructor_.alloc_, p->value_ptr());
+        boost::unordered::detail::func::destroy(boost::addressof(*p));
+        node_allocator_traits::deallocate(constructor_.alloc_, p, 1);
+    }
+}
 
-    template <typename SizeT>
-    struct mix64_policy
+///////////////////////////////////////////////////////////////////
+//
+// Bucket
+
+template <typename NodePointer> struct bucket
+{
+    typedef NodePointer link_pointer;
+    link_pointer next_;
+
+    bucket() : next_() {}
+
+    link_pointer first_from_start() { return next_; }
+
+    enum
     {
-        template <typename Hash, typename T>
-        static inline SizeT apply_hash(Hash const& hf, T const& x) {
-            SizeT key = hf(x);
-            key = (~key) + (key << 21); // key = (key << 21) - key - 1;
-            key = key ^ (key >> 24);
-            key = (key + (key << 3)) + (key << 8); // key * 265
-            key = key ^ (key >> 14);
-            key = (key + (key << 2)) + (key << 4); // key * 21
-            key = key ^ (key >> 28);
-            key = key + (key << 31);
-            return key;
-        }
-
-        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash) {
-            return hash & (bucket_count - 1);
-        }
-
-        static inline SizeT new_bucket_count(SizeT min) {
-            if (min <= 4) return 4;
-            --min;
-            min |= min >> 1;
-            min |= min >> 2;
-            min |= min >> 4;
-            min |= min >> 8;
-            min |= min >> 16;
-            min |= min >> 32;
-            return min + 1;
-        }
-
-        static inline SizeT prev_bucket_count(SizeT max) {
-            max |= max >> 1;
-            max |= max >> 2;
-            max |= max >> 4;
-            max |= max >> 8;
-            max |= max >> 16;
-            max |= max >> 32;
-            return (max >> 1) + 1;
-        }
+        extra_node = true
     };
+};
 
-    template <int digits, int radix>
-    struct pick_policy_impl {
-        typedef prime_policy<std::size_t> type;
+struct ptr_bucket
+{
+    typedef ptr_bucket* link_pointer;
+    link_pointer next_;
+
+    ptr_bucket() : next_(0) {}
+
+    link_pointer first_from_start() { return this; }
+
+    enum
+    {
+        extra_node = false
     };
+};
 
-    template <>
-    struct pick_policy_impl<64, 2> {
-        typedef mix64_policy<std::size_t> type;
-    };
+///////////////////////////////////////////////////////////////////
+//
+// Hash Policy
 
-    template <typename T>
-    struct pick_policy :
-        pick_policy_impl<
-            std::numeric_limits<std::size_t>::digits,
-            std::numeric_limits<std::size_t>::radix> {};
+template <typename SizeT> struct prime_policy
+{
+    template <typename Hash, typename T>
+    static inline SizeT apply_hash(Hash const& hf, T const& x)
+    {
+        return hf(x);
+    }
 
-    // While the mix policy is generally faster, the prime policy is a lot
-    // faster when a large number consecutive integers are used, because
-    // there are no collisions. Since that is probably quite common, use
-    // prime policy for integeral types. But not the smaller ones, as they
-    // don't have enough unique values for this to be an issue.
+    static inline SizeT to_bucket(SizeT bucket_count, SizeT hash)
+    {
+        return hash % bucket_count;
+    }
 
-    template <>
-    struct pick_policy<int> {
-        typedef prime_policy<std::size_t> type;
-    };
+    static inline SizeT new_bucket_count(SizeT min)
+    {
+        return boost::unordered::detail::next_prime(min);
+    }
 
-    template <>
-    struct pick_policy<unsigned int> {
-        typedef prime_policy<std::size_t> type;
-    };
+    static inline SizeT prev_bucket_count(SizeT max)
+    {
+        return boost::unordered::detail::prev_prime(max);
+    }
+};
 
-    template <>
-    struct pick_policy<long> {
-        typedef prime_policy<std::size_t> type;
-    };
+template <typename SizeT> struct mix64_policy
+{
+    template <typename Hash, typename T>
+    static inline SizeT apply_hash(Hash const& hf, T const& x)
+    {
+        SizeT key = hf(x);
+        key = (~key) + (key << 21); // key = (key << 21) - key - 1;
+        key = key ^ (key >> 24);
+        key = (key + (key << 3)) + (key << 8); // key * 265
+        key = key ^ (key >> 14);
+        key = (key + (key << 2)) + (key << 4); // key * 21
+        key = key ^ (key >> 28);
+        key = key + (key << 31);
+        return key;
+    }
 
-    template <>
-    struct pick_policy<unsigned long> {
-        typedef prime_policy<std::size_t> type;
-    };
+    static inline SizeT to_bucket(SizeT bucket_count, SizeT hash)
+    {
+        return hash & (bucket_count - 1);
+    }
 
-    // TODO: Maybe not if std::size_t is smaller than long long.
+    static inline SizeT new_bucket_count(SizeT min)
+    {
+        if (min <= 4)
+            return 4;
+        --min;
+        min |= min >> 1;
+        min |= min >> 2;
+        min |= min >> 4;
+        min |= min >> 8;
+        min |= min >> 16;
+        min |= min >> 32;
+        return min + 1;
+    }
+
+    static inline SizeT prev_bucket_count(SizeT max)
+    {
+        max |= max >> 1;
+        max |= max >> 2;
+        max |= max >> 4;
+        max |= max >> 8;
+        max |= max >> 16;
+        max |= max >> 32;
+        return (max >> 1) + 1;
+    }
+};
+
+template <int digits, int radix> struct pick_policy_impl
+{
+    typedef prime_policy<std::size_t> type;
+};
+
+template <> struct pick_policy_impl<64, 2>
+{
+    typedef mix64_policy<std::size_t> type;
+};
+
+template <typename T>
+struct pick_policy : pick_policy_impl<std::numeric_limits<std::size_t>::digits,
+                         std::numeric_limits<std::size_t>::radix>
+{
+};
+
+// While the mix policy is generally faster, the prime policy is a lot
+// faster when a large number consecutive integers are used, because
+// there are no collisions. Since that is probably quite common, use
+// prime policy for integeral types. But not the smaller ones, as they
+// don't have enough unique values for this to be an issue.
+
+template <> struct pick_policy<int>
+{
+    typedef prime_policy<std::size_t> type;
+};
+
+template <> struct pick_policy<unsigned int>
+{
+    typedef prime_policy<std::size_t> type;
+};
+
+template <> struct pick_policy<long>
+{
+    typedef prime_policy<std::size_t> type;
+};
+
+template <> struct pick_policy<unsigned long>
+{
+    typedef prime_policy<std::size_t> type;
+};
+
+// TODO: Maybe not if std::size_t is smaller than long long.
 #if !defined(BOOST_NO_LONG_LONG)
-    template <>
-    struct pick_policy<boost::long_long_type> {
-        typedef prime_policy<std::size_t> type;
-    };
+template <> struct pick_policy<boost::long_long_type>
+{
+    typedef prime_policy<std::size_t> type;
+};
 
-    template <>
-    struct pick_policy<boost::ulong_long_type> {
-        typedef prime_policy<std::size_t> type;
-    };
+template <> struct pick_policy<boost::ulong_long_type>
+{
+    typedef prime_policy<std::size_t> type;
+};
 #endif
 
-    ////////////////////////////////////////////////////////////////////////////
-    // Functions
+////////////////////////////////////////////////////////////////////////////
+// Functions
 
-    // Assigning and swapping the equality and hash function objects
-    // needs strong exception safety. To implement that normally we'd
-    // require one of them to be known to not throw and the other to
-    // guarantee strong exception safety. Unfortunately they both only
-    // have basic exception safety. So to acheive strong exception
-    // safety we have storage space for two copies, and assign the new
-    // copies to the unused space. Then switch to using that to use
-    // them. This is implemented in 'set_hash_functions' which
-    // atomically assigns the new function objects in a strongly
-    // exception safe manner.
+// Assigning and swapping the equality and hash function objects
+// needs strong exception safety. To implement that normally we'd
+// require one of them to be known to not throw and the other to
+// guarantee strong exception safety. Unfortunately they both only
+// have basic exception safety. So to acheive strong exception
+// safety we have storage space for two copies, and assign the new
+// copies to the unused space. Then switch to using that to use
+// them. This is implemented in 'set_hash_functions' which
+// atomically assigns the new function objects in a strongly
+// exception safe manner.
 
-    template <class H, class P, bool NoThrowMoveAssign>
-    class set_hash_functions;
+template <class H, class P, bool NoThrowMoveAssign> class set_hash_functions;
 
-    template <class H, class P>
-    class functions
+template <class H, class P> class functions
+{
+  public:
+    static const bool nothrow_move_assignable =
+        boost::is_nothrow_move_assignable<H>::value &&
+        boost::is_nothrow_move_assignable<P>::value;
+    static const bool nothrow_move_constructible =
+        boost::is_nothrow_move_constructible<H>::value &&
+        boost::is_nothrow_move_constructible<P>::value;
+
+  private:
+    friend class boost::unordered::detail::set_hash_functions<H, P,
+        nothrow_move_assignable>;
+    functions& operator=(functions const&);
+
+    typedef compressed<H, P> function_pair;
+
+    typedef typename boost::aligned_storage<sizeof(function_pair),
+        boost::alignment_of<function_pair>::value>::type aligned_function;
+
+    bool current_; // The currently active functions.
+    aligned_function funcs_[2];
+
+    function_pair const& current() const
     {
-    public:
-        static const bool nothrow_move_assignable =
-                boost::is_nothrow_move_assignable<H>::value &&
-                boost::is_nothrow_move_assignable<P>::value;
-        static const bool nothrow_move_constructible =
-                boost::is_nothrow_move_constructible<H>::value &&
-                boost::is_nothrow_move_constructible<P>::value;
+        return *static_cast<function_pair const*>(
+            static_cast<void const*>(&funcs_[current_]));
+    }
 
-    private:
-        friend class boost::unordered::detail::set_hash_functions<H, P,
-               nothrow_move_assignable>;
-        functions& operator=(functions const&);
-
-        typedef compressed<H, P> function_pair;
-
-        typedef typename boost::aligned_storage<
-            sizeof(function_pair),
-            boost::alignment_of<function_pair>::value>::type aligned_function;
-
-        bool current_; // The currently active functions.
-        aligned_function funcs_[2];
-
-        function_pair const& current() const {
-            return *static_cast<function_pair const*>(
-                static_cast<void const*>(&funcs_[current_]));
-        }
-
-        function_pair& current() {
-            return *static_cast<function_pair*>(
-                static_cast<void*>(&funcs_[current_]));
-        }
-
-        void construct(bool which, H const& hf, P const& eq)
-        {
-            new((void*) &funcs_[which]) function_pair(hf, eq);
-        }
-
-        void construct(bool which, function_pair const& f,
-                boost::unordered::detail::false_type =
-                    boost::unordered::detail::false_type())
-        {
-            new((void*) &funcs_[which]) function_pair(f);
-        }
-
-        void construct(bool which, function_pair& f,
-                boost::unordered::detail::true_type)
-        {
-            new((void*) &funcs_[which]) function_pair(f,
-                boost::unordered::detail::move_tag());
-        }
-
-        void destroy(bool which)
-        {
-            boost::unordered::detail::func::destroy((function_pair*)(&funcs_[which]));
-        }
-
-    public:
-
-        typedef boost::unordered::detail::set_hash_functions<H, P,
-                nothrow_move_assignable> set_hash_functions;
-
-        functions(H const& hf, P const& eq)
-            : current_(false)
-        {
-            construct(current_, hf, eq);
-        }
-
-        functions(functions const& bf)
-            : current_(false)
-        {
-            construct(current_, bf.current());
-        }
-
-        functions(functions& bf, boost::unordered::detail::move_tag)
-            : current_(false)
-        {
-            construct(current_, bf.current(),
-                boost::unordered::detail::integral_constant<bool,
-                    nothrow_move_constructible>());
-        }
-
-        ~functions() {
-            this->destroy(current_);
-        }
-
-        H const& hash_function() const {
-            return current().first();
-        }
-
-        P const& key_eq() const {
-            return current().second();
-        }
-    };
-
-    template <class H, class P>
-    class set_hash_functions<H, P, false>
+    function_pair& current()
     {
-        set_hash_functions(set_hash_functions const&);
-        set_hash_functions& operator=(set_hash_functions const&);
+        return *static_cast<function_pair*>(
+            static_cast<void*>(&funcs_[current_]));
+    }
 
-        typedef functions<H, P> functions_type;
-
-        functions_type& functions_;
-        bool tmp_functions_;
-
-    public:
-
-        set_hash_functions(functions_type& f, H const& h, P const& p)
-          : functions_(f),
-            tmp_functions_(!f.current_)
-        {
-            f.construct(tmp_functions_, h, p);
-        }
-
-        set_hash_functions(functions_type& f, functions_type const& other)
-          : functions_(f),
-            tmp_functions_(!f.current_)
-        {
-            f.construct(tmp_functions_, other.current());
-        }
-
-        ~set_hash_functions()
-        {
-            functions_.destroy(tmp_functions_);
-        }
-
-        void commit()
-        {
-            functions_.current_ = tmp_functions_;
-            tmp_functions_ = !tmp_functions_;
-        }
-    };
-
-    template <class H, class P>
-    class set_hash_functions<H, P, true>
+    void construct(bool which, H const& hf, P const& eq)
     {
-        set_hash_functions(set_hash_functions const&);
-        set_hash_functions& operator=(set_hash_functions const&);
+        new ((void*)&funcs_[which]) function_pair(hf, eq);
+    }
 
-        typedef functions<H, P> functions_type;
+    void construct(bool which, function_pair const& f,
+        boost::unordered::detail::false_type =
+            boost::unordered::detail::false_type())
+    {
+        new ((void*)&funcs_[which]) function_pair(f);
+    }
 
-        functions_type& functions_;
-        H hash_;
-        P pred_;
+    void construct(
+        bool which, function_pair& f, boost::unordered::detail::true_type)
+    {
+        new ((void*)&funcs_[which])
+            function_pair(f, boost::unordered::detail::move_tag());
+    }
 
-    public:
+    void destroy(bool which)
+    {
+        boost::unordered::detail::func::destroy(
+            (function_pair*)(&funcs_[which]));
+    }
 
-        set_hash_functions(functions_type& f, H const& h, P const& p) :
-            functions_(f),
-            hash_(h),
-            pred_(p) {}
+  public:
+    typedef boost::unordered::detail::set_hash_functions<H, P,
+        nothrow_move_assignable>
+        set_hash_functions;
 
-        set_hash_functions(functions_type& f, functions_type const& other) :
-            functions_(f),
-            hash_(other.hash_function()),
-            pred_(other.key_eq()) {}
+    functions(H const& hf, P const& eq) : current_(false)
+    {
+        construct(current_, hf, eq);
+    }
 
-        void commit()
-        {
-            functions_.current().first() = boost::move(hash_);
-            functions_.current().second() = boost::move(pred_);
-        }
-    };
+    functions(functions const& bf) : current_(false)
+    {
+        construct(current_, bf.current());
+    }
 
-    ////////////////////////////////////////////////////////////////////////////
-    // rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
-    // e.g. for int
+    functions(functions& bf, boost::unordered::detail::move_tag)
+        : current_(false)
+    {
+        construct(current_, bf.current(),
+            boost::unordered::detail::integral_constant<bool,
+                      nothrow_move_constructible>());
+    }
+
+    ~functions() { this->destroy(current_); }
+
+    H const& hash_function() const { return current().first(); }
+
+    P const& key_eq() const { return current().second(); }
+};
+
+template <class H, class P> class set_hash_functions<H, P, false>
+{
+    set_hash_functions(set_hash_functions const&);
+    set_hash_functions& operator=(set_hash_functions const&);
+
+    typedef functions<H, P> functions_type;
+
+    functions_type& functions_;
+    bool tmp_functions_;
+
+  public:
+    set_hash_functions(functions_type& f, H const& h, P const& p)
+        : functions_(f), tmp_functions_(!f.current_)
+    {
+        f.construct(tmp_functions_, h, p);
+    }
+
+    set_hash_functions(functions_type& f, functions_type const& other)
+        : functions_(f), tmp_functions_(!f.current_)
+    {
+        f.construct(tmp_functions_, other.current());
+    }
+
+    ~set_hash_functions() { functions_.destroy(tmp_functions_); }
+
+    void commit()
+    {
+        functions_.current_ = tmp_functions_;
+        tmp_functions_ = !tmp_functions_;
+    }
+};
+
+template <class H, class P> class set_hash_functions<H, P, true>
+{
+    set_hash_functions(set_hash_functions const&);
+    set_hash_functions& operator=(set_hash_functions const&);
+
+    typedef functions<H, P> functions_type;
+
+    functions_type& functions_;
+    H hash_;
+    P pred_;
+
+  public:
+    set_hash_functions(functions_type& f, H const& h, P const& p)
+        : functions_(f), hash_(h), pred_(p)
+    {
+    }
+
+    set_hash_functions(functions_type& f, functions_type const& other)
+        : functions_(f), hash_(other.hash_function()), pred_(other.key_eq())
+    {
+    }
+
+    void commit()
+    {
+        functions_.current().first() = boost::move(hash_);
+        functions_.current().second() = boost::move(pred_);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////
+// rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
+// e.g. for int
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   define BOOST_UNORDERED_RV_REF(T) BOOST_RV_REF(T)
+#define BOOST_UNORDERED_RV_REF(T) BOOST_RV_REF(T)
 #else
-    struct please_ignore_this_overload {
-        typedef please_ignore_this_overload type;
-    };
+struct please_ignore_this_overload
+{
+    typedef please_ignore_this_overload type;
+};
 
-    template <typename T>
-    struct rv_ref_impl {
-        typedef BOOST_RV_REF(T) type;
-    };
+template <typename T> struct rv_ref_impl
+{
+    typedef BOOST_RV_REF(T) type;
+};
 
-    template <typename T>
-    struct rv_ref :
-        boost::detail::if_true<
-            boost::is_class<T>::value
-        >::BOOST_NESTED_TEMPLATE then <
-            boost::unordered::detail::rv_ref_impl<T>,
-            please_ignore_this_overload
-        >::type
-    {};
+template <typename T>
+struct rv_ref
+    : boost::detail::if_true<boost::is_class<T>::value>::BOOST_NESTED_TEMPLATE
+          then<boost::unordered::detail::rv_ref_impl<T>,
+              please_ignore_this_overload>::type
+{
+};
 
-#   define BOOST_UNORDERED_RV_REF(T) \
-        typename boost::unordered::detail::rv_ref<T>::type
+#define BOOST_UNORDERED_RV_REF(T)                                              \
+    typename boost::unordered::detail::rv_ref<T>::type
 #endif
-}}}
+}
+}
+}
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 #endif
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    ////////////////////////////////////////////////////////////////////////////
-    // convert double to std::size_t
+////////////////////////////////////////////////////////////////////////////
+// convert double to std::size_t
 
-    inline std::size_t double_to_size(double f)
+inline std::size_t double_to_size(double f)
+{
+    return f >= static_cast<double>((std::numeric_limits<std::size_t>::max)())
+               ? (std::numeric_limits<std::size_t>::max)()
+               : static_cast<std::size_t>(f);
+}
+
+// The space used to store values in a node.
+
+template <typename ValueType> struct value_base
+{
+    typedef ValueType value_type;
+
+    typename boost::aligned_storage<sizeof(value_type),
+        boost::alignment_of<value_type>::value>::type data_;
+
+    value_base() : data_() {}
+
+    void* address() { return this; }
+
+    value_type& value() { return *(ValueType*)this; }
+
+    value_type* value_ptr() { return (ValueType*)this; }
+
+  private:
+    value_base& operator=(value_base const&);
+};
+
+template <typename Types>
+struct table : boost::unordered::detail::functions<typename Types::hasher,
+                   typename Types::key_equal>
+{
+  private:
+    table(table const&);
+    table& operator=(table const&);
+
+  public:
+    typedef typename Types::node node;
+    typedef typename Types::bucket bucket;
+    typedef typename Types::hasher hasher;
+    typedef typename Types::key_equal key_equal;
+    typedef typename Types::key_type key_type;
+    typedef typename Types::extractor extractor;
+    typedef typename Types::value_type value_type;
+    typedef typename Types::table table_impl;
+    typedef typename Types::link_pointer link_pointer;
+    typedef typename Types::policy policy;
+    typedef typename Types::iterator iterator;
+    typedef typename Types::c_iterator c_iterator;
+    typedef typename Types::l_iterator l_iterator;
+    typedef typename Types::cl_iterator cl_iterator;
+
+    typedef boost::unordered::detail::functions<typename Types::hasher,
+        typename Types::key_equal>
+        functions;
+    typedef typename functions::set_hash_functions set_hash_functions;
+
+    typedef typename Types::allocator allocator;
+    typedef typename boost::unordered::detail::rebind_wrap<allocator,
+        node>::type node_allocator;
+    typedef typename boost::unordered::detail::rebind_wrap<allocator,
+        bucket>::type bucket_allocator;
+    typedef boost::unordered::detail::allocator_traits<node_allocator>
+        node_allocator_traits;
+    typedef boost::unordered::detail::allocator_traits<bucket_allocator>
+        bucket_allocator_traits;
+    typedef typename node_allocator_traits::pointer node_pointer;
+    typedef typename node_allocator_traits::const_pointer const_node_pointer;
+    typedef typename bucket_allocator_traits::pointer bucket_pointer;
+    typedef boost::unordered::detail::node_constructor<node_allocator>
+        node_constructor;
+    typedef boost::unordered::detail::node_tmp<node_allocator> node_tmp;
+
+    ////////////////////////////////////////////////////////////////////////
+    // Members
+
+    boost::unordered::detail::compressed<bucket_allocator, node_allocator>
+        allocators_;
+    std::size_t bucket_count_;
+    std::size_t size_;
+    float mlf_;
+    std::size_t max_load_;
+    bucket_pointer buckets_;
+
+    ////////////////////////////////////////////////////////////////////////
+    // Node functions
+
+    static inline node_pointer next_node(link_pointer n)
     {
-        return f >= static_cast<double>(
-            (std::numeric_limits<std::size_t>::max)()) ?
-            (std::numeric_limits<std::size_t>::max)() :
-            static_cast<std::size_t>(f);
+        return static_cast<node_pointer>(n->next_);
     }
 
-    // The space used to store values in a node.
+    ////////////////////////////////////////////////////////////////////////
+    // Data access
 
-    template <typename ValueType>
-    struct value_base
+    bucket_allocator const& bucket_alloc() const { return allocators_.first(); }
+
+    node_allocator const& node_alloc() const { return allocators_.second(); }
+
+    bucket_allocator& bucket_alloc() { return allocators_.first(); }
+
+    node_allocator& node_alloc() { return allocators_.second(); }
+
+    std::size_t max_bucket_count() const
     {
-        typedef ValueType value_type;
+        // -1 to account for the start bucket.
+        return policy::prev_bucket_count(
+            bucket_allocator_traits::max_size(bucket_alloc()) - 1);
+    }
 
-        typename boost::aligned_storage<
-            sizeof(value_type),
-            boost::alignment_of<value_type>::value>::type data_;
-
-        value_base() :
-            data_()
-        {}
-
-        void* address() {
-            return this;
-        }
-
-        value_type& value() {
-            return *(ValueType*) this;
-        }
-
-        value_type* value_ptr() {
-            return (ValueType*) this;
-        }
-
-    private:
-
-        value_base& operator=(value_base const&);
-    };
-
-    template <typename Types>
-    struct table :
-        boost::unordered::detail::functions<
-            typename Types::hasher,
-            typename Types::key_equal>
+    bucket_pointer get_bucket(std::size_t bucket_index) const
     {
-    private:
-        table(table const&);
-        table& operator=(table const&);
-    public:
-        typedef typename Types::node node;
-        typedef typename Types::bucket bucket;
-        typedef typename Types::hasher hasher;
-        typedef typename Types::key_equal key_equal;
-        typedef typename Types::key_type key_type;
-        typedef typename Types::extractor extractor;
-        typedef typename Types::value_type value_type;
-        typedef typename Types::table table_impl;
-        typedef typename Types::link_pointer link_pointer;
-        typedef typename Types::policy policy;
-        typedef typename Types::iterator iterator;
-        typedef typename Types::c_iterator c_iterator;
-        typedef typename Types::l_iterator l_iterator;
-        typedef typename Types::cl_iterator cl_iterator;
+        BOOST_ASSERT(buckets_);
+        return buckets_ + static_cast<std::ptrdiff_t>(bucket_index);
+    }
 
-        typedef boost::unordered::detail::functions<
-            typename Types::hasher,
-            typename Types::key_equal> functions;
-        typedef typename functions::set_hash_functions set_hash_functions;
+    link_pointer get_previous_start() const
+    {
+        return get_bucket(bucket_count_)->first_from_start();
+    }
 
-        typedef typename Types::allocator allocator;
-        typedef typename boost::unordered::detail::
-            rebind_wrap<allocator, node>::type node_allocator;
-        typedef typename boost::unordered::detail::
-            rebind_wrap<allocator, bucket>::type bucket_allocator;
-        typedef boost::unordered::detail::allocator_traits<node_allocator>
-            node_allocator_traits;
-        typedef boost::unordered::detail::allocator_traits<bucket_allocator>
-            bucket_allocator_traits;
-        typedef typename node_allocator_traits::pointer
-            node_pointer;
-        typedef typename node_allocator_traits::const_pointer
-            const_node_pointer;
-        typedef typename bucket_allocator_traits::pointer
-            bucket_pointer;
-        typedef boost::unordered::detail::node_constructor<node_allocator>
-            node_constructor;
-        typedef boost::unordered::detail::node_tmp<node_allocator>
-            node_tmp;
+    link_pointer get_previous_start(std::size_t bucket_index) const
+    {
+        return get_bucket(bucket_index)->next_;
+    }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Members
+    node_pointer begin() const
+    {
+        return size_ ? next_node(get_previous_start()) : node_pointer();
+    }
 
-        boost::unordered::detail::compressed<bucket_allocator, node_allocator>
-            allocators_;
-        std::size_t bucket_count_;
-        std::size_t size_;
-        float mlf_;
-        std::size_t max_load_;
-        bucket_pointer buckets_;
+    node_pointer begin(std::size_t bucket_index) const
+    {
+        if (!size_)
+            return node_pointer();
+        link_pointer prev = get_previous_start(bucket_index);
+        return prev ? next_node(prev) : node_pointer();
+    }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Node functions
+    std::size_t hash_to_bucket(std::size_t hash_value) const
+    {
+        return policy::to_bucket(bucket_count_, hash_value);
+    }
 
-        static inline node_pointer next_node(link_pointer n) {
-            return static_cast<node_pointer>(n->next_);
+    float load_factor() const
+    {
+        BOOST_ASSERT(bucket_count_ != 0);
+        return static_cast<float>(size_) / static_cast<float>(bucket_count_);
+    }
+
+    std::size_t bucket_size(std::size_t index) const
+    {
+        node_pointer n = begin(index);
+        if (!n)
+            return 0;
+
+        std::size_t count = 0;
+        while (n && hash_to_bucket(n->hash_) == index) {
+            ++count;
+            n = next_node(n);
         }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Data access
+        return count;
+    }
 
-        bucket_allocator const& bucket_alloc() const
-        {
-            return allocators_.first();
+    ////////////////////////////////////////////////////////////////////////
+    // Load methods
+
+    std::size_t max_size() const
+    {
+        using namespace std;
+
+        // size < mlf_ * count
+        return boost::unordered::detail::double_to_size(
+                   ceil(static_cast<double>(mlf_) *
+                        static_cast<double>(max_bucket_count()))) -
+               1;
+    }
+
+    void recalculate_max_load()
+    {
+        using namespace std;
+
+        // From 6.3.1/13:
+        // Only resize when size >= mlf_ * count
+        max_load_ = buckets_ ? boost::unordered::detail::double_to_size(
+                                   ceil(static_cast<double>(mlf_) *
+                                        static_cast<double>(bucket_count_)))
+                             : 0;
+    }
+
+    void max_load_factor(float z)
+    {
+        BOOST_ASSERT(z > 0);
+        mlf_ = (std::max)(z, minimum_max_load_factor);
+        recalculate_max_load();
+    }
+
+    std::size_t min_buckets_for_size(std::size_t size) const
+    {
+        BOOST_ASSERT(mlf_ >= minimum_max_load_factor);
+
+        using namespace std;
+
+        // From 6.3.1/13:
+        // size < mlf_ * count
+        // => count > size / mlf_
+        //
+        // Or from rehash post-condition:
+        // count > size / mlf_
+
+        return policy::new_bucket_count(
+            boost::unordered::detail::double_to_size(
+                floor(static_cast<double>(size) / static_cast<double>(mlf_)) +
+                1));
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Constructors
+
+    table(std::size_t num_buckets, hasher const& hf, key_equal const& eq,
+        node_allocator const& a)
+        : functions(hf, eq), allocators_(a, a),
+          bucket_count_(policy::new_bucket_count(num_buckets)), size_(0),
+          mlf_(1.0f), max_load_(0), buckets_()
+    {
+    }
+
+    table(table const& x, node_allocator const& a)
+        : functions(x), allocators_(a, a),
+          bucket_count_(x.min_buckets_for_size(x.size_)), size_(0),
+          mlf_(x.mlf_), max_load_(0), buckets_()
+    {
+    }
+
+    table(table& x, boost::unordered::detail::move_tag m)
+        : functions(x, m), allocators_(x.allocators_, m),
+          bucket_count_(x.bucket_count_), size_(x.size_), mlf_(x.mlf_),
+          max_load_(x.max_load_), buckets_(x.buckets_)
+    {
+        x.buckets_ = bucket_pointer();
+        x.size_ = 0;
+        x.max_load_ = 0;
+    }
+
+    table(
+        table& x, node_allocator const& a, boost::unordered::detail::move_tag m)
+        : functions(x, m), allocators_(a, a), bucket_count_(x.bucket_count_),
+          size_(0), mlf_(x.mlf_), max_load_(x.max_load_), buckets_()
+    {
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Initialisation.
+
+    void init(table const& x)
+    {
+        if (x.size_) {
+            static_cast<table_impl*>(this)->copy_buckets(x);
         }
+    }
 
-        node_allocator const& node_alloc() const
-        {
-            return allocators_.second();
+    void move_init(table& x)
+    {
+        if (node_alloc() == x.node_alloc()) {
+            move_buckets_from(x);
+        } else if (x.size_) {
+            // TODO: Could pick new bucket size?
+            static_cast<table_impl*>(this)->move_buckets(x);
         }
+    }
 
-        bucket_allocator& bucket_alloc()
+    ////////////////////////////////////////////////////////////////////////
+    // Create buckets
+
+    void create_buckets(std::size_t new_count)
+    {
+        std::size_t length = new_count + 1;
+        bucket_pointer new_buckets =
+            bucket_allocator_traits::allocate(bucket_alloc(), length);
+        bucket_pointer constructed = new_buckets;
+
+        BOOST_TRY
         {
-            return allocators_.first();
-        }
-
-        node_allocator& node_alloc()
-        {
-            return allocators_.second();
-        }
-
-        std::size_t max_bucket_count() const
-        {
-            // -1 to account for the start bucket.
-            return policy::prev_bucket_count(
-                bucket_allocator_traits::max_size(bucket_alloc()) - 1);
-        }
-
-        bucket_pointer get_bucket(std::size_t bucket_index) const
-        {
-            BOOST_ASSERT(buckets_);
-            return buckets_ + static_cast<std::ptrdiff_t>(bucket_index);
-        }
-
-        link_pointer get_previous_start() const
-        {
-            return get_bucket(bucket_count_)->first_from_start();
-        }
-
-        link_pointer get_previous_start(std::size_t bucket_index) const
-        {
-            return get_bucket(bucket_index)->next_;
-        }
-
-        node_pointer begin() const
-        {
-            return size_ ? next_node(get_previous_start()) : node_pointer();
-        }
-
-        node_pointer begin(std::size_t bucket_index) const
-        {
-            if (!size_) return node_pointer();
-            link_pointer prev = get_previous_start(bucket_index);
-            return prev ? next_node(prev) : node_pointer();
-        }
-
-        std::size_t hash_to_bucket(std::size_t hash_value) const
-        {
-            return policy::to_bucket(bucket_count_, hash_value);
-        }
-
-        float load_factor() const
-        {
-            BOOST_ASSERT(bucket_count_ != 0);
-            return static_cast<float>(size_)
-                / static_cast<float>(bucket_count_);
-        }
-
-        std::size_t bucket_size(std::size_t index) const
-        {
-            node_pointer n = begin(index);
-            if (!n) return 0;
-
-            std::size_t count = 0;
-            while(n && hash_to_bucket(n->hash_) == index)
-            {
-                ++count;
-                n = next_node(n);
+            bucket_pointer end =
+                new_buckets + static_cast<std::ptrdiff_t>(length);
+            for (; constructed != end; ++constructed) {
+                new ((void*)boost::addressof(*constructed)) bucket();
             }
 
-            return count;
+            if (buckets_) {
+                // Copy the nodes to the new buckets, including the dummy
+                // node if there is one.
+                (new_buckets + static_cast<std::ptrdiff_t>(new_count))->next_ =
+                    (buckets_ + static_cast<std::ptrdiff_t>(bucket_count_))
+                        ->next_;
+                destroy_buckets();
+            } else if (bucket::extra_node) {
+                node_constructor a(node_alloc());
+                a.create_node();
+
+                (new_buckets + static_cast<std::ptrdiff_t>(new_count))->next_ =
+                    a.release();
+            }
+        }
+        BOOST_CATCH(...)
+        {
+            for (bucket_pointer p = new_buckets; p != constructed; ++p) {
+                boost::unordered::detail::func::destroy(boost::addressof(*p));
+            }
+
+            bucket_allocator_traits::deallocate(
+                bucket_alloc(), new_buckets, length);
+
+            BOOST_RETHROW;
+        }
+        BOOST_CATCH_END
+
+        bucket_count_ = new_count;
+        buckets_ = new_buckets;
+        recalculate_max_load();
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Swap and Move
+
+    void swap_allocators(table& other, false_type)
+    {
+        boost::unordered::detail::func::ignore_unused_variable_warning(other);
+
+        // According to 23.2.1.8, if propagate_on_container_swap is
+        // false the behaviour is undefined unless the allocators
+        // are equal.
+        BOOST_ASSERT(node_alloc() == other.node_alloc());
+    }
+
+    void swap_allocators(table& other, true_type)
+    {
+        allocators_.swap(other.allocators_);
+    }
+
+    // Only swaps the allocators if propagate_on_container_swap
+    void swap(table& x)
+    {
+        set_hash_functions op1(*this, x);
+        set_hash_functions op2(x, *this);
+
+        // I think swap can throw if Propagate::value,
+        // since the allocators' swap can throw. Not sure though.
+        swap_allocators(x, boost::unordered::detail::integral_constant<bool,
+                               allocator_traits<node_allocator>::
+                                   propagate_on_container_swap::value>());
+
+        boost::swap(buckets_, x.buckets_);
+        boost::swap(bucket_count_, x.bucket_count_);
+        boost::swap(size_, x.size_);
+        std::swap(mlf_, x.mlf_);
+        std::swap(max_load_, x.max_load_);
+        op1.commit();
+        op2.commit();
+    }
+
+    // Only call with nodes allocated with the currect allocator, or
+    // one that is equal to it. (Can't assert because other's
+    // allocators might have already been moved).
+    void move_buckets_from(table& other)
+    {
+        BOOST_ASSERT(!buckets_);
+        buckets_ = other.buckets_;
+        bucket_count_ = other.bucket_count_;
+        size_ = other.size_;
+        other.buckets_ = bucket_pointer();
+        other.size_ = 0;
+        other.max_load_ = 0;
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Delete/destruct
+
+    ~table() { delete_buckets(); }
+
+    void delete_node(link_pointer prev)
+    {
+        node_pointer n = static_cast<node_pointer>(prev->next_);
+        prev->next_ = n->next_;
+
+        boost::unordered::detail::func::call_destroy(
+            node_alloc(), n->value_ptr());
+        boost::unordered::detail::func::destroy(boost::addressof(*n));
+        node_allocator_traits::deallocate(node_alloc(), n, 1);
+        --size_;
+    }
+
+    std::size_t delete_nodes(link_pointer prev, link_pointer end)
+    {
+        BOOST_ASSERT(prev->next_ != end);
+
+        std::size_t count = 0;
+
+        do {
+            delete_node(prev);
+            ++count;
+        } while (prev->next_ != end);
+
+        return count;
+    }
+
+    void delete_buckets()
+    {
+        if (buckets_) {
+            if (size_)
+                delete_nodes(get_previous_start(), link_pointer());
+
+            if (bucket::extra_node) {
+                node_pointer n =
+                    static_cast<node_pointer>(get_bucket(bucket_count_)->next_);
+                boost::unordered::detail::func::destroy(boost::addressof(*n));
+                node_allocator_traits::deallocate(node_alloc(), n, 1);
+            }
+
+            destroy_buckets();
+            buckets_ = bucket_pointer();
+            max_load_ = 0;
         }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Load methods
+        BOOST_ASSERT(!size_);
+    }
 
-        std::size_t max_size() const
-        {
-            using namespace std;
+    void clear()
+    {
+        if (!size_)
+            return;
 
-            // size < mlf_ * count
-            return boost::unordered::detail::double_to_size(ceil(
-                    static_cast<double>(mlf_) *
-                    static_cast<double>(max_bucket_count())
-                )) - 1;
+        delete_nodes(get_previous_start(), link_pointer());
+        clear_buckets();
+
+        BOOST_ASSERT(!size_);
+    }
+
+    void clear_buckets()
+    {
+        bucket_pointer end = get_bucket(bucket_count_);
+        for (bucket_pointer it = buckets_; it != end; ++it) {
+            it->next_ = node_pointer();
+        }
+    }
+
+    void destroy_buckets()
+    {
+        bucket_pointer end = get_bucket(bucket_count_ + 1);
+        for (bucket_pointer it = buckets_; it != end; ++it) {
+            boost::unordered::detail::func::destroy(boost::addressof(*it));
         }
 
-        void recalculate_max_load()
-        {
-            using namespace std;
+        bucket_allocator_traits::deallocate(
+            bucket_alloc(), buckets_, bucket_count_ + 1);
+    }
 
-            // From 6.3.1/13:
-            // Only resize when size >= mlf_ * count
-            max_load_ = buckets_ ? boost::unordered::detail::double_to_size(ceil(
-                    static_cast<double>(mlf_) *
-                    static_cast<double>(bucket_count_)
-                )) : 0;
+    ////////////////////////////////////////////////////////////////////////
+    // Fix buckets after delete
+    //
 
+    std::size_t fix_bucket(std::size_t bucket_index, link_pointer prev)
+    {
+        link_pointer end = prev->next_;
+        std::size_t bucket_index2 = bucket_index;
+
+        if (end) {
+            bucket_index2 =
+                hash_to_bucket(static_cast<node_pointer>(end)->hash_);
+
+            // If begin and end are in the same bucket, then
+            // there's nothing to do.
+            if (bucket_index == bucket_index2)
+                return bucket_index2;
+
+            // Update the bucket containing end.
+            get_bucket(bucket_index2)->next_ = prev;
         }
 
-        void max_load_factor(float z)
-        {
-            BOOST_ASSERT(z > 0);
-            mlf_ = (std::max)(z, minimum_max_load_factor);
-            recalculate_max_load();
+        // Check if this bucket is now empty.
+        bucket_pointer this_bucket = get_bucket(bucket_index);
+        if (this_bucket->next_ == prev)
+            this_bucket->next_ = link_pointer();
+
+        return bucket_index2;
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Assignment
+
+    void assign(table const& x)
+    {
+        if (this != boost::addressof(x)) {
+            assign(x, boost::unordered::detail::integral_constant<bool,
+                          allocator_traits<node_allocator>::
+                              propagate_on_container_copy_assignment::value>());
+        }
+    }
+
+    void assign(table const& x, false_type)
+    {
+        // Strong exception safety.
+        set_hash_functions new_func_this(*this, x);
+        mlf_ = x.mlf_;
+        recalculate_max_load();
+
+        if (!size_ && !x.size_) {
+            new_func_this.commit();
+            return;
         }
 
-        std::size_t min_buckets_for_size(std::size_t size) const
-        {
-            BOOST_ASSERT(mlf_ >= minimum_max_load_factor);
-
-            using namespace std;
-
-            // From 6.3.1/13:
-            // size < mlf_ * count
-            // => count > size / mlf_
-            //
-            // Or from rehash post-condition:
-            // count > size / mlf_
-
-            return policy::new_bucket_count(
-                boost::unordered::detail::double_to_size(floor(
-                    static_cast<double>(size) /
-                    static_cast<double>(mlf_)) + 1));
+        if (x.size_ >= max_load_) {
+            create_buckets(min_buckets_for_size(x.size_));
+        } else {
+            clear_buckets();
         }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Constructors
+        new_func_this.commit();
+        static_cast<table_impl*>(this)->assign_buckets(x);
+    }
 
-        table(std::size_t num_buckets,
-                hasher const& hf,
-                key_equal const& eq,
-                node_allocator const& a) :
-            functions(hf, eq),
-            allocators_(a,a),
-            bucket_count_(policy::new_bucket_count(num_buckets)),
-            size_(0),
-            mlf_(1.0f),
-            max_load_(0),
-            buckets_()
-        {}
+    void assign(table const& x, true_type)
+    {
+        if (node_alloc() == x.node_alloc()) {
+            allocators_.assign(x.allocators_);
+            assign(x, false_type());
+        } else {
+            set_hash_functions new_func_this(*this, x);
 
-        table(table const& x, node_allocator const& a) :
-            functions(x),
-            allocators_(a,a),
-            bucket_count_(x.min_buckets_for_size(x.size_)),
-            size_(0),
-            mlf_(x.mlf_),
-            max_load_(0),
-            buckets_()
-        {}
+            // Delete everything with current allocators before assigning
+            // the new ones.
+            delete_buckets();
+            allocators_.assign(x.allocators_);
 
-        table(table& x, boost::unordered::detail::move_tag m) :
-            functions(x, m),
-            allocators_(x.allocators_, m),
-            bucket_count_(x.bucket_count_),
-            size_(x.size_),
-            mlf_(x.mlf_),
-            max_load_(x.max_load_),
-            buckets_(x.buckets_)
-        {
-            x.buckets_ = bucket_pointer();
-            x.size_ = 0;
-            x.max_load_ = 0;
-        }
+            // Copy over other data, all no throw.
+            new_func_this.commit();
+            mlf_ = x.mlf_;
+            bucket_count_ = min_buckets_for_size(x.size_);
+            max_load_ = 0;
 
-        table(table& x, node_allocator const& a,
-                boost::unordered::detail::move_tag m) :
-            functions(x, m),
-            allocators_(a, a),
-            bucket_count_(x.bucket_count_),
-            size_(0),
-            mlf_(x.mlf_),
-            max_load_(x.max_load_),
-            buckets_()
-        {}
-
-        ////////////////////////////////////////////////////////////////////////
-        // Initialisation.
-
-        void init(table const& x)
-        {
+            // Finally copy the elements.
             if (x.size_) {
                 static_cast<table_impl*>(this)->copy_buckets(x);
             }
         }
+    }
 
-        void move_init(table& x)
-        {
-            if(node_alloc() == x.node_alloc()) {
-                move_buckets_from(x);
-            }
-            else if(x.size_) {
-                // TODO: Could pick new bucket size?
-                static_cast<table_impl*>(this)->move_buckets(x);
-            }
+    void move_assign(table& x)
+    {
+        if (this != boost::addressof(x)) {
+            move_assign(
+                x, boost::unordered::detail::integral_constant<bool,
+                       allocator_traits<node_allocator>::
+                           propagate_on_container_move_assignment::value>());
         }
+    }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Create buckets
+    void move_assign(table& x, true_type)
+    {
+        delete_buckets();
+        set_hash_functions new_func_this(*this, x);
+        allocators_.move_assign(x.allocators_);
+        // No throw from here.
+        mlf_ = x.mlf_;
+        max_load_ = x.max_load_;
+        move_buckets_from(x);
+        new_func_this.commit();
+    }
 
-        void create_buckets(std::size_t new_count)
-        {
-            std::size_t length = new_count + 1;
-            bucket_pointer new_buckets = bucket_allocator_traits::allocate(
-                    bucket_alloc(), length);
-            bucket_pointer constructed = new_buckets;
-
-            BOOST_TRY {
-                bucket_pointer end = new_buckets
-                    + static_cast<std::ptrdiff_t>(length);
-                for(; constructed != end; ++constructed) {
-                    new ((void*) boost::addressof(*constructed)) bucket();
-                }
-
-                if (buckets_)
-                {
-                    // Copy the nodes to the new buckets, including the dummy
-                    // node if there is one.
-                    (new_buckets +
-                        static_cast<std::ptrdiff_t>(new_count))->next_ =
-                            (buckets_ + static_cast<std::ptrdiff_t>(
-                                bucket_count_))->next_;
-                    destroy_buckets();
-                }
-                else if (bucket::extra_node)
-                {
-                    node_constructor a(node_alloc());
-                    a.create_node();
-
-                    (new_buckets +
-                        static_cast<std::ptrdiff_t>(new_count))->next_ =
-                            a.release();
-                }
-            }
-            BOOST_CATCH(...) {
-                for(bucket_pointer p = new_buckets; p != constructed; ++p) {
-                    boost::unordered::detail::func::destroy(
-                            boost::addressof(*p));
-                }
-
-                bucket_allocator_traits::deallocate(bucket_alloc(),
-                        new_buckets, length);
-
-                BOOST_RETHROW;
-            }
-            BOOST_CATCH_END
-
-            bucket_count_ = new_count;
-            buckets_ = new_buckets;
-            recalculate_max_load();
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Swap and Move
-
-        void swap_allocators(table& other, false_type)
-        {
-            boost::unordered::detail::func::ignore_unused_variable_warning(other);
-
-            // According to 23.2.1.8, if propagate_on_container_swap is
-            // false the behaviour is undefined unless the allocators
-            // are equal.
-            BOOST_ASSERT(node_alloc() == other.node_alloc());
-        }
-
-        void swap_allocators(table& other, true_type)
-        {
-            allocators_.swap(other.allocators_);
-        }
-
-        // Only swaps the allocators if propagate_on_container_swap
-        void swap(table& x)
-        {
-            set_hash_functions op1(*this, x);
-            set_hash_functions op2(x, *this);
-
-            // I think swap can throw if Propagate::value,
-            // since the allocators' swap can throw. Not sure though.
-            swap_allocators(x,
-                boost::unordered::detail::integral_constant<bool,
-                    allocator_traits<node_allocator>::
-                    propagate_on_container_swap::value>());
-
-            boost::swap(buckets_, x.buckets_);
-            boost::swap(bucket_count_, x.bucket_count_);
-            boost::swap(size_, x.size_);
-            std::swap(mlf_, x.mlf_);
-            std::swap(max_load_, x.max_load_);
-            op1.commit();
-            op2.commit();
-        }
-
-        // Only call with nodes allocated with the currect allocator, or
-        // one that is equal to it. (Can't assert because other's
-        // allocators might have already been moved).
-        void move_buckets_from(table& other)
-        {
-            BOOST_ASSERT(!buckets_);
-            buckets_ = other.buckets_;
-            bucket_count_ = other.bucket_count_;
-            size_ = other.size_;
-            other.buckets_ = bucket_pointer();
-            other.size_ = 0;
-            other.max_load_ = 0;
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Delete/destruct
-
-        ~table()
-        {
+    void move_assign(table& x, false_type)
+    {
+        if (node_alloc() == x.node_alloc()) {
             delete_buckets();
-        }
-
-        void delete_node(link_pointer prev)
-        {
-            node_pointer n = static_cast<node_pointer>(prev->next_);
-            prev->next_ = n->next_;
-
-            boost::unordered::detail::func::call_destroy(node_alloc(),
-                n->value_ptr());
-            boost::unordered::detail::func::destroy(boost::addressof(*n));
-            node_allocator_traits::deallocate(node_alloc(), n, 1);
-            --size_;
-        }
-
-        std::size_t delete_nodes(link_pointer prev, link_pointer end)
-        {
-            BOOST_ASSERT(prev->next_ != end);
-
-            std::size_t count = 0;
-
-            do {
-                delete_node(prev);
-                ++count;
-            } while (prev->next_ != end);
-
-            return count;
-        }
-
-        void delete_buckets()
-        {
-            if(buckets_) {
-                if (size_) delete_nodes(get_previous_start(), link_pointer());
-
-                if (bucket::extra_node) {
-                    node_pointer n = static_cast<node_pointer>(
-                            get_bucket(bucket_count_)->next_);
-                    boost::unordered::detail::func::destroy(
-                            boost::addressof(*n));
-                    node_allocator_traits::deallocate(node_alloc(), n, 1);
-                }
-
-                destroy_buckets();
-                buckets_ = bucket_pointer();
-                max_load_ = 0;
-            }
-
-            BOOST_ASSERT(!size_);
-        }
-
-        void clear()
-        {
-            if (!size_) return;
-
-            delete_nodes(get_previous_start(), link_pointer());
-            clear_buckets();
-
-            BOOST_ASSERT(!size_);
-        }
-
-        void clear_buckets()
-        {
-            bucket_pointer end = get_bucket(bucket_count_);
-            for(bucket_pointer it = buckets_; it != end; ++it)
-            {
-                it->next_ = node_pointer();
-            }
-        }
-
-        void destroy_buckets()
-        {
-            bucket_pointer end = get_bucket(bucket_count_ + 1);
-            for(bucket_pointer it = buckets_; it != end; ++it)
-            {
-                boost::unordered::detail::func::destroy(
-                    boost::addressof(*it));
-            }
-
-            bucket_allocator_traits::deallocate(bucket_alloc(),
-                buckets_, bucket_count_ + 1);
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Fix buckets after delete
-        //
-
-        std::size_t fix_bucket(std::size_t bucket_index, link_pointer prev)
-        {
-            link_pointer end = prev->next_;
-            std::size_t bucket_index2 = bucket_index;
-
-            if (end)
-            {
-                bucket_index2 = hash_to_bucket(
-                    static_cast<node_pointer>(end)->hash_);
-
-                // If begin and end are in the same bucket, then
-                // there's nothing to do.
-                if (bucket_index == bucket_index2) return bucket_index2;
-
-                // Update the bucket containing end.
-                get_bucket(bucket_index2)->next_ = prev;
-            }
-
-            // Check if this bucket is now empty.
-            bucket_pointer this_bucket = get_bucket(bucket_index);
-            if (this_bucket->next_ == prev)
-                this_bucket->next_ = link_pointer();
-
-            return bucket_index2;
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Assignment
-
-        void assign(table const& x)
-        {
-            if (this != boost::addressof(x))
-            {
-                assign(x,
-                    boost::unordered::detail::integral_constant<bool,
-                        allocator_traits<node_allocator>::
-                        propagate_on_container_copy_assignment::value>());
-            }
-        }
-
-        void assign(table const& x, false_type)
-        {
-            // Strong exception safety.
+            set_hash_functions new_func_this(*this, x);
+            // No throw from here.
+            mlf_ = x.mlf_;
+            max_load_ = x.max_load_;
+            move_buckets_from(x);
+            new_func_this.commit();
+        } else {
             set_hash_functions new_func_this(*this, x);
             mlf_ = x.mlf_;
             recalculate_max_load();
@@ -2996,196 +3027,108 @@ namespace boost { namespace unordered { namespace detail {
 
             if (x.size_ >= max_load_) {
                 create_buckets(min_buckets_for_size(x.size_));
-            }
-            else {
+            } else {
                 clear_buckets();
             }
 
             new_func_this.commit();
-            static_cast<table_impl*>(this)->assign_buckets(x);
-        }
-
-        void assign(table const& x, true_type)
-        {
-            if (node_alloc() == x.node_alloc()) {
-                allocators_.assign(x.allocators_);
-                assign(x, false_type());
-            }
-            else {
-                set_hash_functions new_func_this(*this, x);
-
-                // Delete everything with current allocators before assigning
-                // the new ones.
-                delete_buckets();
-                allocators_.assign(x.allocators_);
-
-                // Copy over other data, all no throw.
-                new_func_this.commit();
-                mlf_ = x.mlf_;
-                bucket_count_ = min_buckets_for_size(x.size_);
-                max_load_ = 0;
-
-                // Finally copy the elements.
-                if (x.size_) {
-                    static_cast<table_impl*>(this)->copy_buckets(x);
-                }
-            }
-        }
-
-        void move_assign(table& x)
-        {
-            if (this != boost::addressof(x))
-            {
-                move_assign(x,
-                    boost::unordered::detail::integral_constant<bool,
-                        allocator_traits<node_allocator>::
-                        propagate_on_container_move_assignment::value>());
-            }
-        }
-
-        void move_assign(table& x, true_type)
-        {
-            delete_buckets();
-            set_hash_functions new_func_this(*this, x);
-            allocators_.move_assign(x.allocators_);
-            // No throw from here.
-            mlf_ = x.mlf_;
-            max_load_ = x.max_load_;
-            move_buckets_from(x);
-            new_func_this.commit();
-        }
-
-        void move_assign(table& x, false_type)
-        {
-            if (node_alloc() == x.node_alloc()) {
-                delete_buckets();
-                set_hash_functions new_func_this(*this, x);
-                // No throw from here.
-                mlf_ = x.mlf_;
-                max_load_ = x.max_load_;
-                move_buckets_from(x);
-                new_func_this.commit();
-            }
-            else {
-                set_hash_functions new_func_this(*this, x);
-                mlf_ = x.mlf_;
-                recalculate_max_load();
-
-                if (!size_ && !x.size_) {
-                    new_func_this.commit();
-                    return;
-                }
-
-                if (x.size_ >= max_load_) {
-                    create_buckets(min_buckets_for_size(x.size_));
-                }
-                else {
-                    clear_buckets();
-                }
-
-                new_func_this.commit();
-                static_cast<table_impl*>(this)->move_assign_buckets(x);
-            }
-        }
-
-        // Accessors
-
-        key_type const& get_key(value_type const& x) const
-        {
-            return extractor::extract(x);
-        }
-
-        std::size_t hash(key_type const& k) const
-        {
-            return policy::apply_hash(this->hash_function(), k);
-        }
-
-        // Find Node
-
-        template <typename Key, typename Hash, typename Pred>
-        node_pointer generic_find_node(
-                Key const& k,
-                Hash const& hf,
-                Pred const& eq) const
-        {
-            return static_cast<table_impl const*>(this)->
-                find_node_impl(policy::apply_hash(hf, k), k, eq);
-        }
-
-        node_pointer find_node(
-                std::size_t key_hash,
-                key_type const& k) const
-        {
-            return static_cast<table_impl const*>(this)->
-                find_node_impl(key_hash, k, this->key_eq());
-        }
-
-        node_pointer find_node(key_type const& k) const
-        {
-            return static_cast<table_impl const*>(this)->
-                find_node_impl(hash(k), k, this->key_eq());
-        }
-
-        // Reserve and rehash
-
-        void reserve_for_insert(std::size_t);
-        void rehash(std::size_t);
-        void reserve(std::size_t);
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Reserve & Rehash
-
-    // basic exception safety
-    template <typename Types>
-    inline void table<Types>::reserve_for_insert(std::size_t size)
-    {
-        if (!buckets_) {
-            create_buckets((std::max)(bucket_count_,
-                min_buckets_for_size(size)));
-        }
-        // According to the standard this should be 'size >= max_load_',
-        // but I think this is better, defect report filed.
-        else if(size > max_load_) {
-            std::size_t num_buckets
-                = min_buckets_for_size((std::max)(size,
-                    size_ + (size_ >> 1)));
-
-            if (num_buckets != bucket_count_)
-                static_cast<table_impl*>(this)->rehash_impl(num_buckets);
+            static_cast<table_impl*>(this)->move_assign_buckets(x);
         }
     }
 
-    // if hash function throws, basic exception safety
-    // strong otherwise.
+    // Accessors
 
-    template <typename Types>
-    inline void table<Types>::rehash(std::size_t min_buckets)
+    key_type const& get_key(value_type const& x) const
     {
-        using namespace std;
-
-        if(!size_) {
-            delete_buckets();
-            bucket_count_ = policy::new_bucket_count(min_buckets);
-        }
-        else {
-            min_buckets = policy::new_bucket_count((std::max)(min_buckets,
-                boost::unordered::detail::double_to_size(floor(
-                    static_cast<double>(size_) /
-                    static_cast<double>(mlf_))) + 1));
-
-            if(min_buckets != bucket_count_)
-                static_cast<table_impl*>(this)->rehash_impl(min_buckets);
-        }
+        return extractor::extract(x);
     }
 
-    template <typename Types>
-    inline void table<Types>::reserve(std::size_t num_elements)
+    std::size_t hash(key_type const& k) const
     {
-        rehash(static_cast<std::size_t>(
-            std::ceil(static_cast<double>(num_elements) / mlf_)));
+        return policy::apply_hash(this->hash_function(), k);
     }
-}}}
+
+    // Find Node
+
+    template <typename Key, typename Hash, typename Pred>
+    node_pointer generic_find_node(
+        Key const& k, Hash const& hf, Pred const& eq) const
+    {
+        return static_cast<table_impl const*>(this)->find_node_impl(
+            policy::apply_hash(hf, k), k, eq);
+    }
+
+    node_pointer find_node(std::size_t key_hash, key_type const& k) const
+    {
+        return static_cast<table_impl const*>(this)->find_node_impl(
+            key_hash, k, this->key_eq());
+    }
+
+    node_pointer find_node(key_type const& k) const
+    {
+        return static_cast<table_impl const*>(this)->find_node_impl(
+            hash(k), k, this->key_eq());
+    }
+
+    // Reserve and rehash
+
+    void reserve_for_insert(std::size_t);
+    void rehash(std::size_t);
+    void reserve(std::size_t);
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Reserve & Rehash
+
+// basic exception safety
+template <typename Types>
+inline void table<Types>::reserve_for_insert(std::size_t size)
+{
+    if (!buckets_) {
+        create_buckets((std::max)(bucket_count_, min_buckets_for_size(size)));
+    }
+    // According to the standard this should be 'size >= max_load_',
+    // but I think this is better, defect report filed.
+    else if (size > max_load_) {
+        std::size_t num_buckets =
+            min_buckets_for_size((std::max)(size, size_ + (size_ >> 1)));
+
+        if (num_buckets != bucket_count_)
+            static_cast<table_impl*>(this)->rehash_impl(num_buckets);
+    }
+}
+
+// if hash function throws, basic exception safety
+// strong otherwise.
+
+template <typename Types>
+inline void table<Types>::rehash(std::size_t min_buckets)
+{
+    using namespace std;
+
+    if (!size_) {
+        delete_buckets();
+        bucket_count_ = policy::new_bucket_count(min_buckets);
+    } else {
+        min_buckets = policy::new_bucket_count((std::max)(min_buckets,
+            boost::unordered::detail::double_to_size(
+                floor(static_cast<double>(size_) / static_cast<double>(mlf_))) +
+                1));
+
+        if (min_buckets != bucket_count_)
+            static_cast<table_impl*>(this)->rehash_impl(min_buckets);
+    }
+}
+
+template <typename Types>
+inline void table<Types>::reserve(std::size_t num_elements)
+{
+    rehash(static_cast<std::size_t>(
+        std::ceil(static_cast<double>(num_elements) / mlf_)));
+}
+}
+}
+}
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
@@ -3195,1554 +3138,1490 @@ namespace boost {
 namespace unordered {
 namespace detail {
 
-    // key extractors
-    //
-    // no throw
-    //
-    // 'extract_key' is called with the emplace parameters to return a
-    // key if available or 'no_key' is one isn't and will need to be
-    // constructed. This could be done by overloading the emplace implementation
-    // for the different cases, but that's a bit tricky on compilers without
-    // variadic templates.
+// key extractors
+//
+// no throw
+//
+// 'extract_key' is called with the emplace parameters to return a
+// key if available or 'no_key' is one isn't and will need to be
+// constructed. This could be done by overloading the emplace implementation
+// for the different cases, but that's a bit tricky on compilers without
+// variadic templates.
 
-    struct no_key {
-        no_key() {}
-        template <class T> no_key(T const&) {}
-    };
+struct no_key
+{
+    no_key() {}
+    template <class T> no_key(T const&) {}
+};
 
-    template <typename Key, typename T>
-    struct is_key {
-        template <typename T2>
-        static choice1::type test(T2 const&);
-        static choice2::type test(Key const&);
+template <typename Key, typename T> struct is_key
+{
+    template <typename T2> static choice1::type test(T2 const&);
+    static choice2::type test(Key const&);
 
-        enum { value = sizeof(test(boost::unordered::detail::make<T>())) ==
-            sizeof(choice2::type) };
-
-        typedef typename boost::detail::if_true<value>::
-            BOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type;
-    };
-
-    template <class ValueType>
-    struct set_extractor
+    enum
     {
-        typedef ValueType value_type;
-        typedef ValueType key_type;
+        value = sizeof(test(boost::unordered::detail::make<T>())) ==
+                sizeof(choice2::type)
+    };
 
-        static key_type const& extract(value_type const& v)
-        {
-            return v;
-        }
+    typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE
+        then<Key const&, no_key>::type type;
+};
 
-        static no_key extract()
-        {
-            return no_key();
-        }
+template <class ValueType> struct set_extractor
+{
+    typedef ValueType value_type;
+    typedef ValueType key_type;
 
-        template <class Arg>
-        static no_key extract(Arg const&)
-        {
-            return no_key();
-        }
+    static key_type const& extract(value_type const& v) { return v; }
+
+    static no_key extract() { return no_key(); }
+
+    template <class Arg> static no_key extract(Arg const&) { return no_key(); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class Arg1, class Arg2, class... Args>
-        static no_key extract(Arg1 const&, Arg2 const&, Args const&...)
-        {
-            return no_key();
-        }
+    template <class Arg1, class Arg2, class... Args>
+    static no_key extract(Arg1 const&, Arg2 const&, Args const&...)
+    {
+        return no_key();
+    }
 #else
-        template <class Arg1, class Arg2>
-        static no_key extract(Arg1 const&, Arg2 const&)
-        {
-            return no_key();
-        }
-#endif
-    };
-
-    template <class Key, class ValueType>
-    struct map_extractor
+    template <class Arg1, class Arg2>
+    static no_key extract(Arg1 const&, Arg2 const&)
     {
-        typedef ValueType value_type;
-        typedef typename boost::remove_const<Key>::type key_type;
+        return no_key();
+    }
+#endif
+};
 
-        static key_type const& extract(value_type const& v)
-        {
-            return v.first;
-        }
+template <class Key, class ValueType> struct map_extractor
+{
+    typedef ValueType value_type;
+    typedef typename boost::remove_const<Key>::type key_type;
 
-        template <class Second>
-        static key_type const& extract(std::pair<key_type, Second> const& v)
-        {
-            return v.first;
-        }
+    static key_type const& extract(value_type const& v) { return v.first; }
 
-        template <class Second>
-        static key_type const& extract(
-            std::pair<key_type const, Second> const& v)
-        {
-            return v.first;
-        }
+    template <class Second>
+    static key_type const& extract(std::pair<key_type, Second> const& v)
+    {
+        return v.first;
+    }
 
-        template <class Arg1>
-        static key_type const& extract(key_type const& k, Arg1 const&)
-        {
-            return k;
-        }
+    template <class Second>
+    static key_type const& extract(std::pair<key_type const, Second> const& v)
+    {
+        return v.first;
+    }
 
-        static no_key extract()
-        {
-            return no_key();
-        }
+    template <class Arg1>
+    static key_type const& extract(key_type const& k, Arg1 const&)
+    {
+        return k;
+    }
 
-        template <class Arg>
-        static no_key extract(Arg const&)
-        {
-            return no_key();
-        }
+    static no_key extract() { return no_key(); }
 
-        template <class Arg1, class Arg2>
-        static no_key extract(Arg1 const&, Arg2 const&)
-        {
-            return no_key();
-        }
+    template <class Arg> static no_key extract(Arg const&) { return no_key(); }
+
+    template <class Arg1, class Arg2>
+    static no_key extract(Arg1 const&, Arg2 const&)
+    {
+        return no_key();
+    }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class Arg1, class Arg2, class Arg3, class... Args>
-        static no_key extract(Arg1 const&, Arg2 const&, Arg3 const&,
-                Args const&...)
-        {
-            return no_key();
-        }
+    template <class Arg1, class Arg2, class Arg3, class... Args>
+    static no_key extract(Arg1 const&, Arg2 const&, Arg3 const&, Args const&...)
+    {
+        return no_key();
+    }
 #endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
-        template <typename T2>                                              \
-        static no_key extract(boost::unordered::piecewise_construct_t,      \
-                namespace_ tuple<> const&, T2 const&)                       \
-        {                                                                   \
-            return no_key();                                                \
-        }                                                                   \
-                                                                            \
-        template <typename T, typename T2>                                  \
-        static typename is_key<key_type, T>::type                           \
-            extract(boost::unordered::piecewise_construct_t,                \
-                namespace_ tuple<T> const& k, T2 const&)                    \
-        {                                                                   \
-            return typename is_key<key_type, T>::type(                      \
-                namespace_ get<0>(k));                                      \
-        }
+#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                             \
+    template <typename T2>                                                     \
+    static no_key extract(boost::unordered::piecewise_construct_t,             \
+        namespace_ tuple<> const&, T2 const&)                                  \
+    {                                                                          \
+        return no_key();                                                       \
+    }                                                                          \
+                                                                               \
+    template <typename T, typename T2>                                         \
+    static typename is_key<key_type, T>::type extract(                         \
+        boost::unordered::piecewise_construct_t, namespace_ tuple<T> const& k, \
+        T2 const&)                                                             \
+    {                                                                          \
+        return typename is_key<key_type, T>::type(namespace_ get<0>(k));       \
+    }
 
 #else
 
-#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
-        static no_key extract(boost::unordered::piecewise_construct_t,      \
-                namespace_ tuple<> const&)                                  \
-        {                                                                   \
-            return no_key();                                                \
-        }                                                                   \
-                                                                            \
-        template <typename T>                                               \
-        static typename is_key<key_type, T>::type                           \
-            extract(boost::unordered::piecewise_construct_t,                \
-                namespace_ tuple<T> const& k)                               \
-        {                                                                   \
-            return typename is_key<key_type, T>::type(                      \
-                namespace_ get<0>(k));                                      \
-        }
+#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                             \
+    static no_key extract(                                                     \
+        boost::unordered::piecewise_construct_t, namespace_ tuple<> const&)    \
+    {                                                                          \
+        return no_key();                                                       \
+    }                                                                          \
+                                                                               \
+    template <typename T>                                                      \
+    static typename is_key<key_type, T>::type extract(                         \
+        boost::unordered::piecewise_construct_t, namespace_ tuple<T> const& k) \
+    {                                                                          \
+        return typename is_key<key_type, T>::type(namespace_ get<0>(k));       \
+    }
 
 #endif
 
-BOOST_UNORDERED_KEY_FROM_TUPLE(boost::)
+    BOOST_UNORDERED_KEY_FROM_TUPLE(boost::)
 
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-BOOST_UNORDERED_KEY_FROM_TUPLE(std::)
+    BOOST_UNORDERED_KEY_FROM_TUPLE(std::)
 #endif
-    };
-}}}
+};
+}
+}
+}
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost {
+namespace unordered {
+namespace detail {
 
-    template <typename A, typename T> struct unique_node;
-    template <typename T> struct ptr_node;
-    template <typename Types> struct table_impl;
+template <typename A, typename T> struct unique_node;
+template <typename T> struct ptr_node;
+template <typename Types> struct table_impl;
 
-    template <typename A, typename T>
-    struct unique_node :
-        boost::unordered::detail::value_base<T>
+template <typename A, typename T>
+struct unique_node : boost::unordered::detail::value_base<T>
+{
+    typedef typename ::boost::unordered::detail::rebind_wrap<A,
+        unique_node<A, T> >::type allocator;
+    typedef typename ::boost::unordered::detail::allocator_traits<
+        allocator>::pointer node_pointer;
+    typedef node_pointer link_pointer;
+
+    link_pointer next_;
+    std::size_t hash_;
+
+    unique_node() : next_(), hash_(0) {}
+
+    void init(node_pointer) {}
+
+  private:
+    unique_node& operator=(unique_node const&);
+};
+
+template <typename T> struct ptr_node : boost::unordered::detail::ptr_bucket
+{
+    typedef T value_type;
+    typedef boost::unordered::detail::ptr_bucket bucket_base;
+    typedef ptr_node<T>* node_pointer;
+    typedef ptr_bucket* link_pointer;
+
+    std::size_t hash_;
+    boost::unordered::detail::value_base<T> value_base_;
+
+    ptr_node() : bucket_base(), hash_(0) {}
+
+    void init(node_pointer) {}
+
+    void* address() { return value_base_.address(); }
+    value_type& value() { return value_base_.value(); }
+    value_type* value_ptr() { return value_base_.value_ptr(); }
+
+  private:
+    ptr_node& operator=(ptr_node const&);
+};
+
+// If the allocator uses raw pointers use ptr_node
+// Otherwise use node.
+
+template <typename A, typename T, typename NodePtr, typename BucketPtr>
+struct pick_node2
+{
+    typedef boost::unordered::detail::unique_node<A, T> node;
+
+    typedef typename boost::unordered::detail::allocator_traits<
+        typename boost::unordered::detail::rebind_wrap<A, node>::type>::pointer
+        node_pointer;
+
+    typedef boost::unordered::detail::bucket<node_pointer> bucket;
+    typedef node_pointer link_pointer;
+};
+
+template <typename A, typename T>
+struct pick_node2<A, T, boost::unordered::detail::ptr_node<T>*,
+    boost::unordered::detail::ptr_bucket*>
+{
+    typedef boost::unordered::detail::ptr_node<T> node;
+    typedef boost::unordered::detail::ptr_bucket bucket;
+    typedef bucket* link_pointer;
+};
+
+template <typename A, typename T> struct pick_node
+{
+    typedef typename boost::remove_const<T>::type nonconst;
+
+    typedef boost::unordered::detail::allocator_traits<
+        typename boost::unordered::detail::rebind_wrap<A,
+            boost::unordered::detail::ptr_node<nonconst> >::type>
+        tentative_node_traits;
+
+    typedef boost::unordered::detail::allocator_traits<
+        typename boost::unordered::detail::rebind_wrap<A,
+            boost::unordered::detail::ptr_bucket>::type>
+        tentative_bucket_traits;
+
+    typedef pick_node2<A, nonconst, typename tentative_node_traits::pointer,
+        typename tentative_bucket_traits::pointer>
+        pick;
+
+    typedef typename pick::node node;
+    typedef typename pick::bucket bucket;
+    typedef typename pick::link_pointer link_pointer;
+};
+
+template <typename Types>
+struct table_impl : boost::unordered::detail::table<Types>
+{
+    typedef boost::unordered::detail::table<Types> table;
+    typedef typename table::value_type value_type;
+    typedef typename table::bucket bucket;
+    typedef typename table::policy policy;
+    typedef typename table::node_pointer node_pointer;
+    typedef typename table::node_allocator node_allocator;
+    typedef typename table::node_allocator_traits node_allocator_traits;
+    typedef typename table::bucket_pointer bucket_pointer;
+    typedef typename table::link_pointer link_pointer;
+    typedef typename table::hasher hasher;
+    typedef typename table::key_equal key_equal;
+    typedef typename table::key_type key_type;
+    typedef typename table::node_constructor node_constructor;
+    typedef typename table::node_tmp node_tmp;
+    typedef typename table::extractor extractor;
+    typedef typename table::iterator iterator;
+    typedef typename table::c_iterator c_iterator;
+
+    typedef std::pair<iterator, bool> emplace_return;
+
+    // Constructors
+
+    table_impl(std::size_t n, hasher const& hf, key_equal const& eq,
+        node_allocator const& a)
+        : table(n, hf, eq, a)
     {
-        typedef typename ::boost::unordered::detail::rebind_wrap<
-            A, unique_node<A, T> >::type allocator;
-        typedef typename ::boost::unordered::detail::
-            allocator_traits<allocator>::pointer node_pointer;
-        typedef node_pointer link_pointer;
+    }
 
-        link_pointer next_;
-        std::size_t hash_;
-
-        unique_node() :
-            next_(),
-            hash_(0)
-        {}
-
-        void init(node_pointer)
-        {
-        }
-
-    private:
-        unique_node& operator=(unique_node const&);
-    };
-
-    template <typename T>
-    struct ptr_node :
-        boost::unordered::detail::ptr_bucket
+    table_impl(table_impl const& x)
+        : table(x, node_allocator_traits::select_on_container_copy_construction(
+                       x.node_alloc()))
     {
-        typedef T value_type;
-        typedef boost::unordered::detail::ptr_bucket bucket_base;
-        typedef ptr_node<T>* node_pointer;
-        typedef ptr_bucket* link_pointer;
+        this->init(x);
+    }
 
-        std::size_t hash_;
-        boost::unordered::detail::value_base<T> value_base_;
-
-        ptr_node() :
-            bucket_base(),
-            hash_(0)
-        {}
-
-        void init(node_pointer)
-        {
-        }
-
-        void* address() { return value_base_.address(); }
-        value_type& value() { return value_base_.value(); }
-        value_type* value_ptr() { return value_base_.value_ptr(); }
-
-    private:
-        ptr_node& operator=(ptr_node const&);
-    };
-
-    // If the allocator uses raw pointers use ptr_node
-    // Otherwise use node.
-
-    template <typename A, typename T, typename NodePtr, typename BucketPtr>
-    struct pick_node2
+    table_impl(table_impl const& x, node_allocator const& a) : table(x, a)
     {
-        typedef boost::unordered::detail::unique_node<A, T> node;
+        this->init(x);
+    }
 
-        typedef typename boost::unordered::detail::allocator_traits<
-            typename boost::unordered::detail::rebind_wrap<A, node>::type
-        >::pointer node_pointer;
-
-        typedef boost::unordered::detail::bucket<node_pointer> bucket;
-        typedef node_pointer link_pointer;
-    };
-
-    template <typename A, typename T>
-    struct pick_node2<A, T,
-        boost::unordered::detail::ptr_node<T>*,
-        boost::unordered::detail::ptr_bucket*>
+    table_impl(table_impl& x, boost::unordered::detail::move_tag m)
+        : table(x, m)
     {
-        typedef boost::unordered::detail::ptr_node<T> node;
-        typedef boost::unordered::detail::ptr_bucket bucket;
-        typedef bucket* link_pointer;
-    };
+    }
 
-    template <typename A, typename T>
-    struct pick_node
+    table_impl(table_impl& x, node_allocator const& a,
+        boost::unordered::detail::move_tag m)
+        : table(x, a, m)
     {
-        typedef typename boost::remove_const<T>::type nonconst;
+        this->move_init(x);
+    }
 
-        typedef boost::unordered::detail::allocator_traits<
-            typename boost::unordered::detail::rebind_wrap<A,
-                boost::unordered::detail::ptr_node<nonconst> >::type
-        > tentative_node_traits;
+    // Node functions.
 
-        typedef boost::unordered::detail::allocator_traits<
-            typename boost::unordered::detail::rebind_wrap<A,
-                boost::unordered::detail::ptr_bucket >::type
-        > tentative_bucket_traits;
-
-        typedef pick_node2<A, nonconst,
-            typename tentative_node_traits::pointer,
-            typename tentative_bucket_traits::pointer> pick;
-
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
-    };
-
-    template <typename Types>
-    struct table_impl : boost::unordered::detail::table<Types>
+    static inline node_pointer next_node(link_pointer n)
     {
-        typedef boost::unordered::detail::table<Types> table;
-        typedef typename table::value_type value_type;
-        typedef typename table::bucket bucket;
-        typedef typename table::policy policy;
-        typedef typename table::node_pointer node_pointer;
-        typedef typename table::node_allocator node_allocator;
-        typedef typename table::node_allocator_traits node_allocator_traits;
-        typedef typename table::bucket_pointer bucket_pointer;
-        typedef typename table::link_pointer link_pointer;
-        typedef typename table::hasher hasher;
-        typedef typename table::key_equal key_equal;
-        typedef typename table::key_type key_type;
-        typedef typename table::node_constructor node_constructor;
-        typedef typename table::node_tmp node_tmp;
-        typedef typename table::extractor extractor;
-        typedef typename table::iterator iterator;
-        typedef typename table::c_iterator c_iterator;
+        return static_cast<node_pointer>(n->next_);
+    }
 
-        typedef std::pair<iterator, bool> emplace_return;
+    // Accessors
 
-        // Constructors
+    template <class Key, class Pred>
+    node_pointer find_node_impl(
+        std::size_t key_hash, Key const& k, Pred const& eq) const
+    {
+        std::size_t bucket_index = this->hash_to_bucket(key_hash);
+        node_pointer n = this->begin(bucket_index);
 
-        table_impl(std::size_t n,
-                hasher const& hf,
-                key_equal const& eq,
-                node_allocator const& a)
-          : table(n, hf, eq, a)
-        {}
+        for (;;) {
+            if (!n)
+                return n;
 
-        table_impl(table_impl const& x)
-          : table(x, node_allocator_traits::
-                select_on_container_copy_construction(x.node_alloc()))
-        {
-            this->init(x);
-        }
-
-        table_impl(table_impl const& x,
-                node_allocator const& a)
-          : table(x, a)
-        {
-            this->init(x);
-        }
-
-        table_impl(table_impl& x,
-                boost::unordered::detail::move_tag m)
-          : table(x, m)
-        {}
-
-        table_impl(table_impl& x,
-                node_allocator const& a,
-                boost::unordered::detail::move_tag m)
-          : table(x, a, m)
-        {
-            this->move_init(x);
-        }
-
-        // Node functions.
-
-        static inline node_pointer next_node(link_pointer n) {
-            return static_cast<node_pointer>(n->next_);
-        }
-
-        // Accessors
-
-        template <class Key, class Pred>
-        node_pointer find_node_impl(
-                std::size_t key_hash,
-                Key const& k,
-                Pred const& eq) const
-        {
-            std::size_t bucket_index = this->hash_to_bucket(key_hash);
-            node_pointer n = this->begin(bucket_index);
-
-            for (;;)
-            {
-                if (!n) return n;
-
-                std::size_t node_hash = n->hash_;
-                if (key_hash == node_hash)
-                {
-                    if (eq(k, this->get_key(n->value())))
-                        return n;
-                }
-                else
-                {
-                    if (this->hash_to_bucket(node_hash) != bucket_index)
-                        return node_pointer();
-                }
-
-                n = next_node(n);
-            }
-        }
-
-        std::size_t count(key_type const& k) const
-        {
-            return this->find_node(k) ? 1 : 0;
-        }
-
-        value_type& at(key_type const& k) const
-        {
-            if (this->size_) {
-                node_pointer n = this->find_node(k);
-                if (n) return n->value();
+            std::size_t node_hash = n->hash_;
+            if (key_hash == node_hash) {
+                if (eq(k, this->get_key(n->value())))
+                    return n;
+            } else {
+                if (this->hash_to_bucket(node_hash) != bucket_index)
+                    return node_pointer();
             }
 
-            boost::throw_exception(
-                std::out_of_range("Unable to find key in unordered_map."));
+            n = next_node(n);
         }
+    }
 
-        std::pair<iterator, iterator>
-            equal_range(key_type const& k) const
-        {
+    std::size_t count(key_type const& k) const
+    {
+        return this->find_node(k) ? 1 : 0;
+    }
+
+    value_type& at(key_type const& k) const
+    {
+        if (this->size_) {
             node_pointer n = this->find_node(k);
-            return std::make_pair(iterator(n), iterator(n ? next_node(n) : n));
+            if (n)
+                return n->value();
         }
 
-        // equals
+        boost::throw_exception(
+            std::out_of_range("Unable to find key in unordered_map."));
+    }
 
-        bool equals(table_impl const& other) const
-        {
-            if(this->size_ != other.size_) return false;
+    std::pair<iterator, iterator> equal_range(key_type const& k) const
+    {
+        node_pointer n = this->find_node(k);
+        return std::make_pair(iterator(n), iterator(n ? next_node(n) : n));
+    }
 
-            for(node_pointer n1 = this->begin(); n1; n1 = next_node(n1))
-            {
-                node_pointer n2 = other.find_node(other.get_key(n1->value()));
+    // equals
 
-                if (!n2 || n1->value() != n2->value())
+    bool equals(table_impl const& other) const
+    {
+        if (this->size_ != other.size_)
+            return false;
+
+        for (node_pointer n1 = this->begin(); n1; n1 = next_node(n1)) {
+            node_pointer n2 = other.find_node(other.get_key(n1->value()));
+
+            if (!n2 || n1->value() != n2->value())
+                return false;
+        }
+
+        return true;
+    }
+
+    // Emplace/Insert
+
+    inline node_pointer add_node(node_pointer n, std::size_t key_hash)
+    {
+        n->hash_ = key_hash;
+
+        bucket_pointer b = this->get_bucket(this->hash_to_bucket(key_hash));
+
+        if (!b->next_) {
+            link_pointer start_node = this->get_previous_start();
+
+            if (start_node->next_) {
+                this->get_bucket(
+                        this->hash_to_bucket(next_node(start_node)->hash_))
+                    ->next_ = n;
+            }
+
+            b->next_ = start_node;
+            n->next_ = start_node->next_;
+            start_node->next_ = n;
+        } else {
+            n->next_ = b->next_->next_;
+            b->next_->next_ = n;
+        }
+
+        ++this->size_;
+        return n;
+    }
+
+    inline node_pointer resize_and_add_node(
+        node_pointer n, std::size_t key_hash)
+    {
+        node_tmp b(n, this->node_alloc());
+        this->reserve_for_insert(this->size_ + 1);
+        return this->add_node(b.release(), key_hash);
+    }
+
+    value_type& operator[](key_type const& k)
+    {
+        std::size_t key_hash = this->hash(k);
+        node_pointer pos = this->find_node(key_hash, k);
+        if (pos) {
+            return pos->value();
+        } else {
+            return this
+                ->resize_and_add_node(
+                    boost::unordered::detail::func::construct_node_pair(
+                        this->node_alloc(), k),
+                    key_hash)
+                ->value();
+        }
+    }
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    emplace_return emplace(boost::unordered::detail::emplace_args1<
+        boost::unordered::detail::please_ignore_this_overload> const&)
+    {
+        BOOST_ASSERT(false);
+        return emplace_return(iterator(), false);
+    }
+
+    iterator emplace_hint(
+        c_iterator,
+        boost::unordered::detail::emplace_args1<
+            boost::unordered::detail::please_ignore_this_overload> const&)
+    {
+        BOOST_ASSERT(false);
+        return iterator();
+    }
+#else
+    emplace_return emplace(
+        boost::unordered::detail::please_ignore_this_overload const&)
+    {
+        BOOST_ASSERT(false);
+        return emplace_return(iterator(), false);
+    }
+
+    iterator emplace_hint(c_iterator,
+        boost::unordered::detail::please_ignore_this_overload const&)
+    {
+        BOOST_ASSERT(false);
+        return iterator();
+    }
+#endif
+#endif
+
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS)
+    {
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+        return emplace_impl(extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
+            BOOST_UNORDERED_EMPLACE_FORWARD);
+#else
+        return emplace_impl(extractor::extract(args.a0, args.a1),
+            BOOST_UNORDERED_EMPLACE_FORWARD);
+#endif
+    }
+
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    iterator emplace_hint(c_iterator hint, BOOST_UNORDERED_EMPLACE_ARGS)
+    {
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+        return emplace_hint_impl(hint,
+            extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
+            BOOST_UNORDERED_EMPLACE_FORWARD);
+#else
+        return emplace_hint_impl(hint, extractor::extract(args.a0, args.a1),
+            BOOST_UNORDERED_EMPLACE_FORWARD);
+#endif
+    }
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <typename A0>
+    emplace_return emplace(
+        boost::unordered::detail::emplace_args1<A0> const& args)
+    {
+        return emplace_impl(extractor::extract(args.a0), args);
+    }
+
+    template <typename A0>
+    iterator emplace_hint(c_iterator hint,
+        boost::unordered::detail::emplace_args1<A0> const& args)
+    {
+        return emplace_hint_impl(hint, extractor::extract(args.a0), args);
+    }
+#endif
+
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    iterator emplace_hint_impl(
+        c_iterator hint, key_type const& k, BOOST_UNORDERED_EMPLACE_ARGS)
+    {
+        if (hint.node_ && this->key_eq()(k, this->get_key(*hint))) {
+            return iterator(hint.node_);
+        } else {
+            return emplace_impl(k, BOOST_UNORDERED_EMPLACE_FORWARD).first;
+        }
+    }
+
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    emplace_return emplace_impl(key_type const& k, BOOST_UNORDERED_EMPLACE_ARGS)
+    {
+        std::size_t key_hash = this->hash(k);
+        node_pointer pos = this->find_node(key_hash, k);
+        if (pos) {
+            return emplace_return(iterator(pos), false);
+        } else {
+            return emplace_return(
+                iterator(this->resize_and_add_node(
+                    boost::unordered::detail::func::construct_node_from_args(
+                        this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
+                    key_hash)),
+                true);
+        }
+    }
+
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    iterator emplace_hint_impl(
+        c_iterator hint, no_key, BOOST_UNORDERED_EMPLACE_ARGS)
+    {
+        node_tmp b(boost::unordered::detail::func::construct_node_from_args(
+                       this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
+            this->node_alloc());
+        key_type const& k = this->get_key(b.node_->value());
+        if (hint.node_ && this->key_eq()(k, this->get_key(*hint))) {
+            return iterator(hint.node_);
+        }
+        std::size_t key_hash = this->hash(k);
+        node_pointer pos = this->find_node(key_hash, k);
+        if (pos) {
+            return iterator(pos);
+        } else {
+            return iterator(this->resize_and_add_node(b.release(), key_hash));
+        }
+    }
+
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    emplace_return emplace_impl(no_key, BOOST_UNORDERED_EMPLACE_ARGS)
+    {
+        node_tmp b(boost::unordered::detail::func::construct_node_from_args(
+                       this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
+            this->node_alloc());
+        key_type const& k = this->get_key(b.node_->value());
+        std::size_t key_hash = this->hash(k);
+        node_pointer pos = this->find_node(key_hash, k);
+        if (pos) {
+            return emplace_return(iterator(pos), false);
+        } else {
+            return emplace_return(
+                iterator(this->resize_and_add_node(b.release(), key_hash)),
+                true);
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Insert range methods
+    //
+    // if hash function throws, or inserting > 1 element, basic exception
+    // safety strong otherwise
+
+    template <class InputIt> void insert_range(InputIt i, InputIt j)
+    {
+        if (i != j)
+            return insert_range_impl(extractor::extract(*i), i, j);
+    }
+
+    template <class InputIt>
+    void insert_range_impl(key_type const& k, InputIt i, InputIt j)
+    {
+        insert_range_impl2(k, i, j);
+
+        while (++i != j) {
+            // Note: can't use get_key as '*i' might not be value_type - it
+            // could be a pair with first_types as key_type without const or
+            // a different second_type.
+            //
+            // TODO: Might be worth storing the value_type instead of the
+            // key here. Could be more efficient if '*i' is expensive. Could
+            // be less efficient if copying the full value_type is
+            // expensive.
+            insert_range_impl2(extractor::extract(*i), i, j);
+        }
+    }
+
+    template <class InputIt>
+    void insert_range_impl2(key_type const& k, InputIt i, InputIt j)
+    {
+        // No side effects in this initial code
+        std::size_t key_hash = this->hash(k);
+        node_pointer pos = this->find_node(key_hash, k);
+
+        if (!pos) {
+            node_tmp b(boost::unordered::detail::func::construct_node(
+                           this->node_alloc(), *i),
+                this->node_alloc());
+            if (this->size_ + 1 > this->max_load_)
+                this->reserve_for_insert(
+                    this->size_ + boost::unordered::detail::insert_size(i, j));
+            this->add_node(b.release(), key_hash);
+        }
+    }
+
+    template <class InputIt>
+    void insert_range_impl(no_key, InputIt i, InputIt j)
+    {
+        node_constructor a(this->node_alloc());
+
+        do {
+            if (!a.node_) {
+                a.create_node();
+            }
+            boost::unordered::detail::func::call_construct(
+                a.alloc_, a.node_->value_ptr(), *i);
+            node_tmp b(a.release(), a.alloc_);
+
+            key_type const& k = this->get_key(b.node_->value());
+            std::size_t key_hash = this->hash(k);
+            node_pointer pos = this->find_node(key_hash, k);
+
+            if (pos) {
+                a.reclaim(b.release());
+            } else {
+                // reserve has basic exception safety if the hash function
+                // throws, strong otherwise.
+                this->reserve_for_insert(this->size_ + 1);
+                this->add_node(b.release(), key_hash);
+            }
+        } while (++i != j);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Erase
+    //
+    // no throw
+
+    std::size_t erase_key(key_type const& k)
+    {
+        if (!this->size_)
+            return 0;
+
+        std::size_t key_hash = this->hash(k);
+        std::size_t bucket_index = this->hash_to_bucket(key_hash);
+        link_pointer prev = this->get_previous_start(bucket_index);
+        if (!prev)
+            return 0;
+
+        for (;;) {
+            if (!prev->next_)
+                return 0;
+            std::size_t node_hash = next_node(prev)->hash_;
+            if (this->hash_to_bucket(node_hash) != bucket_index)
+                return 0;
+            if (node_hash == key_hash &&
+                this->key_eq()(k, this->get_key(next_node(prev)->value())))
+                break;
+            prev = prev->next_;
+        }
+
+        link_pointer end = next_node(prev)->next_;
+
+        std::size_t deleted_count = this->delete_nodes(prev, end);
+        this->fix_bucket(bucket_index, prev);
+        return deleted_count;
+    }
+
+    iterator erase(c_iterator r)
+    {
+        BOOST_ASSERT(r.node_);
+        node_pointer next = next_node(r.node_);
+        erase_nodes(r.node_, next);
+        return iterator(next);
+    }
+
+    iterator erase_range(c_iterator r1, c_iterator r2)
+    {
+        if (r1 == r2)
+            return iterator(r2.node_);
+        erase_nodes(r1.node_, r2.node_);
+        return iterator(r2.node_);
+    }
+
+    void erase_nodes(node_pointer i, node_pointer j)
+    {
+        std::size_t bucket_index = this->hash_to_bucket(i->hash_);
+
+        // Find the node before i.
+        link_pointer prev = this->get_previous_start(bucket_index);
+        while (prev->next_ != i)
+            prev = prev->next_;
+
+        // Delete the nodes.
+        do {
+            this->delete_node(prev);
+            bucket_index = this->fix_bucket(bucket_index, prev);
+        } while (prev->next_ != j);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // fill_buckets
+
+    void copy_buckets(table const& src)
+    {
+        this->create_buckets(this->bucket_count_);
+
+        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+            this->add_node(boost::unordered::detail::func::construct_node(
+                               this->node_alloc(), n->value()),
+                n->hash_);
+        }
+    }
+
+    void move_buckets(table const& src)
+    {
+        this->create_buckets(this->bucket_count_);
+
+        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+            this->add_node(boost::unordered::detail::func::construct_node(
+                               this->node_alloc(), boost::move(n->value())),
+                n->hash_);
+        }
+    }
+
+    void assign_buckets(table const& src)
+    {
+        node_holder<node_allocator> holder(*this);
+        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+            this->add_node(holder.copy_of(n->value()), n->hash_);
+        }
+    }
+
+    void move_assign_buckets(table& src)
+    {
+        node_holder<node_allocator> holder(*this);
+        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+            this->add_node(holder.move_copy_of(n->value()), n->hash_);
+        }
+    }
+
+    // strong otherwise exception safety
+    void rehash_impl(std::size_t num_buckets)
+    {
+        BOOST_ASSERT(this->buckets_);
+
+        this->create_buckets(num_buckets);
+        link_pointer prev = this->get_previous_start();
+        while (prev->next_)
+            prev = place_in_bucket(*this, prev);
+    }
+
+    // Iterate through the nodes placing them in the correct buckets.
+    // pre: prev->next_ is not null.
+    static link_pointer place_in_bucket(table& dst, link_pointer prev)
+    {
+        node_pointer n = next_node(prev);
+        bucket_pointer b = dst.get_bucket(dst.hash_to_bucket(n->hash_));
+
+        if (!b->next_) {
+            b->next_ = prev;
+            return n;
+        } else {
+            prev->next_ = n->next_;
+            n->next_ = b->next_->next_;
+            b->next_->next_ = n;
+            return prev;
+        }
+    }
+};
+}
+}
+}
+
+namespace boost {
+namespace unordered {
+namespace detail {
+
+template <typename A, typename T> struct grouped_node;
+template <typename T> struct grouped_ptr_node;
+template <typename Types> struct grouped_table_impl;
+
+template <typename A, typename T>
+struct grouped_node : boost::unordered::detail::value_base<T>
+{
+    typedef typename ::boost::unordered::detail::rebind_wrap<A,
+        grouped_node<A, T> >::type allocator;
+    typedef typename ::boost::unordered::detail::allocator_traits<
+        allocator>::pointer node_pointer;
+    typedef node_pointer link_pointer;
+
+    link_pointer next_;
+    node_pointer group_prev_;
+    std::size_t hash_;
+
+    grouped_node() : next_(), group_prev_(), hash_(0) {}
+
+    void init(node_pointer self) { group_prev_ = self; }
+
+  private:
+    grouped_node& operator=(grouped_node const&);
+};
+
+template <typename T>
+struct grouped_ptr_node : boost::unordered::detail::ptr_bucket
+{
+    typedef T value_type;
+    typedef boost::unordered::detail::ptr_bucket bucket_base;
+    typedef grouped_ptr_node<T>* node_pointer;
+    typedef ptr_bucket* link_pointer;
+
+    node_pointer group_prev_;
+    std::size_t hash_;
+    boost::unordered::detail::value_base<T> value_base_;
+
+    grouped_ptr_node() : bucket_base(), group_prev_(0), hash_(0) {}
+
+    void init(node_pointer self) { group_prev_ = self; }
+
+    void* address() { return value_base_.address(); }
+    value_type& value() { return value_base_.value(); }
+    value_type* value_ptr() { return value_base_.value_ptr(); }
+
+  private:
+    grouped_ptr_node& operator=(grouped_ptr_node const&);
+};
+
+// If the allocator uses raw pointers use grouped_ptr_node
+// Otherwise use grouped_node.
+
+template <typename A, typename T, typename NodePtr, typename BucketPtr>
+struct pick_grouped_node2
+{
+    typedef boost::unordered::detail::grouped_node<A, T> node;
+
+    typedef typename boost::unordered::detail::allocator_traits<
+        typename boost::unordered::detail::rebind_wrap<A, node>::type>::pointer
+        node_pointer;
+
+    typedef boost::unordered::detail::bucket<node_pointer> bucket;
+    typedef node_pointer link_pointer;
+};
+
+template <typename A, typename T>
+struct pick_grouped_node2<A, T, boost::unordered::detail::grouped_ptr_node<T>*,
+    boost::unordered::detail::ptr_bucket*>
+{
+    typedef boost::unordered::detail::grouped_ptr_node<T> node;
+    typedef boost::unordered::detail::ptr_bucket bucket;
+    typedef bucket* link_pointer;
+};
+
+template <typename A, typename T> struct pick_grouped_node
+{
+    typedef typename boost::remove_const<T>::type nonconst;
+
+    typedef boost::unordered::detail::allocator_traits<
+        typename boost::unordered::detail::rebind_wrap<A,
+            boost::unordered::detail::grouped_ptr_node<nonconst> >::type>
+        tentative_node_traits;
+
+    typedef boost::unordered::detail::allocator_traits<
+        typename boost::unordered::detail::rebind_wrap<A,
+            boost::unordered::detail::ptr_bucket>::type>
+        tentative_bucket_traits;
+
+    typedef pick_grouped_node2<A, nonconst,
+        typename tentative_node_traits::pointer,
+        typename tentative_bucket_traits::pointer>
+        pick;
+
+    typedef typename pick::node node;
+    typedef typename pick::bucket bucket;
+    typedef typename pick::link_pointer link_pointer;
+};
+
+template <typename Types>
+struct grouped_table_impl : boost::unordered::detail::table<Types>
+{
+    typedef boost::unordered::detail::table<Types> table;
+    typedef typename table::value_type value_type;
+    typedef typename table::bucket bucket;
+    typedef typename table::policy policy;
+    typedef typename table::node_pointer node_pointer;
+    typedef typename table::node_allocator node_allocator;
+    typedef typename table::node_allocator_traits node_allocator_traits;
+    typedef typename table::bucket_pointer bucket_pointer;
+    typedef typename table::link_pointer link_pointer;
+    typedef typename table::hasher hasher;
+    typedef typename table::key_equal key_equal;
+    typedef typename table::key_type key_type;
+    typedef typename table::node_constructor node_constructor;
+    typedef typename table::node_tmp node_tmp;
+    typedef typename table::extractor extractor;
+    typedef typename table::iterator iterator;
+    typedef typename table::c_iterator c_iterator;
+
+    // Constructors
+
+    grouped_table_impl(std::size_t n, hasher const& hf, key_equal const& eq,
+        node_allocator const& a)
+        : table(n, hf, eq, a)
+    {
+    }
+
+    grouped_table_impl(grouped_table_impl const& x)
+        : table(x, node_allocator_traits::select_on_container_copy_construction(
+                       x.node_alloc()))
+    {
+        this->init(x);
+    }
+
+    grouped_table_impl(grouped_table_impl const& x, node_allocator const& a)
+        : table(x, a)
+    {
+        this->init(x);
+    }
+
+    grouped_table_impl(
+        grouped_table_impl& x, boost::unordered::detail::move_tag m)
+        : table(x, m)
+    {
+    }
+
+    grouped_table_impl(grouped_table_impl& x, node_allocator const& a,
+        boost::unordered::detail::move_tag m)
+        : table(x, a, m)
+    {
+        this->move_init(x);
+    }
+
+    // Node functions.
+
+    static inline node_pointer next_node(link_pointer n)
+    {
+        return static_cast<node_pointer>(n->next_);
+    }
+
+    static inline node_pointer next_group(node_pointer n)
+    {
+        return static_cast<node_pointer>(n->group_prev_->next_);
+    }
+
+    // Accessors
+
+    template <class Key, class Pred>
+    node_pointer find_node_impl(
+        std::size_t key_hash, Key const& k, Pred const& eq) const
+    {
+        std::size_t bucket_index = this->hash_to_bucket(key_hash);
+        node_pointer n = this->begin(bucket_index);
+
+        for (;;) {
+            if (!n)
+                return n;
+
+            std::size_t node_hash = n->hash_;
+            if (key_hash == node_hash) {
+                if (eq(k, this->get_key(n->value())))
+                    return n;
+            } else {
+                if (this->hash_to_bucket(node_hash) != bucket_index)
+                    return node_pointer();
+            }
+
+            n = next_group(n);
+        }
+    }
+
+    std::size_t count(key_type const& k) const
+    {
+        node_pointer n = this->find_node(k);
+        if (!n)
+            return 0;
+
+        std::size_t x = 0;
+        node_pointer it = n;
+        do {
+            it = it->group_prev_;
+            ++x;
+        } while (it != n);
+
+        return x;
+    }
+
+    std::pair<iterator, iterator> equal_range(key_type const& k) const
+    {
+        node_pointer n = this->find_node(k);
+        return std::make_pair(iterator(n), iterator(n ? next_group(n) : n));
+    }
+
+    // Equality
+
+    bool equals(grouped_table_impl const& other) const
+    {
+        if (this->size_ != other.size_)
+            return false;
+
+        for (node_pointer n1 = this->begin(); n1;) {
+            node_pointer n2 = other.find_node(other.get_key(n1->value()));
+            if (!n2)
+                return false;
+            node_pointer end1 = next_group(n1);
+            node_pointer end2 = next_group(n2);
+            if (!group_equals(n1, end1, n2, end2))
+                return false;
+            n1 = end1;
+        }
+
+        return true;
+    }
+
+    static bool group_equals(
+        node_pointer n1, node_pointer end1, node_pointer n2, node_pointer end2)
+    {
+        for (;;) {
+            if (n1->value() != n2->value())
+                break;
+
+            n1 = next_node(n1);
+            n2 = next_node(n2);
+
+            if (n1 == end1)
+                return n2 == end2;
+            if (n2 == end2)
+                return false;
+        }
+
+        for (node_pointer n1a = n1, n2a = n2;;) {
+            n1a = next_node(n1a);
+            n2a = next_node(n2a);
+
+            if (n1a == end1) {
+                if (n2a == end2)
+                    break;
+                else
                     return false;
             }
 
-            return true;
+            if (n2a == end2)
+                return false;
         }
 
-        // Emplace/Insert
+        node_pointer start = n1;
+        for (; n1 != end1; n1 = next_node(n1)) {
+            value_type const& v = n1->value();
+            if (!find(start, n1, v)) {
+                std::size_t matches = count_equal(n2, end2, v);
+                if (!matches)
+                    return false;
+                if (matches != 1 + count_equal(next_node(n1), end1, v))
+                    return false;
+            }
+        }
 
-        inline node_pointer add_node(
-                node_pointer n,
-                std::size_t key_hash)
-        {
-            n->hash_ = key_hash;
+        return true;
+    }
 
+    static bool find(node_pointer n, node_pointer end, value_type const& v)
+    {
+        for (; n != end; n = next_node(n))
+            if (n->value() == v)
+                return true;
+        return false;
+    }
+
+    static std::size_t count_equal(
+        node_pointer n, node_pointer end, value_type const& v)
+    {
+        std::size_t count = 0;
+        for (; n != end; n = next_node(n))
+            if (n->value() == v)
+                ++count;
+        return count;
+    }
+
+    // Emplace/Insert
+
+    // Add node 'n' to the group containing 'pos'.
+    // If 'pos' is the first node in group, add to the end of the group,
+    // otherwise add before 'pos'.
+    static inline void add_to_node_group(node_pointer n, node_pointer pos)
+    {
+        n->next_ = pos->group_prev_->next_;
+        n->group_prev_ = pos->group_prev_;
+        pos->group_prev_->next_ = n;
+        pos->group_prev_ = n;
+    }
+
+    inline node_pointer add_node(
+        node_pointer n, std::size_t key_hash, node_pointer pos)
+    {
+        n->hash_ = key_hash;
+        if (pos) {
+            this->add_to_node_group(n, pos);
+            if (n->next_) {
+                std::size_t next_bucket =
+                    this->hash_to_bucket(next_node(n)->hash_);
+                if (next_bucket != this->hash_to_bucket(key_hash)) {
+                    this->get_bucket(next_bucket)->next_ = n;
+                }
+            }
+        } else {
             bucket_pointer b = this->get_bucket(this->hash_to_bucket(key_hash));
 
-            if (!b->next_)
-            {
+            if (!b->next_) {
                 link_pointer start_node = this->get_previous_start();
 
                 if (start_node->next_) {
-                    this->get_bucket(this->hash_to_bucket(
-                        next_node(start_node)->hash_)
-                    )->next_ = n;
+                    this->get_bucket(
+                            this->hash_to_bucket(next_node(start_node)->hash_))
+                        ->next_ = n;
                 }
 
                 b->next_ = start_node;
                 n->next_ = start_node->next_;
                 start_node->next_ = n;
-            }
-            else
-            {
+            } else {
                 n->next_ = b->next_->next_;
                 b->next_->next_ = n;
             }
-
-            ++this->size_;
-            return n;
         }
+        ++this->size_;
+        return n;
+    }
 
-        inline node_pointer resize_and_add_node(node_pointer n, std::size_t key_hash)
-        {
-            node_tmp b(n, this->node_alloc());
-            this->reserve_for_insert(this->size_ + 1);
-            return this->add_node(b.release(), key_hash);
-        }
-
-        value_type& operator[](key_type const& k)
-        {
-            std::size_t key_hash = this->hash(k);
-            node_pointer pos = this->find_node(key_hash, k);
-            if (pos) {
-                return pos->value();
-            }
-            else {
-                return this->resize_and_add_node(
-                    boost::unordered::detail::func::construct_node_pair(this->node_alloc(), k),
-                    key_hash)->value();
+    inline node_pointer add_using_hint(node_pointer n, node_pointer hint)
+    {
+        n->hash_ = hint->hash_;
+        this->add_to_node_group(n, hint);
+        if (n->next_ != hint && n->next_) {
+            std::size_t next_bucket = this->hash_to_bucket(next_node(n)->hash_);
+            if (next_bucket != this->hash_to_bucket(n->hash_)) {
+                this->get_bucket(next_bucket)->next_ = n;
             }
         }
+        ++this->size_;
+        return n;
+    }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        emplace_return emplace(boost::unordered::detail::emplace_args1<
-                boost::unordered::detail::please_ignore_this_overload> const&)
-        {
-            BOOST_ASSERT(false);
-            return emplace_return(iterator(), false);
-        }
-
-        iterator emplace_hint(c_iterator,
-            boost::unordered::detail::emplace_args1<
-                boost::unordered::detail::please_ignore_this_overload> const&)
-        {
-            BOOST_ASSERT(false);
-            return iterator();
-        }
-#   else
-        emplace_return emplace(
-                boost::unordered::detail::please_ignore_this_overload const&)
-        {
-            BOOST_ASSERT(false);
-            return emplace_return(iterator(), false);
-        }
-
-        iterator emplace_hint(c_iterator,
-                boost::unordered::detail::please_ignore_this_overload const&)
-        {
-            BOOST_ASSERT(false);
-            return iterator();
-        }
-#   endif
-#endif
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-            return emplace_impl(
-                extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
-#else
-            return emplace_impl(
-                extractor::extract(args.a0, args.a1),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
-#endif
-        }
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        iterator emplace_hint(c_iterator hint,
-            BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-            return emplace_hint_impl(hint,
-                extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
-#else
-            return emplace_hint_impl(hint,
-                extractor::extract(args.a0, args.a1),
-                BOOST_UNORDERED_EMPLACE_FORWARD);
-#endif
-        }
-
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <typename A0>
-        emplace_return emplace(
-                boost::unordered::detail::emplace_args1<A0> const& args)
-        {
-            return emplace_impl(extractor::extract(args.a0), args);
-        }
+    iterator emplace(boost::unordered::detail::emplace_args1<
+        boost::unordered::detail::please_ignore_this_overload> const&)
+    {
+        BOOST_ASSERT(false);
+        return iterator();
+    }
 
-        template <typename A0>
-        iterator emplace_hint(c_iterator hint,
-                boost::unordered::detail::emplace_args1<A0> const& args)
-        {
-            return emplace_hint_impl(hint, extractor::extract(args.a0), args);
-        }
+    iterator emplace_hint(
+        c_iterator,
+        boost::unordered::detail::emplace_args1<
+            boost::unordered::detail::please_ignore_this_overload> const&)
+    {
+        BOOST_ASSERT(false);
+        return iterator();
+    }
+#else
+    iterator emplace(
+        boost::unordered::detail::please_ignore_this_overload const&)
+    {
+        BOOST_ASSERT(false);
+        return iterator();
+    }
+
+    iterator emplace_hint(c_iterator,
+        boost::unordered::detail::please_ignore_this_overload const&)
+    {
+        BOOST_ASSERT(false);
+        return iterator();
+    }
+#endif
 #endif
 
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        iterator emplace_hint_impl(c_iterator hint, key_type const& k,
-            BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-            if (hint.node_ && this->key_eq()(k, this->get_key(*hint))) {
-                return iterator(hint.node_);
-            }
-            else {
-                return emplace_impl(k, BOOST_UNORDERED_EMPLACE_FORWARD).first;
-            }
-        }
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        emplace_return emplace_impl(key_type const& k,
-            BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-            std::size_t key_hash = this->hash(k);
-            node_pointer pos = this->find_node(key_hash, k);
-            if (pos) {
-                return emplace_return(iterator(pos), false);
-            }
-            else {
-                return emplace_return(
-                    iterator(this->resize_and_add_node(
-                        boost::unordered::detail::func::construct_node_from_args(
-                            this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
-                        key_hash)),
-                    true);
-            }
-        }
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        iterator emplace_hint_impl(c_iterator hint, no_key,
-            BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-            node_tmp b(
-                boost::unordered::detail::func::construct_node_from_args(
-                    this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
-                this->node_alloc());
-            key_type const& k = this->get_key(b.node_->value());
-            if (hint.node_ && this->key_eq()(k, this->get_key(*hint))) {
-                return iterator(hint.node_);
-            }
-            std::size_t key_hash = this->hash(k);
-            node_pointer pos = this->find_node(key_hash, k);
-            if (pos) {
-                return iterator(pos);
-            }
-            else {
-                return iterator(this->resize_and_add_node(b.release(), key_hash));
-            }
-        }
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        emplace_return emplace_impl(no_key, BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-            node_tmp b(
-                boost::unordered::detail::func::construct_node_from_args(
-                    this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
-                this->node_alloc());
-            key_type const& k = this->get_key(b.node_->value());
-            std::size_t key_hash = this->hash(k);
-            node_pointer pos = this->find_node(key_hash, k);
-            if (pos) {
-                return emplace_return(iterator(pos), false);
-            }
-            else {
-                return emplace_return(
-                    iterator(this->resize_and_add_node(b.release(), key_hash)),
-                    true);
-            }
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Insert range methods
-        //
-        // if hash function throws, or inserting > 1 element, basic exception
-        // safety strong otherwise
-
-        template <class InputIt>
-        void insert_range(InputIt i, InputIt j)
-        {
-            if(i != j)
-                return insert_range_impl(extractor::extract(*i), i, j);
-        }
-
-        template <class InputIt>
-        void insert_range_impl(key_type const& k, InputIt i, InputIt j)
-        {
-            insert_range_impl2(k, i, j);
-
-            while(++i != j) {
-                // Note: can't use get_key as '*i' might not be value_type - it
-                // could be a pair with first_types as key_type without const or
-                // a different second_type.
-                //
-                // TODO: Might be worth storing the value_type instead of the
-                // key here. Could be more efficient if '*i' is expensive. Could
-                // be less efficient if copying the full value_type is
-                // expensive.
-                insert_range_impl2(extractor::extract(*i), i, j);
-            }
-        }
-
-        template <class InputIt>
-        void insert_range_impl2(key_type const& k, InputIt i, InputIt j)
-        {
-            // No side effects in this initial code
-            std::size_t key_hash = this->hash(k);
-            node_pointer pos = this->find_node(key_hash, k);
-
-            if (!pos) {
-                node_tmp b(
-                    boost::unordered::detail::func::construct_node(this->node_alloc(), *i),
-                    this->node_alloc());
-                if(this->size_ + 1 > this->max_load_)
-                    this->reserve_for_insert(this->size_ +
-                        boost::unordered::detail::insert_size(i, j));
-                this->add_node(b.release(), key_hash);
-            }
-        }
-
-        template <class InputIt>
-        void insert_range_impl(no_key, InputIt i, InputIt j)
-        {
-            node_constructor a(this->node_alloc());
-
-            do {
-                if (!a.node_) { a.create_node(); }
-                boost::unordered::detail::func::call_construct(
-                    a.alloc_, a.node_->value_ptr(), *i);
-                node_tmp b(a.release(), a.alloc_);
-
-                key_type const& k = this->get_key(b.node_->value());
-                std::size_t key_hash = this->hash(k);
-                node_pointer pos = this->find_node(key_hash, k);
-
-                if (pos) {
-                    a.reclaim(b.release());
-                }
-                else {
-                    // reserve has basic exception safety if the hash function
-                    // throws, strong otherwise.
-                    this->reserve_for_insert(this->size_ + 1);
-                    this->add_node(b.release(), key_hash);
-                }
-            } while(++i != j);
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // Erase
-        //
-        // no throw
-
-        std::size_t erase_key(key_type const& k)
-        {
-            if(!this->size_) return 0;
-
-            std::size_t key_hash = this->hash(k);
-            std::size_t bucket_index = this->hash_to_bucket(key_hash);
-            link_pointer prev = this->get_previous_start(bucket_index);
-            if (!prev) return 0;
-
-            for (;;)
-            {
-                if (!prev->next_) return 0;
-                std::size_t node_hash = next_node(prev)->hash_;
-                if (this->hash_to_bucket(node_hash) != bucket_index)
-                    return 0;
-                if (node_hash == key_hash &&
-                        this->key_eq()(k, this->get_key(
-                        next_node(prev)->value())))
-                    break;
-                prev = prev->next_;
-            }
-
-            link_pointer end = next_node(prev)->next_;
-
-            std::size_t deleted_count = this->delete_nodes(prev, end);
-            this->fix_bucket(bucket_index, prev);
-            return deleted_count;
-        }
-
-        iterator erase(c_iterator r)
-        {
-            BOOST_ASSERT(r.node_);
-            node_pointer next = next_node(r.node_);
-            erase_nodes(r.node_, next);
-            return iterator(next);
-        }
-
-        iterator erase_range(c_iterator r1, c_iterator r2)
-        {
-            if (r1 == r2) return iterator(r2.node_);
-            erase_nodes(r1.node_, r2.node_);
-            return iterator(r2.node_);
-        }
-
-        void erase_nodes(node_pointer i, node_pointer j)
-        {
-            std::size_t bucket_index = this->hash_to_bucket(i->hash_);
-
-            // Find the node before i.
-            link_pointer prev = this->get_previous_start(bucket_index);
-            while(prev->next_ != i) prev = prev->next_;
-
-            // Delete the nodes.
-            do {
-                this->delete_node(prev);
-                bucket_index = this->fix_bucket(bucket_index, prev);
-            } while (prev->next_ != j);
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // fill_buckets
-
-        void copy_buckets(table const& src) {
-            this->create_buckets(this->bucket_count_);
-
-            for(node_pointer n = src.begin(); n; n = next_node(n)) {
-                this->add_node(
-                    boost::unordered::detail::func::construct_node(
-                     this->node_alloc(), n->value()), n->hash_);
-            }
-        }
-
-        void move_buckets(table const& src) {
-            this->create_buckets(this->bucket_count_);
-
-            for(node_pointer n = src.begin(); n; n = next_node(n)) {
-                this->add_node(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), boost::move(n->value())), n->hash_);
-            }
-        }
-
-        void assign_buckets(table const& src)
-        {
-            node_holder<node_allocator> holder(*this);
-            for(node_pointer n = src.begin(); n; n = next_node(n)) {
-                this->add_node(holder.copy_of(n->value()), n->hash_);
-            }
-        }
-
-        void move_assign_buckets(table& src)
-        {
-            node_holder<node_allocator> holder(*this);
-            for(node_pointer n = src.begin(); n; n = next_node(n)) {
-                this->add_node(holder.move_copy_of(n->value()), n->hash_);
-            }
-        }
-
-        // strong otherwise exception safety
-        void rehash_impl(std::size_t num_buckets)
-        {
-            BOOST_ASSERT(this->buckets_);
-
-            this->create_buckets(num_buckets);
-            link_pointer prev = this->get_previous_start();
-            while (prev->next_)
-                prev = place_in_bucket(*this, prev);
-        }
-
-        // Iterate through the nodes placing them in the correct buckets.
-        // pre: prev->next_ is not null.
-        static link_pointer place_in_bucket(table& dst, link_pointer prev)
-        {
-            node_pointer n = next_node(prev);
-            bucket_pointer b = dst.get_bucket(dst.hash_to_bucket(n->hash_));
-
-            if (!b->next_) {
-                b->next_ = prev;
-                return n;
-            }
-            else {
-                prev->next_ = n->next_;
-                n->next_ = b->next_->next_;
-                b->next_->next_ = n;
-                return prev;
-            }
-        }
-    };
-}}}
-
-namespace boost { namespace unordered { namespace detail {
-
-    template <typename A, typename T> struct grouped_node;
-    template <typename T> struct grouped_ptr_node;
-    template <typename Types> struct grouped_table_impl;
-
-    template <typename A, typename T>
-    struct grouped_node :
-        boost::unordered::detail::value_base<T>
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    iterator emplace(BOOST_UNORDERED_EMPLACE_ARGS)
     {
-        typedef typename ::boost::unordered::detail::rebind_wrap<
-            A, grouped_node<A, T> >::type allocator;
-        typedef typename ::boost::unordered::detail::
-            allocator_traits<allocator>::pointer node_pointer;
-        typedef node_pointer link_pointer;
+        return iterator(emplace_impl(
+            boost::unordered::detail::func::construct_node_from_args(
+                this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD)));
+    }
 
-        link_pointer next_;
-        node_pointer group_prev_;
-        std::size_t hash_;
-
-        grouped_node() :
-            next_(),
-            group_prev_(),
-            hash_(0)
-        {}
-
-        void init(node_pointer self)
-        {
-            group_prev_ = self;
-        }
-
-    private:
-        grouped_node& operator=(grouped_node const&);
-    };
-
-    template <typename T>
-    struct grouped_ptr_node :
-        boost::unordered::detail::ptr_bucket
+    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+    iterator emplace_hint(c_iterator hint, BOOST_UNORDERED_EMPLACE_ARGS)
     {
-        typedef T value_type;
-        typedef boost::unordered::detail::ptr_bucket bucket_base;
-        typedef grouped_ptr_node<T>* node_pointer;
-        typedef ptr_bucket* link_pointer;
+        return iterator(emplace_hint_impl(
+            hint, boost::unordered::detail::func::construct_node_from_args(
+                      this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD)));
+    }
 
-        node_pointer group_prev_;
-        std::size_t hash_;
-        boost::unordered::detail::value_base<T> value_base_;
-
-        grouped_ptr_node() :
-            bucket_base(),
-            group_prev_(0),
-            hash_(0)
-        {}
-
-        void init(node_pointer self)
-        {
-            group_prev_ = self;
-        }
-
-        void* address() { return value_base_.address(); }
-        value_type& value() { return value_base_.value(); }
-        value_type* value_ptr() { return value_base_.value_ptr(); }
-
-    private:
-        grouped_ptr_node& operator=(grouped_ptr_node const&);
-    };
-
-    // If the allocator uses raw pointers use grouped_ptr_node
-    // Otherwise use grouped_node.
-
-    template <typename A, typename T, typename NodePtr, typename BucketPtr>
-    struct pick_grouped_node2
+    iterator emplace_impl(node_pointer n)
     {
-        typedef boost::unordered::detail::grouped_node<A, T> node;
+        node_tmp a(n, this->node_alloc());
+        key_type const& k = this->get_key(a.node_->value());
+        std::size_t key_hash = this->hash(k);
+        node_pointer position = this->find_node(key_hash, k);
+        this->reserve_for_insert(this->size_ + 1);
+        return iterator(this->add_node(a.release(), key_hash, position));
+    }
 
-        typedef typename boost::unordered::detail::allocator_traits<
-            typename boost::unordered::detail::rebind_wrap<A, node>::type
-        >::pointer node_pointer;
-
-        typedef boost::unordered::detail::bucket<node_pointer> bucket;
-        typedef node_pointer link_pointer;
-    };
-
-    template <typename A, typename T>
-    struct pick_grouped_node2<A, T,
-        boost::unordered::detail::grouped_ptr_node<T>*,
-        boost::unordered::detail::ptr_bucket*>
+    iterator emplace_hint_impl(c_iterator hint, node_pointer n)
     {
-        typedef boost::unordered::detail::grouped_ptr_node<T> node;
-        typedef boost::unordered::detail::ptr_bucket bucket;
-        typedef bucket* link_pointer;
-    };
-
-    template <typename A, typename T>
-    struct pick_grouped_node
-    {
-        typedef typename boost::remove_const<T>::type nonconst;
-
-        typedef boost::unordered::detail::allocator_traits<
-            typename boost::unordered::detail::rebind_wrap<A,
-                boost::unordered::detail::grouped_ptr_node<nonconst> >::type
-        > tentative_node_traits;
-
-        typedef boost::unordered::detail::allocator_traits<
-            typename boost::unordered::detail::rebind_wrap<A,
-                boost::unordered::detail::ptr_bucket >::type
-        > tentative_bucket_traits;
-
-        typedef pick_grouped_node2<A, nonconst,
-            typename tentative_node_traits::pointer,
-            typename tentative_bucket_traits::pointer> pick;
-
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
-    };
-
-    template <typename Types>
-    struct grouped_table_impl : boost::unordered::detail::table<Types>
-    {
-        typedef boost::unordered::detail::table<Types> table;
-        typedef typename table::value_type value_type;
-        typedef typename table::bucket bucket;
-        typedef typename table::policy policy;
-        typedef typename table::node_pointer node_pointer;
-        typedef typename table::node_allocator node_allocator;
-        typedef typename table::node_allocator_traits node_allocator_traits;
-        typedef typename table::bucket_pointer bucket_pointer;
-        typedef typename table::link_pointer link_pointer;
-        typedef typename table::hasher hasher;
-        typedef typename table::key_equal key_equal;
-        typedef typename table::key_type key_type;
-        typedef typename table::node_constructor node_constructor;
-        typedef typename table::node_tmp node_tmp;
-        typedef typename table::extractor extractor;
-        typedef typename table::iterator iterator;
-        typedef typename table::c_iterator c_iterator;
-
-        // Constructors
-
-        grouped_table_impl(std::size_t n,
-                hasher const& hf,
-                key_equal const& eq,
-                node_allocator const& a)
-          : table(n, hf, eq, a)
-        {}
-
-        grouped_table_impl(grouped_table_impl const& x)
-          : table(x, node_allocator_traits::
-                select_on_container_copy_construction(x.node_alloc()))
-        {
-            this->init(x);
-        }
-
-        grouped_table_impl(grouped_table_impl const& x,
-                node_allocator const& a)
-          : table(x, a)
-        {
-            this->init(x);
-        }
-
-        grouped_table_impl(grouped_table_impl& x,
-                boost::unordered::detail::move_tag m)
-          : table(x, m)
-        {}
-
-        grouped_table_impl(grouped_table_impl& x,
-                node_allocator const& a,
-                boost::unordered::detail::move_tag m)
-          : table(x, a, m)
-        {
-            this->move_init(x);
-        }
-
-        // Node functions.
-
-        static inline node_pointer next_node(link_pointer n) {
-            return static_cast<node_pointer>(n->next_);
-        }
-
-        static inline node_pointer next_group(node_pointer n) {
-            return static_cast<node_pointer>(n->group_prev_->next_);
-        }
-
-        // Accessors
-
-        template <class Key, class Pred>
-        node_pointer find_node_impl(
-                std::size_t key_hash,
-                Key const& k,
-                Pred const& eq) const
-        {
-            std::size_t bucket_index = this->hash_to_bucket(key_hash);
-            node_pointer n = this->begin(bucket_index);
-
-            for (;;)
-            {
-                if (!n) return n;
-
-                std::size_t node_hash = n->hash_;
-                if (key_hash == node_hash)
-                {
-                    if (eq(k, this->get_key(n->value())))
-                        return n;
-                }
-                else
-                {
-                    if (this->hash_to_bucket(node_hash) != bucket_index)
-                        return node_pointer();
-                }
-
-                n = next_group(n);
-            }
-        }
-
-        std::size_t count(key_type const& k) const
-        {
-            node_pointer n = this->find_node(k);
-            if (!n) return 0;
-
-            std::size_t x = 0;
-            node_pointer it = n;
-            do {
-                it = it->group_prev_;
-                ++x;
-            } while(it != n);
-
-            return x;
-        }
-
-        std::pair<iterator, iterator>
-            equal_range(key_type const& k) const
-        {
-            node_pointer n = this->find_node(k);
-            return std::make_pair(iterator(n), iterator(n ? next_group(n) : n));
-        }
-
-        // Equality
-
-        bool equals(grouped_table_impl const& other) const
-        {
-            if(this->size_ != other.size_) return false;
-
-            for(node_pointer n1 = this->begin(); n1;)
-            {
-                node_pointer n2 = other.find_node(other.get_key(n1->value()));
-                if (!n2) return false;
-                node_pointer end1 = next_group(n1);
-                node_pointer end2 = next_group(n2);
-                if (!group_equals(n1, end1, n2, end2)) return false;
-                n1 = end1;
-            }
-
-            return true;
-        }
-
-        static bool group_equals(node_pointer n1, node_pointer end1,
-                node_pointer n2, node_pointer end2)
-        {
-            for(;;)
-            {
-                if (n1->value() != n2->value()) break;
-
-                n1 = next_node(n1);
-                n2 = next_node(n2);
-
-                if (n1 == end1) return n2 == end2;
-                if (n2 == end2) return false;
-            }
-
-            for(node_pointer n1a = n1, n2a = n2;;)
-            {
-                n1a = next_node(n1a);
-                n2a = next_node(n2a);
-
-                if (n1a == end1)
-                {
-                    if (n2a == end2) break;
-                    else return false;
-                }
-
-                if (n2a == end2) return false;
-            }
-
-            node_pointer start = n1;
-            for(;n1 != end1; n1 = next_node(n1))
-            {
-                value_type const& v = n1->value();
-                if (!find(start, n1, v)) {
-                    std::size_t matches = count_equal(n2, end2, v);
-                    if (!matches) return false;
-                    if (matches != 1 + count_equal(next_node(n1), end1, v)) return false;
-                }
-            }
-
-            return true;
-        }
-
-        static bool find(node_pointer n, node_pointer end, value_type const& v)
-        {
-            for(;n != end; n = next_node(n))
-                if (n->value() == v)
-                    return true;
-            return false;
-        }
-
-        static std::size_t count_equal(node_pointer n, node_pointer end,
-            value_type const& v)
-        {
-            std::size_t count = 0;
-            for(;n != end; n = next_node(n))
-                if (n->value() == v) ++count;
-            return count;
-        }
-
-        // Emplace/Insert
-
-        // Add node 'n' to the group containing 'pos'.
-        // If 'pos' is the first node in group, add to the end of the group,
-        // otherwise add before 'pos'.
-        static inline void add_to_node_group(
-                node_pointer n,
-                node_pointer pos)
-        {
-            n->next_ = pos->group_prev_->next_;
-            n->group_prev_ = pos->group_prev_;
-            pos->group_prev_->next_ = n;
-            pos->group_prev_ = n;
-        }
-
-        inline node_pointer add_node(
-                node_pointer n,
-                std::size_t key_hash,
-                node_pointer pos)
-        {
-            n->hash_ = key_hash;
-            if (pos) {
-                this->add_to_node_group(n, pos);
-                if (n->next_) {
-                    std::size_t next_bucket = this->hash_to_bucket(
-                        next_node(n)->hash_);
-                    if (next_bucket != this->hash_to_bucket(key_hash)) {
-                        this->get_bucket(next_bucket)->next_ = n;
-                    }
-                }
-            }
-            else {
-                bucket_pointer b = this->get_bucket(
-                    this->hash_to_bucket(key_hash));
-
-                if (!b->next_)
-                {
-                    link_pointer start_node = this->get_previous_start();
-
-                    if (start_node->next_) {
-                        this->get_bucket(this->hash_to_bucket(
-                            next_node(start_node)->hash_
-                        ))->next_ = n;
-                    }
-
-                    b->next_ = start_node;
-                    n->next_ = start_node->next_;
-                    start_node->next_ = n;
-                }
-                else
-                {
-                    n->next_ = b->next_->next_;
-                    b->next_->next_ = n;
-                }
-            }
-            ++this->size_;
-            return n;
-        }
-
-        inline node_pointer add_using_hint(
-                node_pointer n,
-                node_pointer hint)
-        {
-            n->hash_ = hint->hash_;
-            this->add_to_node_group(n, hint);
-            if (n->next_ != hint && n->next_) {
-                std::size_t next_bucket = this->hash_to_bucket(
-                    next_node(n)->hash_);
-                if (next_bucket != this->hash_to_bucket(n->hash_)) {
-                    this->get_bucket(next_bucket)->next_ = n;
-                }
-            }
-            ++this->size_;
-            return n;
-        }
-
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        iterator emplace(boost::unordered::detail::emplace_args1<
-                boost::unordered::detail::please_ignore_this_overload> const&)
-        {
-            BOOST_ASSERT(false);
-            return iterator();
-        }
-
-        iterator emplace_hint(c_iterator, boost::unordered::detail::emplace_args1<
-                boost::unordered::detail::please_ignore_this_overload> const&)
-        {
-            BOOST_ASSERT(false);
-            return iterator();
-        }
-#   else
-        iterator emplace(
-                boost::unordered::detail::please_ignore_this_overload const&)
-        {
-            BOOST_ASSERT(false);
-            return iterator();
-        }
-
-        iterator emplace_hint(c_iterator,
-                boost::unordered::detail::please_ignore_this_overload const&)
-        {
-            BOOST_ASSERT(false);
-            return iterator();
-        }
-#   endif
-#endif
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        iterator emplace(BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-            return iterator(emplace_impl(
-                boost::unordered::detail::func::construct_node_from_args(
-                    this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD)));
-        }
-
-        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-        iterator emplace_hint(c_iterator hint, BOOST_UNORDERED_EMPLACE_ARGS)
-        {
-            return iterator(emplace_hint_impl(hint,
-                boost::unordered::detail::func::construct_node_from_args(
-                    this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD)));
-        }
-
-        iterator emplace_impl(node_pointer n)
-        {
-            node_tmp a(n, this->node_alloc());
-            key_type const& k = this->get_key(a.node_->value());
+        node_tmp a(n, this->node_alloc());
+        key_type const& k = this->get_key(a.node_->value());
+        if (hint.node_ && this->key_eq()(k, this->get_key(*hint))) {
+            this->reserve_for_insert(this->size_ + 1);
+            return iterator(this->add_using_hint(a.release(), hint.node_));
+        } else {
             std::size_t key_hash = this->hash(k);
             node_pointer position = this->find_node(key_hash, k);
             this->reserve_for_insert(this->size_ + 1);
             return iterator(this->add_node(a.release(), key_hash, position));
         }
+    }
 
-        iterator emplace_hint_impl(c_iterator hint, node_pointer n)
-        {
-            node_tmp a(n, this->node_alloc());
-            key_type const& k = this->get_key(a.node_->value());
-            if (hint.node_ && this->key_eq()(k, this->get_key(*hint))) {
-                this->reserve_for_insert(this->size_ + 1);
-                return iterator(this->add_using_hint(a.release(), hint.node_));
-            }
-            else {
-                std::size_t key_hash = this->hash(k);
-                node_pointer position = this->find_node(key_hash, k);
-                this->reserve_for_insert(this->size_ + 1);
-                return iterator(this->add_node(a.release(), key_hash, position));
-            }
-        }
+    void emplace_impl_no_rehash(node_pointer n)
+    {
+        node_tmp a(n, this->node_alloc());
+        key_type const& k = this->get_key(a.node_->value());
+        std::size_t key_hash = this->hash(k);
+        node_pointer position = this->find_node(key_hash, k);
+        this->add_node(a.release(), key_hash, position);
+    }
 
-        void emplace_impl_no_rehash(node_pointer n)
-        {
-            node_tmp a(n, this->node_alloc());
-            key_type const& k = this->get_key(a.node_->value());
-            std::size_t key_hash = this->hash(k);
-            node_pointer position = this->find_node(key_hash, k);
-            this->add_node(a.release(), key_hash, position);
-        }
+    ////////////////////////////////////////////////////////////////////////
+    // Insert range methods
 
-        ////////////////////////////////////////////////////////////////////////
-        // Insert range methods
+    // if hash function throws, or inserting > 1 element, basic exception
+    // safety. Strong otherwise
+    template <class I>
+    void insert_range(I i, I j,
+        typename boost::unordered::detail::enable_if_forward<I, void*>::type =
+            0)
+    {
+        if (i == j)
+            return;
 
-        // if hash function throws, or inserting > 1 element, basic exception
-        // safety. Strong otherwise
-        template <class I>
-        void insert_range(I i, I j, typename
-            boost::unordered::detail::enable_if_forward<I, void*>::type = 0)
-        {
-            if(i == j) return;
+        std::size_t distance = static_cast<std::size_t>(std::distance(i, j));
+        if (distance == 1) {
+            emplace_impl(boost::unordered::detail::func::construct_node(
+                this->node_alloc(), *i));
+        } else {
+            // Only require basic exception safety here
+            this->reserve_for_insert(this->size_ + distance);
 
-            std::size_t distance = static_cast<std::size_t>(std::distance(i, j));
-            if(distance == 1) {
-                emplace_impl(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), *i));
-            }
-            else {
-                // Only require basic exception safety here
-                this->reserve_for_insert(this->size_ + distance);
-
-                for (; i != j; ++i) {
-                    emplace_impl_no_rehash(
-                        boost::unordered::detail::func::construct_node(
-                            this->node_alloc(), *i));
-                }
-            }
-        }
-
-        template <class I>
-        void insert_range(I i, I j, typename
-            boost::unordered::detail::disable_if_forward<I, void*>::type = 0)
-        {
             for (; i != j; ++i) {
-                emplace_impl(
+                emplace_impl_no_rehash(
                     boost::unordered::detail::func::construct_node(
                         this->node_alloc(), *i));
             }
         }
+    }
 
-        ////////////////////////////////////////////////////////////////////////
-        // Erase
-        //
-        // no throw
+    template <class I>
+    void insert_range(I i, I j,
+        typename boost::unordered::detail::disable_if_forward<I, void*>::type =
+            0)
+    {
+        for (; i != j; ++i) {
+            emplace_impl(boost::unordered::detail::func::construct_node(
+                this->node_alloc(), *i));
+        }
+    }
 
-        std::size_t erase_key(key_type const& k)
-        {
-            if(!this->size_) return 0;
+    ////////////////////////////////////////////////////////////////////////
+    // Erase
+    //
+    // no throw
 
-            std::size_t key_hash = this->hash(k);
-            std::size_t bucket_index = this->hash_to_bucket(key_hash);
-            link_pointer prev = this->get_previous_start(bucket_index);
-            if (!prev) return 0;
+    std::size_t erase_key(key_type const& k)
+    {
+        if (!this->size_)
+            return 0;
 
-            node_pointer first_node;
+        std::size_t key_hash = this->hash(k);
+        std::size_t bucket_index = this->hash_to_bucket(key_hash);
+        link_pointer prev = this->get_previous_start(bucket_index);
+        if (!prev)
+            return 0;
 
-            for (;;)
-            {
-                if (!prev->next_) return 0;
-                first_node = next_node(prev);
-                std::size_t node_hash = first_node->hash_;
-                if (this->hash_to_bucket(node_hash) != bucket_index)
-                    return 0;
-                if (node_hash == key_hash &&
-                    this->key_eq()(k, this->get_key(first_node->value())))
-                    break;
-                prev = first_node->group_prev_;
-            }
+        node_pointer first_node;
 
-            link_pointer end = first_node->group_prev_->next_;
-
-            std::size_t deleted_count = this->delete_nodes(prev, end);
-            this->fix_bucket(bucket_index, prev);
-            return deleted_count;
+        for (;;) {
+            if (!prev->next_)
+                return 0;
+            first_node = next_node(prev);
+            std::size_t node_hash = first_node->hash_;
+            if (this->hash_to_bucket(node_hash) != bucket_index)
+                return 0;
+            if (node_hash == key_hash &&
+                this->key_eq()(k, this->get_key(first_node->value())))
+                break;
+            prev = first_node->group_prev_;
         }
 
-        iterator erase(c_iterator r)
-        {
-            BOOST_ASSERT(r.node_);
-            node_pointer next = next_node(r.node_);
-            erase_nodes(r.node_, next);
-            return iterator(next);
-        }
+        link_pointer end = first_node->group_prev_->next_;
 
-        iterator erase_range(c_iterator r1, c_iterator r2)
-        {
-            if (r1 == r2) return iterator(r2.node_);
-            erase_nodes(r1.node_, r2.node_);
+        std::size_t deleted_count = this->delete_nodes(prev, end);
+        this->fix_bucket(bucket_index, prev);
+        return deleted_count;
+    }
+
+    iterator erase(c_iterator r)
+    {
+        BOOST_ASSERT(r.node_);
+        node_pointer next = next_node(r.node_);
+        erase_nodes(r.node_, next);
+        return iterator(next);
+    }
+
+    iterator erase_range(c_iterator r1, c_iterator r2)
+    {
+        if (r1 == r2)
             return iterator(r2.node_);
+        erase_nodes(r1.node_, r2.node_);
+        return iterator(r2.node_);
+    }
+
+    link_pointer erase_nodes(node_pointer i, node_pointer j)
+    {
+        std::size_t bucket_index = this->hash_to_bucket(i->hash_);
+
+        // Split the groups containing 'i' and 'j'.
+        // And get the pointer to the node before i while
+        // we're at it.
+        link_pointer prev = split_groups(i, j);
+
+        // If we don't have a 'prev' it means that i is at the
+        // beginning of a block, so search through the blocks in the
+        // same bucket.
+        if (!prev) {
+            prev = this->get_previous_start(bucket_index);
+            while (prev->next_ != i)
+                prev = next_node(prev)->group_prev_;
         }
 
-        link_pointer erase_nodes(node_pointer i, node_pointer j)
-        {
-            std::size_t bucket_index = this->hash_to_bucket(i->hash_);
+        // Delete the nodes.
+        do {
+            link_pointer group_end = next_group(next_node(prev));
+            this->delete_nodes(prev, group_end);
+            bucket_index = this->fix_bucket(bucket_index, prev);
+        } while (prev->next_ != j);
 
-            // Split the groups containing 'i' and 'j'.
-            // And get the pointer to the node before i while
-            // we're at it.
-            link_pointer prev = split_groups(i, j);
+        return prev;
+    }
 
-            // If we don't have a 'prev' it means that i is at the
-            // beginning of a block, so search through the blocks in the
-            // same bucket.
-            if (!prev) {
-                prev = this->get_previous_start(bucket_index);
-                while (prev->next_ != i)
-                    prev = next_node(prev)->group_prev_;
+    static link_pointer split_groups(node_pointer i, node_pointer j)
+    {
+        node_pointer prev = i->group_prev_;
+        if (prev->next_ != i)
+            prev = node_pointer();
+
+        if (j) {
+            node_pointer first = j;
+            while (first != i && first->group_prev_->next_ == first) {
+                first = first->group_prev_;
             }
 
-            // Delete the nodes.
-            do {
-                link_pointer group_end = next_group(next_node(prev));
-                this->delete_nodes(prev, group_end);
-                bucket_index = this->fix_bucket(bucket_index, prev);
-            } while(prev->next_ != j);
-
-            return prev;
-        }
-
-        static link_pointer split_groups(node_pointer i, node_pointer j)
-        {
-            node_pointer prev = i->group_prev_;
-            if (prev->next_ != i) prev = node_pointer();
-
-            if (j) {
-                node_pointer first = j;
-                while (first != i && first->group_prev_->next_ == first) {
-                    first = first->group_prev_;
-                }
-
-                boost::swap(first->group_prev_, j->group_prev_);
-                if (first == i) return prev;
-            }
-
-            if (prev) {
-                node_pointer first = prev;
-                while (first->group_prev_->next_ == first) {
-                    first = first->group_prev_;
-                }
-                boost::swap(first->group_prev_, i->group_prev_);
-            }
-
-            return prev;
-        }
-
-        ////////////////////////////////////////////////////////////////////////
-        // fill_buckets
-
-        void copy_buckets(table const& src) {
-            this->create_buckets(this->bucket_count_);
-
-            for (node_pointer n = src.begin(); n;) {
-                std::size_t key_hash = n->hash_;
-                node_pointer group_end(next_group(n));
-                node_pointer pos = this->add_node(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), n->value()), key_hash, node_pointer());
-                for (n = next_node(n); n != group_end; n = next_node(n))
-                {
-                    this->add_node(
-                        boost::unordered::detail::func::construct_node(
-                            this->node_alloc(), n->value()), key_hash, pos);
-                }
-            }
-        }
-
-        void move_buckets(table const& src) {
-            this->create_buckets(this->bucket_count_);
-
-            for (node_pointer n = src.begin(); n;) {
-                std::size_t key_hash = n->hash_;
-                node_pointer group_end(next_group(n));
-                node_pointer pos = this->add_node(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), boost::move(n->value())), key_hash, node_pointer());
-                for (n = next_node(n); n != group_end; n = next_node(n))
-                {
-                    this->add_node(
-                        boost::unordered::detail::func::construct_node(
-                            this->node_alloc(), boost::move(n->value())), key_hash, pos);
-                }
-            }
-        }
-
-        void assign_buckets(table const& src) {
-            node_holder<node_allocator> holder(*this);
-            for (node_pointer n = src.begin(); n;) {
-                std::size_t key_hash = n->hash_;
-                node_pointer group_end(next_group(n));
-                node_pointer pos = this->add_node(holder.copy_of(n->value()), key_hash, node_pointer());
-                for (n = next_node(n); n != group_end; n = next_node(n))
-                {
-                    this->add_node(holder.copy_of(n->value()), key_hash, pos);
-                }
-            }
-        }
-
-        void move_assign_buckets(table& src) {
-            node_holder<node_allocator> holder(*this);
-            for (node_pointer n = src.begin(); n;) {
-                std::size_t key_hash = n->hash_;
-                node_pointer group_end(next_group(n));
-                node_pointer pos = this->add_node(holder.move_copy_of(n->value()), key_hash, node_pointer());
-                for (n = next_node(n); n != group_end; n = next_node(n))
-                {
-                    this->add_node(holder.move_copy_of(n->value()), key_hash, pos);
-                }
-            }
-        }
-
-        // strong otherwise exception safety
-        void rehash_impl(std::size_t num_buckets)
-        {
-            BOOST_ASSERT(this->buckets_);
-
-            this->create_buckets(num_buckets);
-            link_pointer prev = this->get_previous_start();
-            while (prev->next_)
-                prev = place_in_bucket(*this, prev, next_node(prev)->group_prev_);
-        }
-
-        // Iterate through the nodes placing them in the correct buckets.
-        // pre: prev->next_ is not null.
-        static link_pointer place_in_bucket(table& dst,
-                link_pointer prev, node_pointer end)
-        {
-            bucket_pointer b = dst.get_bucket(dst.hash_to_bucket(end->hash_));
-
-            if (!b->next_) {
-                b->next_ = prev;
-                return end;
-            }
-            else {
-                link_pointer next = end->next_;
-                end->next_ = b->next_->next_;
-                b->next_->next_ = prev->next_;
-                prev->next_ = next;
+            boost::swap(first->group_prev_, j->group_prev_);
+            if (first == i)
                 return prev;
+        }
+
+        if (prev) {
+            node_pointer first = prev;
+            while (first->group_prev_->next_ == first) {
+                first = first->group_prev_;
+            }
+            boost::swap(first->group_prev_, i->group_prev_);
+        }
+
+        return prev;
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // fill_buckets
+
+    void copy_buckets(table const& src)
+    {
+        this->create_buckets(this->bucket_count_);
+
+        for (node_pointer n = src.begin(); n;) {
+            std::size_t key_hash = n->hash_;
+            node_pointer group_end(next_group(n));
+            node_pointer pos =
+                this->add_node(boost::unordered::detail::func::construct_node(
+                                   this->node_alloc(), n->value()),
+                    key_hash, node_pointer());
+            for (n = next_node(n); n != group_end; n = next_node(n)) {
+                this->add_node(boost::unordered::detail::func::construct_node(
+                                   this->node_alloc(), n->value()),
+                    key_hash, pos);
             }
         }
-    };
-}}}
+    }
+
+    void move_buckets(table const& src)
+    {
+        this->create_buckets(this->bucket_count_);
+
+        for (node_pointer n = src.begin(); n;) {
+            std::size_t key_hash = n->hash_;
+            node_pointer group_end(next_group(n));
+            node_pointer pos =
+                this->add_node(boost::unordered::detail::func::construct_node(
+                                   this->node_alloc(), boost::move(n->value())),
+                    key_hash, node_pointer());
+            for (n = next_node(n); n != group_end; n = next_node(n)) {
+                this->add_node(boost::unordered::detail::func::construct_node(
+                                   this->node_alloc(), boost::move(n->value())),
+                    key_hash, pos);
+            }
+        }
+    }
+
+    void assign_buckets(table const& src)
+    {
+        node_holder<node_allocator> holder(*this);
+        for (node_pointer n = src.begin(); n;) {
+            std::size_t key_hash = n->hash_;
+            node_pointer group_end(next_group(n));
+            node_pointer pos = this->add_node(
+                holder.copy_of(n->value()), key_hash, node_pointer());
+            for (n = next_node(n); n != group_end; n = next_node(n)) {
+                this->add_node(holder.copy_of(n->value()), key_hash, pos);
+            }
+        }
+    }
+
+    void move_assign_buckets(table& src)
+    {
+        node_holder<node_allocator> holder(*this);
+        for (node_pointer n = src.begin(); n;) {
+            std::size_t key_hash = n->hash_;
+            node_pointer group_end(next_group(n));
+            node_pointer pos = this->add_node(
+                holder.move_copy_of(n->value()), key_hash, node_pointer());
+            for (n = next_node(n); n != group_end; n = next_node(n)) {
+                this->add_node(holder.move_copy_of(n->value()), key_hash, pos);
+            }
+        }
+    }
+
+    // strong otherwise exception safety
+    void rehash_impl(std::size_t num_buckets)
+    {
+        BOOST_ASSERT(this->buckets_);
+
+        this->create_buckets(num_buckets);
+        link_pointer prev = this->get_previous_start();
+        while (prev->next_)
+            prev = place_in_bucket(*this, prev, next_node(prev)->group_prev_);
+    }
+
+    // Iterate through the nodes placing them in the correct buckets.
+    // pre: prev->next_ is not null.
+    static link_pointer place_in_bucket(
+        table& dst, link_pointer prev, node_pointer end)
+    {
+        bucket_pointer b = dst.get_bucket(dst.hash_to_bucket(end->hash_));
+
+        if (!b->next_) {
+            b->next_ = prev;
+            return end;
+        } else {
+            link_pointer next = end->next_;
+            end->next_ = b->next_->next_;
+            b->next_->next_ = prev->next_;
+            prev->next_ = next;
+            return prev;
+        }
+    }
+};
+}
+}
+}
 
 #endif
diff --git a/include/boost/unordered/detail/map.hpp b/include/boost/unordered/detail/map.hpp
index ef527a34..15b18e71 100644
--- a/include/boost/unordered/detail/map.hpp
+++ b/include/boost/unordered/detail/map.hpp
@@ -3,76 +3,73 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/unordered/unordered_map_fwd.hpp>
 #include <boost/unordered/detail/implementation.hpp>
+#include <boost/unordered/unordered_map_fwd.hpp>
 
-namespace boost { namespace unordered { namespace detail {
-    template <typename A, typename K, typename M, typename H, typename P>
-    struct map
-    {
-        typedef boost::unordered::detail::map<A, K, M, H, P> types;
+namespace boost {
+namespace unordered {
+namespace detail {
+template <typename A, typename K, typename M, typename H, typename P> struct map
+{
+    typedef boost::unordered::detail::map<A, K, M, H, P> types;
 
-        typedef A allocator;
-        typedef std::pair<K const, M> value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef K key_type;
+    typedef A allocator;
+    typedef std::pair<K const, M> value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef K key_type;
 
-        typedef boost::unordered::detail::allocator_traits<allocator>
-            traits;
-        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+    typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
+    typedef typename pick::node node;
+    typedef typename pick::bucket bucket;
+    typedef typename pick::link_pointer link_pointer;
 
-        typedef boost::unordered::detail::table_impl<types> table;
-        typedef boost::unordered::detail::map_extractor<key_type, value_type>
-            extractor;
+    typedef boost::unordered::detail::table_impl<types> table;
+    typedef boost::unordered::detail::map_extractor<key_type, value_type>
+        extractor;
 
-        typedef typename boost::unordered::detail::pick_policy<K>::type policy;
+    typedef typename boost::unordered::detail::pick_policy<K>::type policy;
 
-        typedef boost::unordered::iterator_detail::
-            iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            l_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
+    typedef boost::unordered::iterator_detail::iterator<node> iterator;
+    typedef boost::unordered::iterator_detail::c_iterator<node> c_iterator;
+    typedef boost::unordered::iterator_detail::l_iterator<node, policy>
+        l_iterator;
+    typedef boost::unordered::iterator_detail::cl_iterator<node, policy>
+        cl_iterator;
+};
 
-    template <typename A, typename K, typename M, typename H, typename P>
-    struct multimap
-    {
-        typedef boost::unordered::detail::multimap<A, K, M, H, P> types;
+template <typename A, typename K, typename M, typename H, typename P>
+struct multimap
+{
+    typedef boost::unordered::detail::multimap<A, K, M, H, P> types;
 
-        typedef A allocator;
-        typedef std::pair<K const, M> value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef K key_type;
+    typedef A allocator;
+    typedef std::pair<K const, M> value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef K key_type;
 
-        typedef boost::unordered::detail::allocator_traits<allocator> traits;
-        typedef boost::unordered::detail::pick_grouped_node<allocator,
-                value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+    typedef boost::unordered::detail::pick_grouped_node<allocator, value_type>
+        pick;
+    typedef typename pick::node node;
+    typedef typename pick::bucket bucket;
+    typedef typename pick::link_pointer link_pointer;
 
-        typedef boost::unordered::detail::grouped_table_impl<types> table;
-        typedef boost::unordered::detail::map_extractor<key_type, value_type>
-            extractor;
+    typedef boost::unordered::detail::grouped_table_impl<types> table;
+    typedef boost::unordered::detail::map_extractor<key_type, value_type>
+        extractor;
 
-        typedef typename boost::unordered::detail::pick_policy<K>::type policy;
+    typedef typename boost::unordered::detail::pick_policy<K>::type policy;
 
-        typedef boost::unordered::iterator_detail::
-            iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            l_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
-
-}}}
+    typedef boost::unordered::iterator_detail::iterator<node> iterator;
+    typedef boost::unordered::iterator_detail::c_iterator<node> c_iterator;
+    typedef boost::unordered::iterator_detail::l_iterator<node, policy>
+        l_iterator;
+    typedef boost::unordered::iterator_detail::cl_iterator<node, policy>
+        cl_iterator;
+};
+}
+}
+}
diff --git a/include/boost/unordered/detail/set.hpp b/include/boost/unordered/detail/set.hpp
index c254742f..024cc259 100644
--- a/include/boost/unordered/detail/set.hpp
+++ b/include/boost/unordered/detail/set.hpp
@@ -3,72 +3,70 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/unordered/unordered_set_fwd.hpp>
 #include <boost/unordered/detail/implementation.hpp>
+#include <boost/unordered/unordered_set_fwd.hpp>
 
-namespace boost { namespace unordered { namespace detail {
-    template <typename A, typename T, typename H, typename P>
-    struct set
-    {
-        typedef boost::unordered::detail::set<A, T, H, P> types;
+namespace boost {
+namespace unordered {
+namespace detail {
+template <typename A, typename T, typename H, typename P> struct set
+{
+    typedef boost::unordered::detail::set<A, T, H, P> types;
 
-        typedef A allocator;
-        typedef T value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef T key_type;
+    typedef A allocator;
+    typedef T value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef T key_type;
 
-        typedef boost::unordered::detail::allocator_traits<allocator> traits;
-        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+    typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
+    typedef typename pick::node node;
+    typedef typename pick::bucket bucket;
+    typedef typename pick::link_pointer link_pointer;
 
-        typedef boost::unordered::detail::table_impl<types> table;
-        typedef boost::unordered::detail::set_extractor<value_type> extractor;
+    typedef boost::unordered::detail::table_impl<types> table;
+    typedef boost::unordered::detail::set_extractor<value_type> extractor;
 
-        typedef typename boost::unordered::detail::pick_policy<T>::type policy;
+    typedef typename boost::unordered::detail::pick_policy<T>::type policy;
 
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
+    typedef boost::unordered::iterator_detail::c_iterator<node> iterator;
+    typedef boost::unordered::iterator_detail::c_iterator<node> c_iterator;
+    typedef boost::unordered::iterator_detail::cl_iterator<node, policy>
+        l_iterator;
+    typedef boost::unordered::iterator_detail::cl_iterator<node, policy>
+        cl_iterator;
+};
 
-    template <typename A, typename T, typename H, typename P>
-    struct multiset
-    {
-        typedef boost::unordered::detail::multiset<A, T, H, P> types;
+template <typename A, typename T, typename H, typename P> struct multiset
+{
+    typedef boost::unordered::detail::multiset<A, T, H, P> types;
 
-        typedef A allocator;
-        typedef T value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef T key_type;
+    typedef A allocator;
+    typedef T value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef T key_type;
 
-        typedef boost::unordered::detail::allocator_traits<allocator> traits;
-        typedef boost::unordered::detail::pick_grouped_node<allocator,
-            value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
+    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+    typedef boost::unordered::detail::pick_grouped_node<allocator, value_type>
+        pick;
+    typedef typename pick::node node;
+    typedef typename pick::bucket bucket;
+    typedef typename pick::link_pointer link_pointer;
 
-        typedef boost::unordered::detail::grouped_table_impl<types> table;
-        typedef boost::unordered::detail::set_extractor<value_type> extractor;
+    typedef boost::unordered::detail::grouped_table_impl<types> table;
+    typedef boost::unordered::detail::set_extractor<value_type> extractor;
 
-        typedef typename boost::unordered::detail::pick_policy<T>::type policy;
+    typedef typename boost::unordered::detail::pick_policy<T>::type policy;
 
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
-}}}
+    typedef boost::unordered::iterator_detail::c_iterator<node> iterator;
+    typedef boost::unordered::iterator_detail::c_iterator<node> c_iterator;
+    typedef boost::unordered::iterator_detail::cl_iterator<node, policy>
+        l_iterator;
+    typedef boost::unordered::iterator_detail::cl_iterator<node, policy>
+        cl_iterator;
+};
+}
+}
+}
diff --git a/include/boost/unordered/unordered_map.hpp b/include/boost/unordered/unordered_map.hpp
index 101b1c1c..9200f95d 100644
--- a/include/boost/unordered/unordered_map.hpp
+++ b/include/boost/unordered/unordered_map.hpp
@@ -14,10 +14,10 @@
 #pragma once
 #endif
 
-#include <boost/unordered/unordered_map_fwd.hpp>
-#include <boost/unordered/detail/map.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/move/move.hpp>
+#include <boost/unordered/detail/map.hpp>
+#include <boost/unordered/unordered_map_fwd.hpp>
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
@@ -26,1816 +26,1571 @@
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #if BOOST_MSVC >= 1400
-#pragma warning(disable:4396) //the inline specifier cannot be used when a
-                              // friend declaration refers to a specialization
-                              // of a function template
+#pragma warning(disable : 4396) // the inline specifier cannot be used when a
+// friend declaration refers to a specialization
+// of a function template
 #endif
 #endif
 
-namespace boost
+namespace boost {
+namespace unordered {
+template <class K, class T, class H, class P, class A> class unordered_map
 {
-namespace unordered
-{
-    template <class K, class T, class H, class P, class A>
-    class unordered_map
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    BOOST_COPYABLE_AND_MOVABLE(unordered_map)
+#endif
+
+  public:
+    typedef K key_type;
+    typedef std::pair<const K, T> value_type;
+    typedef T mapped_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef A allocator_type;
+
+  private:
+    typedef boost::unordered::detail::map<A, K, T, H, P> types;
+    typedef typename types::traits allocator_traits;
+    typedef typename types::table table;
+
+  public:
+    typedef typename allocator_traits::pointer pointer;
+    typedef typename allocator_traits::const_pointer const_pointer;
+
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    typedef typename table::cl_iterator const_local_iterator;
+    typedef typename table::l_iterator local_iterator;
+    typedef typename table::c_iterator const_iterator;
+    typedef typename table::iterator iterator;
+
+  private:
+    table table_;
+
+  public:
+    // constructors
+
+    unordered_map();
+
+    explicit unordered_map(size_type, const hasher& = hasher(),
+        const key_equal& = key_equal(),
+        const allocator_type& = allocator_type());
+
+    explicit unordered_map(size_type, const allocator_type&);
+
+    explicit unordered_map(size_type, const hasher&, const allocator_type&);
+
+    explicit unordered_map(allocator_type const&);
+
+    template <class InputIt> unordered_map(InputIt, InputIt);
+
+    template <class InputIt>
+    unordered_map(InputIt, InputIt, size_type, const hasher& = hasher(),
+        const key_equal& = key_equal());
+
+    template <class InputIt>
+    unordered_map(InputIt, InputIt, size_type, const hasher&, const key_equal&,
+        const allocator_type&);
+
+    template <class InputIt>
+    unordered_map(
+        InputIt, InputIt, size_type, const hasher&, const allocator_type&);
+
+    template <class InputIt>
+    unordered_map(InputIt, InputIt, size_type, const allocator_type&);
+
+    // copy/move constructors
+
+    unordered_map(unordered_map const&);
+
+    unordered_map(unordered_map const&, allocator_type const&);
+    unordered_map(BOOST_RV_REF(unordered_map), allocator_type const&);
+
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    unordered_map(BOOST_RV_REF(unordered_map) other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        BOOST_COPYABLE_AND_MOVABLE(unordered_map)
-#endif       
-
-    public:
-
-        typedef K key_type;
-        typedef std::pair<const K, T> value_type;
-        typedef T mapped_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef A allocator_type;
-
-    private:
-
-        typedef boost::unordered::detail::map<A, K, T, H, P> types;
-        typedef typename types::traits allocator_traits;
-        typedef typename types::table table;
-
-    public:
-
-        typedef typename allocator_traits::pointer pointer;
-        typedef typename allocator_traits::const_pointer const_pointer;
-
-        typedef value_type& reference;
-        typedef value_type const& const_reference;
-
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-
-        typedef typename table::cl_iterator const_local_iterator;
-        typedef typename table::l_iterator local_iterator;
-        typedef typename table::c_iterator const_iterator;
-        typedef typename table::iterator iterator;
-
-    private:
-
-        table table_;
-
-    public:
-
-        // constructors
-
-        unordered_map();
-
-        explicit unordered_map(
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal(),
-                const allocator_type& = allocator_type());
-
-        explicit unordered_map(
-                size_type,
-                const allocator_type&);
-
-        explicit unordered_map(
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        explicit unordered_map(allocator_type const&);
-
-        template <class InputIt>
-        unordered_map(InputIt, InputIt);
-
-        template <class InputIt>
-        unordered_map(
-                InputIt, InputIt,
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal());
-
-        template <class InputIt>
-        unordered_map(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const key_equal&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_map(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_map(
-                InputIt, InputIt,
-                size_type,
-                const allocator_type&);
-
-        // copy/move constructors
-
-        unordered_map(unordered_map const&);
-
-        unordered_map(unordered_map const&, allocator_type const&);
-        unordered_map(BOOST_RV_REF(unordered_map), allocator_type const&);
-
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_map(BOOST_RV_REF(unordered_map) other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    }
 #elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_map(unordered_map&& other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    unordered_map(unordered_map&& other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
+    {
+    }
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_map(
-                std::initializer_list<value_type>,
-                size_type = boost::unordered::detail::default_bucket_count,
-                const hasher& = hasher(),
-                const key_equal&l = key_equal(),
-                const allocator_type& = allocator_type());
-        unordered_map(
-                std::initializer_list<value_type>,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-        unordered_map(
-                std::initializer_list<value_type>,
-                size_type,
-                const allocator_type&);
+    unordered_map(std::initializer_list<value_type>,
+        size_type = boost::unordered::detail::default_bucket_count,
+        const hasher& = hasher(), const key_equal& l = key_equal(),
+        const allocator_type& = allocator_type());
+    unordered_map(std::initializer_list<value_type>, size_type, const hasher&,
+        const allocator_type&);
+    unordered_map(
+        std::initializer_list<value_type>, size_type, const allocator_type&);
 #endif
 
-        // Destructor
+    // Destructor
 
-        ~unordered_map() BOOST_NOEXCEPT;
+    ~unordered_map() BOOST_NOEXCEPT;
 
-        // Assign
+// Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_map& operator=(BOOST_COPY_ASSIGN_REF(unordered_map) x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_map& operator=(BOOST_COPY_ASSIGN_REF(unordered_map) x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
-        unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #else
-        unordered_map& operator=(unordered_map const& x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_map& operator=(unordered_map const& x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_map& operator=(unordered_map&& x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_map& operator=(unordered_map&& x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_map& operator=(std::initializer_list<value_type>);
+    unordered_map& operator=(std::initializer_list<value_type>);
 #endif
 
-        allocator_type get_allocator() const BOOST_NOEXCEPT
-        {
-            return table_.node_alloc();
-        }
+    allocator_type get_allocator() const BOOST_NOEXCEPT
+    {
+        return table_.node_alloc();
+    }
 
-        // size and capacity
+    // size and capacity
 
-        bool empty() const BOOST_NOEXCEPT
-        {
-            return table_.size_ == 0;
-        }
+    bool empty() const BOOST_NOEXCEPT { return table_.size_ == 0; }
 
-        size_type size() const BOOST_NOEXCEPT
-        {
-            return table_.size_;
-        }
+    size_type size() const BOOST_NOEXCEPT { return table_.size_; }
 
-        size_type max_size() const BOOST_NOEXCEPT;
+    size_type max_size() const BOOST_NOEXCEPT;
 
-        // iterators
+    // iterators
 
-        iterator begin() BOOST_NOEXCEPT
-        {
-            return iterator(table_.begin());
-        }
+    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-        const_iterator begin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator begin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        iterator end() BOOST_NOEXCEPT
-        {
-            return iterator();
-        }
+    iterator end() BOOST_NOEXCEPT { return iterator(); }
 
-        const_iterator end() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        const_iterator cbegin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator cbegin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        const_iterator cend() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        // emplace
+// emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class... Args>
-        std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace(boost::forward<Args>(args)...);
-        }
+    template <class... Args>
+    std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace(boost::forward<Args>(args)...);
+    }
 
-        template <class... Args>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace_hint(hint, boost::forward<Args>(args)...);
-        }
+    template <class... Args>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace_hint(hint, boost::forward<Args>(args)...);
+    }
 #else
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
 
-        // 0 argument emplace requires special treatment in case
-        // the container is instantiated with a value type that
-        // doesn't have a default constructor.
+    // 0 argument emplace requires special treatment in case
+    // the container is instantiated with a value type that
+    // doesn't have a default constructor.
 
-        std::pair<iterator, bool> emplace(
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type())
-        {
-            return this->emplace(boost::move(v));
-        }
+    std::pair<iterator, bool> emplace(
+        boost::unordered::detail::empty_emplace =
+            boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace(boost::move(v));
+    }
 
-        iterator emplace_hint(const_iterator hint,
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type()
-            )
-        {
-            return this->emplace_hint(hint, boost::move(v));
-        }
+    iterator emplace_hint(const_iterator hint,
+        boost::unordered::detail::empty_emplace =
+            boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace_hint(hint, boost::move(v));
+    }
 
 #endif
 
-        template <typename A0>
-        std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0>
+    std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+    }
 
-        template <typename A0>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0)));
+    }
 
-        template <typename A0, typename A1>
-        std::pair<iterator, bool> emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    std::pair<iterator, bool> emplace(
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    iterator emplace_hint(
+        const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        std::pair<iterator, bool> emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    std::pair<iterator, bool> emplace(
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1),
+            boost::forward<A2>(a2)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1),
+                      boost::forward<A2>(a2)));
+    }
 
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                    \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            std::pair<iterator, bool> emplace(                              \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace(                                      \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }                                                               \
-                                                                            \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            iterator emplace_hint(                                          \
-                    const_iterator hint,                                    \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace_hint(hint,                            \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }
+#define BOOST_UNORDERED_EMPLACE(z, n, _)                                       \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    std::pair<iterator, bool> emplace(                                         \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
+    {                                                                          \
+        return table_.emplace(boost::unordered::detail::create_emplace_args(   \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));           \
+    }                                                                          \
+                                                                               \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    iterator emplace_hint(const_iterator hint,                                 \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
+    {                                                                          \
+        return table_.emplace_hint(                                            \
+            hint, boost::unordered::detail::create_emplace_args(               \
+                      BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a))); \
+    }
 
-        BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
+    BOOST_PP_REPEAT_FROM_TO(
+        4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EMPLACE, _)
 
 #undef BOOST_UNORDERED_EMPLACE
 
 #endif
 
-        std::pair<iterator, bool> insert(value_type const& x)
-        {
-            return this->emplace(x);
-        }
+    std::pair<iterator, bool> insert(value_type const& x)
+    {
+        return this->emplace(x);
+    }
 
-        std::pair<iterator, bool> insert(BOOST_RV_REF(value_type) x)
-        {
-            return this->emplace(boost::move(x));
-        }
+    std::pair<iterator, bool> insert(BOOST_RV_REF(value_type) x)
+    {
+        return this->emplace(boost::move(x));
+    }
 
-        iterator insert(const_iterator hint, value_type const& x)
-        {
-            return this->emplace_hint(hint, x);
-        }
+    iterator insert(const_iterator hint, value_type const& x)
+    {
+        return this->emplace_hint(hint, x);
+    }
 
-        iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
-        {
-            return this->emplace_hint(hint, boost::move(x));
-        }
+    iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
+    {
+        return this->emplace_hint(hint, boost::move(x));
+    }
 
-        template <class InputIt> void insert(InputIt, InputIt);
+    template <class InputIt> void insert(InputIt, InputIt);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        void insert(std::initializer_list<value_type>);
+    void insert(std::initializer_list<value_type>);
 #endif
 
-        iterator erase(const_iterator);
-        size_type erase(const key_type&);
-        iterator erase(const_iterator, const_iterator);
-        void quick_erase(const_iterator it) { erase(it); }
-        void erase_return_void(const_iterator it) { erase(it); }
+    iterator erase(const_iterator);
+    size_type erase(const key_type&);
+    iterator erase(const_iterator, const_iterator);
+    void quick_erase(const_iterator it) { erase(it); }
+    void erase_return_void(const_iterator it) { erase(it); }
 
-        void clear();
-        void swap(unordered_map&);
+    void clear();
+    void swap(unordered_map&);
 
-        // observers
+    // observers
 
-        hasher hash_function() const;
-        key_equal key_eq() const;
+    hasher hash_function() const;
+    key_equal key_eq() const;
 
-        mapped_type& operator[](const key_type&);
-        mapped_type& at(const key_type&);
-        mapped_type const& at(const key_type&) const;
+    mapped_type& operator[](const key_type&);
+    mapped_type& at(const key_type&);
+    mapped_type const& at(const key_type&) const;
 
-        // lookup
+    // lookup
 
-        iterator find(const key_type&);
-        const_iterator find(const key_type&) const;
+    iterator find(const key_type&);
+    const_iterator find(const key_type&) const;
 
-        template <class CompatibleKey, class CompatibleHash,
-            class CompatiblePredicate>
-        iterator find(
-                CompatibleKey const&,
-                CompatibleHash const&,
-                CompatiblePredicate const&);
+    template <class CompatibleKey, class CompatibleHash,
+        class CompatiblePredicate>
+    iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&);
 
-        template <class CompatibleKey, class CompatibleHash,
-            class CompatiblePredicate>
-        const_iterator find(
-                CompatibleKey const&,
-                CompatibleHash const&,
-                CompatiblePredicate const&) const;
+    template <class CompatibleKey, class CompatibleHash,
+        class CompatiblePredicate>
+    const_iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&) const;
 
-        size_type count(const key_type&) const;
+    size_type count(const key_type&) const;
 
-        std::pair<iterator, iterator>
-        equal_range(const key_type&);
-        std::pair<const_iterator, const_iterator>
-        equal_range(const key_type&) const;
+    std::pair<iterator, iterator> equal_range(const key_type&);
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_type&) const;
 
-        // bucket interface
+    // bucket interface
 
-        size_type bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.bucket_count_;
-        }
+    size_type bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.bucket_count_;
+    }
 
-        size_type max_bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.max_bucket_count();
-        }
+    size_type max_bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.max_bucket_count();
+    }
 
-        size_type bucket_size(size_type) const;
+    size_type bucket_size(size_type) const;
 
-        size_type bucket(const key_type& k) const
-        {
-            return table_.hash_to_bucket(table_.hash(k));
-        }
+    size_type bucket(const key_type& k) const
+    {
+        return table_.hash_to_bucket(table_.hash(k));
+    }
 
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    local_iterator begin(size_type n)
+    {
+        return local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator begin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        local_iterator end(size_type)
-        {
-            return local_iterator();
-        }
+    local_iterator end(size_type) { return local_iterator(); }
 
-        const_local_iterator end(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator end(size_type) const { return const_local_iterator(); }
 
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator cbegin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator cend(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator cend(size_type) const
+    {
+        return const_local_iterator();
+    }
 
-        // hash policy
+    // hash policy
 
-        float max_load_factor() const BOOST_NOEXCEPT
-        {
-            return table_.mlf_;
-        }
+    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
 
-        float load_factor() const BOOST_NOEXCEPT;
-        void max_load_factor(float) BOOST_NOEXCEPT;
-        void rehash(size_type);
-        void reserve(size_type);
+    float load_factor() const BOOST_NOEXCEPT;
+    void max_load_factor(float) BOOST_NOEXCEPT;
+    void rehash(size_type);
+    void reserve(size_type);
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-        friend bool operator==<K,T,H,P,A>(
-                unordered_map const&, unordered_map const&);
-        friend bool operator!=<K,T,H,P,A>(
-                unordered_map const&, unordered_map const&);
+    friend bool operator==
+        <K, T, H, P, A>(unordered_map const&, unordered_map const&);
+    friend bool operator!=
+        <K, T, H, P, A>(unordered_map const&, unordered_map const&);
 #endif
-    }; // class template unordered_map
+}; // class template unordered_map
 
-    template <class K, class T, class H, class P, class A>
-    class unordered_multimap
+template <class K, class T, class H, class P, class A> class unordered_multimap
+{
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    BOOST_COPYABLE_AND_MOVABLE(unordered_multimap)
+#endif
+  public:
+    typedef K key_type;
+    typedef std::pair<const K, T> value_type;
+    typedef T mapped_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef A allocator_type;
+
+  private:
+    typedef boost::unordered::detail::multimap<A, K, T, H, P> types;
+    typedef typename types::traits allocator_traits;
+    typedef typename types::table table;
+
+  public:
+    typedef typename allocator_traits::pointer pointer;
+    typedef typename allocator_traits::const_pointer const_pointer;
+
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    typedef typename table::cl_iterator const_local_iterator;
+    typedef typename table::l_iterator local_iterator;
+    typedef typename table::c_iterator const_iterator;
+    typedef typename table::iterator iterator;
+
+  private:
+    table table_;
+
+  public:
+    // constructors
+
+    unordered_multimap();
+
+    explicit unordered_multimap(size_type, const hasher& = hasher(),
+        const key_equal& = key_equal(),
+        const allocator_type& = allocator_type());
+
+    explicit unordered_multimap(size_type, const allocator_type&);
+
+    explicit unordered_multimap(
+        size_type, const hasher&, const allocator_type&);
+
+    explicit unordered_multimap(allocator_type const&);
+
+    template <class InputIt> unordered_multimap(InputIt, InputIt);
+
+    template <class InputIt>
+    unordered_multimap(InputIt, InputIt, size_type, const hasher& = hasher(),
+        const key_equal& = key_equal());
+
+    template <class InputIt>
+    unordered_multimap(InputIt, InputIt, size_type, const hasher&,
+        const key_equal&, const allocator_type&);
+
+    template <class InputIt>
+    unordered_multimap(
+        InputIt, InputIt, size_type, const hasher&, const allocator_type&);
+
+    template <class InputIt>
+    unordered_multimap(InputIt, InputIt, size_type, const allocator_type&);
+
+    // copy/move constructors
+
+    unordered_multimap(unordered_multimap const&);
+
+    unordered_multimap(unordered_multimap const&, allocator_type const&);
+    unordered_multimap(BOOST_RV_REF(unordered_multimap), allocator_type const&);
+
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        BOOST_COPYABLE_AND_MOVABLE(unordered_multimap)
-#endif
-    public:
-
-        typedef K key_type;
-        typedef std::pair<const K, T> value_type;
-        typedef T mapped_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef A allocator_type;
-
-    private:
-
-        typedef boost::unordered::detail::multimap<A, K, T, H, P> types;
-        typedef typename types::traits allocator_traits;
-        typedef typename types::table table;
-
-    public:
-
-        typedef typename allocator_traits::pointer pointer;
-        typedef typename allocator_traits::const_pointer const_pointer;
-
-        typedef value_type& reference;
-        typedef value_type const& const_reference;
-
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-
-        typedef typename table::cl_iterator const_local_iterator;
-        typedef typename table::l_iterator local_iterator;
-        typedef typename table::c_iterator const_iterator;
-        typedef typename table::iterator iterator;
-
-    private:
-
-        table table_;
-        
-    public:
-
-        // constructors
-
-        unordered_multimap();
-
-        explicit unordered_multimap(
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal(),
-                const allocator_type& = allocator_type());
-
-        explicit unordered_multimap(
-                size_type,
-                const allocator_type&);
-
-        explicit unordered_multimap(
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        explicit unordered_multimap(allocator_type const&);
-
-        template <class InputIt>
-        unordered_multimap(InputIt, InputIt);
-
-        template <class InputIt>
-        unordered_multimap(
-                InputIt, InputIt,
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal());
-
-        template <class InputIt>
-        unordered_multimap(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const key_equal&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_multimap(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_multimap(
-                InputIt, InputIt,
-                size_type,
-                const allocator_type&);
-
-        // copy/move constructors
-
-        unordered_multimap(unordered_multimap const&);
-
-        unordered_multimap(unordered_multimap const&, allocator_type const&);
-        unordered_multimap(BOOST_RV_REF(unordered_multimap), allocator_type const&);
-
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    }
 #elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_multimap(unordered_multimap&& other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    unordered_multimap(unordered_multimap&& other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
+    {
+    }
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_multimap(
-                std::initializer_list<value_type>,
-                size_type = boost::unordered::detail::default_bucket_count,
-                const hasher& = hasher(),
-                const key_equal&l = key_equal(),
-                const allocator_type& = allocator_type());
-        unordered_multimap(
-                std::initializer_list<value_type>,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-        unordered_multimap(
-                std::initializer_list<value_type>,
-                size_type,
-                const allocator_type&);
+    unordered_multimap(std::initializer_list<value_type>,
+        size_type = boost::unordered::detail::default_bucket_count,
+        const hasher& = hasher(), const key_equal& l = key_equal(),
+        const allocator_type& = allocator_type());
+    unordered_multimap(std::initializer_list<value_type>, size_type,
+        const hasher&, const allocator_type&);
+    unordered_multimap(
+        std::initializer_list<value_type>, size_type, const allocator_type&);
 #endif
 
-        // Destructor
+    // Destructor
 
-        ~unordered_multimap() BOOST_NOEXCEPT;
+    ~unordered_multimap() BOOST_NOEXCEPT;
 
-        // Assign
+// Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_multimap& operator=(
-                BOOST_COPY_ASSIGN_REF(unordered_multimap) x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_multimap& operator=(BOOST_COPY_ASSIGN_REF(unordered_multimap) x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
-        unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #else
-        unordered_multimap& operator=(unordered_multimap const& x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_multimap& operator=(unordered_multimap const& x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_multimap& operator=(unordered_multimap&& x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_multimap& operator=(unordered_multimap&& x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_multimap& operator=(std::initializer_list<value_type>);
+    unordered_multimap& operator=(std::initializer_list<value_type>);
 #endif
 
-        allocator_type get_allocator() const BOOST_NOEXCEPT
-        {
-            return table_.node_alloc();
-        }
+    allocator_type get_allocator() const BOOST_NOEXCEPT
+    {
+        return table_.node_alloc();
+    }
 
-        // size and capacity
+    // size and capacity
 
-        bool empty() const BOOST_NOEXCEPT
-        {
-            return table_.size_ == 0;
-        }
+    bool empty() const BOOST_NOEXCEPT { return table_.size_ == 0; }
 
-        size_type size() const BOOST_NOEXCEPT
-        {
-            return table_.size_;
-        }
+    size_type size() const BOOST_NOEXCEPT { return table_.size_; }
 
-        size_type max_size() const BOOST_NOEXCEPT;
+    size_type max_size() const BOOST_NOEXCEPT;
 
-        // iterators
+    // iterators
 
-        iterator begin() BOOST_NOEXCEPT
-        {
-            return iterator(table_.begin());
-        }
+    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-        const_iterator begin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator begin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        iterator end() BOOST_NOEXCEPT
-        {
-            return iterator();
-        }
+    iterator end() BOOST_NOEXCEPT { return iterator(); }
 
-        const_iterator end() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        const_iterator cbegin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator cbegin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        const_iterator cend() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        // emplace
+// emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class... Args>
-        iterator emplace(BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace(boost::forward<Args>(args)...);
-        }
+    template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace(boost::forward<Args>(args)...);
+    }
 
-        template <class... Args>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace_hint(hint, boost::forward<Args>(args)...);
-        }
+    template <class... Args>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace_hint(hint, boost::forward<Args>(args)...);
+    }
 #else
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
 
-        // 0 argument emplace requires special treatment in case
-        // the container is instantiated with a value type that
-        // doesn't have a default constructor.
+    // 0 argument emplace requires special treatment in case
+    // the container is instantiated with a value type that
+    // doesn't have a default constructor.
 
-        iterator emplace(
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type())
-        {
-            return this->emplace(boost::move(v));
-        }
+    iterator emplace(boost::unordered::detail::empty_emplace =
+                         boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace(boost::move(v));
+    }
 
-        iterator emplace_hint(const_iterator hint,
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type()
-            )
-        {
-            return this->emplace_hint(hint, boost::move(v));
-        }
+    iterator emplace_hint(const_iterator hint,
+        boost::unordered::detail::empty_emplace =
+            boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace_hint(hint, boost::move(v));
+    }
 
 #endif
 
-        template <typename A0>
-        iterator emplace(BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+    }
 
-        template <typename A0>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0)));
+    }
 
-        template <typename A0, typename A1>
-        iterator emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    iterator emplace(BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    iterator emplace_hint(
+        const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        iterator emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    iterator emplace(
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1),
+            boost::forward<A2>(a2)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1),
+                      boost::forward<A2>(a2)));
+    }
 
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                    \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            iterator emplace(                                               \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace(                                      \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }                                                               \
-                                                                            \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            iterator emplace_hint(                                          \
-                    const_iterator hint,                                    \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace_hint(hint,                            \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }
+#define BOOST_UNORDERED_EMPLACE(z, n, _)                                       \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    iterator emplace(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))       \
+    {                                                                          \
+        return table_.emplace(boost::unordered::detail::create_emplace_args(   \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));           \
+    }                                                                          \
+                                                                               \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    iterator emplace_hint(const_iterator hint,                                 \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
+    {                                                                          \
+        return table_.emplace_hint(                                            \
+            hint, boost::unordered::detail::create_emplace_args(               \
+                      BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a))); \
+    }
 
-        BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
+    BOOST_PP_REPEAT_FROM_TO(
+        4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EMPLACE, _)
 
 #undef BOOST_UNORDERED_EMPLACE
 
 #endif
 
-        iterator insert(value_type const& x)
-        {
-            return this->emplace(x);
-        }
+    iterator insert(value_type const& x) { return this->emplace(x); }
 
-        iterator insert(BOOST_RV_REF(value_type) x)
-        {
-            return this->emplace(boost::move(x));
-        }
+    iterator insert(BOOST_RV_REF(value_type) x)
+    {
+        return this->emplace(boost::move(x));
+    }
 
-        iterator insert(const_iterator hint, value_type const& x)
-        {
-            return this->emplace_hint(hint, x);
-        }
+    iterator insert(const_iterator hint, value_type const& x)
+    {
+        return this->emplace_hint(hint, x);
+    }
 
-        iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
-        {
-            return this->emplace_hint(hint, boost::move(x));
-        }
+    iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
+    {
+        return this->emplace_hint(hint, boost::move(x));
+    }
 
-        template <class InputIt> void insert(InputIt, InputIt);
+    template <class InputIt> void insert(InputIt, InputIt);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        void insert(std::initializer_list<value_type>);
+    void insert(std::initializer_list<value_type>);
 #endif
 
-        iterator erase(const_iterator);
-        size_type erase(const key_type&);
-        iterator erase(const_iterator, const_iterator);
-        void quick_erase(const_iterator it) { erase(it); }
-        void erase_return_void(const_iterator it) { erase(it); }
+    iterator erase(const_iterator);
+    size_type erase(const key_type&);
+    iterator erase(const_iterator, const_iterator);
+    void quick_erase(const_iterator it) { erase(it); }
+    void erase_return_void(const_iterator it) { erase(it); }
 
-        void clear();
-        void swap(unordered_multimap&);
+    void clear();
+    void swap(unordered_multimap&);
 
-        // observers
+    // observers
 
-        hasher hash_function() const;
-        key_equal key_eq() const;
+    hasher hash_function() const;
+    key_equal key_eq() const;
 
-        // lookup
+    // lookup
 
-        iterator find(const key_type&);
-        const_iterator find(const key_type&) const;
+    iterator find(const key_type&);
+    const_iterator find(const key_type&) const;
 
-        template <class CompatibleKey, class CompatibleHash,
-            class CompatiblePredicate>
-        iterator find(
-                CompatibleKey const&,
-                CompatibleHash const&,
-                CompatiblePredicate const&);
+    template <class CompatibleKey, class CompatibleHash,
+        class CompatiblePredicate>
+    iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&);
 
-        template <class CompatibleKey, class CompatibleHash,
-            class CompatiblePredicate>
-        const_iterator find(
-                CompatibleKey const&,
-                CompatibleHash const&,
-                CompatiblePredicate const&) const;
+    template <class CompatibleKey, class CompatibleHash,
+        class CompatiblePredicate>
+    const_iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&) const;
 
-        size_type count(const key_type&) const;
+    size_type count(const key_type&) const;
 
-        std::pair<iterator, iterator>
-        equal_range(const key_type&);
-        std::pair<const_iterator, const_iterator>
-        equal_range(const key_type&) const;
+    std::pair<iterator, iterator> equal_range(const key_type&);
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_type&) const;
 
-        // bucket interface
+    // bucket interface
 
-        size_type bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.bucket_count_;
-        }
+    size_type bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.bucket_count_;
+    }
 
-        size_type max_bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.max_bucket_count();
-        }
+    size_type max_bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.max_bucket_count();
+    }
 
-        size_type bucket_size(size_type) const;
+    size_type bucket_size(size_type) const;
 
-        size_type bucket(const key_type& k) const
-        {
-            return table_.hash_to_bucket(table_.hash(k));
-        }
+    size_type bucket(const key_type& k) const
+    {
+        return table_.hash_to_bucket(table_.hash(k));
+    }
 
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    local_iterator begin(size_type n)
+    {
+        return local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator begin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        local_iterator end(size_type)
-        {
-            return local_iterator();
-        }
+    local_iterator end(size_type) { return local_iterator(); }
 
-        const_local_iterator end(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator end(size_type) const { return const_local_iterator(); }
 
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator cbegin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator cend(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator cend(size_type) const
+    {
+        return const_local_iterator();
+    }
 
-        // hash policy
+    // hash policy
 
-        float max_load_factor() const BOOST_NOEXCEPT
-        {
-            return table_.mlf_;
-        }
+    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
 
-        float load_factor() const BOOST_NOEXCEPT;
-        void max_load_factor(float) BOOST_NOEXCEPT;
-        void rehash(size_type);
-        void reserve(size_type);
+    float load_factor() const BOOST_NOEXCEPT;
+    void max_load_factor(float) BOOST_NOEXCEPT;
+    void rehash(size_type);
+    void reserve(size_type);
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-        friend bool operator==<K,T,H,P,A>(
-                unordered_multimap const&, unordered_multimap const&);
-        friend bool operator!=<K,T,H,P,A>(
-                unordered_multimap const&, unordered_multimap const&);
+    friend bool operator==
+        <K, T, H, P, A>(unordered_multimap const&, unordered_multimap const&);
+    friend bool operator!=
+        <K, T, H, P, A>(unordered_multimap const&, unordered_multimap const&);
 #endif
-    }; // class template unordered_multimap
+}; // class template unordered_multimap
 
 ////////////////////////////////////////////////////////////////////////////////
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map()
-      : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map()
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), allocator_type())
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            size_type n, const hasher &hf, const key_equal &eql,
-            const allocator_type &a)
-      : table_(n, hf, eql, a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(size_type n, const hasher& hf,
+    const key_equal& eql, const allocator_type& a)
+    : table_(n, hf, eql, a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            size_type n, const allocator_type &a)
-      : table_(n, hasher(), key_equal(), a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    size_type n, const allocator_type& a)
+    : table_(n, hasher(), key_equal(), a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            size_type n, const hasher &hf, const allocator_type &a)
-      : table_(n, hf, key_equal(), a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(n, hf, key_equal(), a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(allocator_type const& a)
-      : table_(boost::unordered::detail::default_bucket_count,
-            hasher(), key_equal(), a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(allocator_type const& a)
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            unordered_map const& other, allocator_type const& a)
-      : table_(other.table_, a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    unordered_map const& other, allocator_type const& a)
+    : table_(other.table_, a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_map<K,T,H,P,A>::unordered_map(InputIt f, InputIt l)
-      : table_(boost::unordered::detail::initial_size(f, l),
-        hasher(), key_equal(), allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_map<K, T, H, P, A>::unordered_map(InputIt f, InputIt l)
+    : table_(boost::unordered::detail::initial_size(f, l), hasher(),
+          key_equal(), allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, eql, allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_map<K, T, H, P, A>::unordered_map(
+    InputIt f, InputIt l, size_type n, const hasher& hf, const key_equal& eql)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql,
+          allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            InputIt f, InputIt l,
-            size_type n,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_map<K, T, H, P, A>::unordered_map(InputIt f, InputIt l, size_type n,
+    const hasher& hf, const key_equal& eql, const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::~unordered_map() BOOST_NOEXCEPT {}
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_map<K, T, H, P, A>::unordered_map(InputIt f, InputIt l, size_type n,
+    const hasher& hf, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(f, l, n), hf, key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            unordered_map const& other)
-      : table_(other.table_)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_map<K, T, H, P, A>::unordered_map(
+    InputIt f, InputIt l, size_type n, const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hasher(),
+          key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            BOOST_RV_REF(unordered_map) other, allocator_type const& a)
-      : table_(other.table_, a, boost::unordered::detail::move_tag())
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::~unordered_map() BOOST_NOEXCEPT
+{
+}
+
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(unordered_map const& other)
+    : table_(other.table_)
+{
+}
+
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    BOOST_RV_REF(unordered_map) other, allocator_type const& a)
+    : table_(other.table_, a, boost::unordered::detail::move_tag())
+{
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const key_equal &eql, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, eql, a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    std::initializer_list<value_type> list, size_type n, const hasher& hf,
+    const key_equal& eql, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, eql, a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    std::initializer_list<value_type> list, size_type n, const hasher& hf,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>::unordered_map(
-            std::initializer_list<value_type> list, size_type n,
-            const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>::unordered_map(
+    std::initializer_list<value_type> list, size_type n,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hasher(), key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_map<K,T,H,P,A>& unordered_map<K,T,H,P,A>::operator=(
-            std::initializer_list<value_type> list)
-    {
-        table_.clear();
-        table_.insert_range(list.begin(), list.end());
-        return *this;
-    }
+template <class K, class T, class H, class P, class A>
+unordered_map<K, T, H, P, A>& unordered_map<K, T, H, P, A>::operator=(
+    std::initializer_list<value_type> list)
+{
+    table_.clear();
+    table_.insert_range(list.begin(), list.end());
+    return *this;
+}
 
 #endif
 
-    // size and capacity
+// size and capacity
 
-    template <class K, class T, class H, class P, class A>
-    std::size_t unordered_map<K,T,H,P,A>::max_size() const BOOST_NOEXCEPT
-    {
-        return table_.max_size();
-    }
+template <class K, class T, class H, class P, class A>
+std::size_t unordered_map<K, T, H, P, A>::max_size() const BOOST_NOEXCEPT
+{
+    return table_.max_size();
+}
 
-    // modifiers
+// modifiers
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    void unordered_map<K,T,H,P,A>::insert(InputIt first, InputIt last)
-    {
-        table_.insert_range(first, last);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+void unordered_map<K, T, H, P, A>::insert(InputIt first, InputIt last)
+{
+    table_.insert_range(first, last);
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    template <class K, class T, class H, class P, class A>
-    void unordered_map<K,T,H,P,A>::insert(
-            std::initializer_list<value_type> list)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_map<K, T, H, P, A>::insert(
+    std::initializer_list<value_type> list)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 #endif
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::iterator
-        unordered_map<K,T,H,P,A>::erase(const_iterator position)
-    {
-        return table_.erase(position);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::iterator
+unordered_map<K, T, H, P, A>::erase(const_iterator position)
+{
+    return table_.erase(position);
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::size_type
-        unordered_map<K,T,H,P,A>::erase(const key_type& k)
-    {
-        return table_.erase_key(k);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::size_type
+unordered_map<K, T, H, P, A>::erase(const key_type& k)
+{
+    return table_.erase_key(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::iterator
-        unordered_map<K,T,H,P,A>::erase(
-            const_iterator first, const_iterator last)
-    {
-        return table_.erase_range(first, last);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::iterator
+unordered_map<K, T, H, P, A>::erase(const_iterator first, const_iterator last)
+{
+    return table_.erase_range(first, last);
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_map<K,T,H,P,A>::clear()
-    {
-        table_.clear();
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_map<K, T, H, P, A>::clear()
+{
+    table_.clear();
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_map<K,T,H,P,A>::swap(unordered_map& other)
-    {
-        table_.swap(other.table_);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_map<K, T, H, P, A>::swap(unordered_map& other)
+{
+    table_.swap(other.table_);
+}
 
-    // observers
+// observers
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::hasher
-        unordered_map<K,T,H,P,A>::hash_function() const
-    {
-        return table_.hash_function();
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::hasher
+unordered_map<K, T, H, P, A>::hash_function() const
+{
+    return table_.hash_function();
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::key_equal
-        unordered_map<K,T,H,P,A>::key_eq() const
-    {
-        return table_.key_eq();
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::key_equal
+unordered_map<K, T, H, P, A>::key_eq() const
+{
+    return table_.key_eq();
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::mapped_type&
-        unordered_map<K,T,H,P,A>::operator[](const key_type &k)
-    {
-        return table_[k].second;
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::mapped_type&
+    unordered_map<K, T, H, P, A>::operator[](const key_type& k)
+{
+    return table_[k].second;
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::mapped_type&
-        unordered_map<K,T,H,P,A>::at(const key_type& k)
-    {
-        return table_.at(k).second;
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::mapped_type&
+unordered_map<K, T, H, P, A>::at(const key_type& k)
+{
+    return table_.at(k).second;
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::mapped_type const&
-        unordered_map<K,T,H,P,A>::at(const key_type& k) const
-    {
-        return table_.at(k).second;
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::mapped_type const&
+unordered_map<K, T, H, P, A>::at(const key_type& k) const
+{
+    return table_.at(k).second;
+}
 
-    // lookup
+// lookup
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::iterator
-        unordered_map<K,T,H,P,A>::find(const key_type& k)
-    {
-        return iterator(table_.find_node(k));
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::iterator
+unordered_map<K, T, H, P, A>::find(const key_type& k)
+{
+    return iterator(table_.find_node(k));
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::const_iterator
-        unordered_map<K,T,H,P,A>::find(const key_type& k) const
-    {
-        return const_iterator(table_.find_node(k));
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::const_iterator
+unordered_map<K, T, H, P, A>::find(const key_type& k) const
+{
+    return const_iterator(table_.find_node(k));
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    typename unordered_map<K,T,H,P,A>::iterator
-        unordered_map<K,T,H,P,A>::find(
-            CompatibleKey const& k,
-            CompatibleHash const& hash,
-            CompatiblePredicate const& eq)
-    {
-        return iterator(table_.generic_find_node(k, hash, eq));
-    }
+template <class K, class T, class H, class P, class A>
+template <class CompatibleKey, class CompatibleHash, class CompatiblePredicate>
+typename unordered_map<K, T, H, P, A>::iterator
+unordered_map<K, T, H, P, A>::find(CompatibleKey const& k,
+    CompatibleHash const& hash, CompatiblePredicate const& eq)
+{
+    return iterator(table_.generic_find_node(k, hash, eq));
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    typename unordered_map<K,T,H,P,A>::const_iterator
-        unordered_map<K,T,H,P,A>::find(
-            CompatibleKey const& k,
-            CompatibleHash const& hash,
-            CompatiblePredicate const& eq) const
-    {
-        return const_iterator(table_.generic_find_node(k, hash, eq));
-    }
+template <class K, class T, class H, class P, class A>
+template <class CompatibleKey, class CompatibleHash, class CompatiblePredicate>
+typename unordered_map<K, T, H, P, A>::const_iterator
+unordered_map<K, T, H, P, A>::find(CompatibleKey const& k,
+    CompatibleHash const& hash, CompatiblePredicate const& eq) const
+{
+    return const_iterator(table_.generic_find_node(k, hash, eq));
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::size_type
-        unordered_map<K,T,H,P,A>::count(const key_type& k) const
-    {
-        return table_.count(k);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::size_type
+unordered_map<K, T, H, P, A>::count(const key_type& k) const
+{
+    return table_.count(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    std::pair<
-            typename unordered_map<K,T,H,P,A>::iterator,
-            typename unordered_map<K,T,H,P,A>::iterator>
-        unordered_map<K,T,H,P,A>::equal_range(const key_type& k)
-    {
-        return table_.equal_range(k);
-    }
+template <class K, class T, class H, class P, class A>
+std::pair<typename unordered_map<K, T, H, P, A>::iterator,
+    typename unordered_map<K, T, H, P, A>::iterator>
+unordered_map<K, T, H, P, A>::equal_range(const key_type& k)
+{
+    return table_.equal_range(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    std::pair<
-            typename unordered_map<K,T,H,P,A>::const_iterator,
-            typename unordered_map<K,T,H,P,A>::const_iterator>
-        unordered_map<K,T,H,P,A>::equal_range(const key_type& k) const
-    {
-        return table_.equal_range(k);
-    }
+template <class K, class T, class H, class P, class A>
+std::pair<typename unordered_map<K, T, H, P, A>::const_iterator,
+    typename unordered_map<K, T, H, P, A>::const_iterator>
+unordered_map<K, T, H, P, A>::equal_range(const key_type& k) const
+{
+    return table_.equal_range(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_map<K,T,H,P,A>::size_type
-        unordered_map<K,T,H,P,A>::bucket_size(size_type n) const
-    {
-        return table_.bucket_size(n);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_map<K, T, H, P, A>::size_type
+unordered_map<K, T, H, P, A>::bucket_size(size_type n) const
+{
+    return table_.bucket_size(n);
+}
 
-    // hash policy
+// hash policy
 
-    template <class K, class T, class H, class P, class A>
-    float unordered_map<K,T,H,P,A>::load_factor() const BOOST_NOEXCEPT
-    {
-        return table_.load_factor();
-    }
+template <class K, class T, class H, class P, class A>
+float unordered_map<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+{
+    return table_.load_factor();
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_map<K,T,H,P,A>::max_load_factor(float m) BOOST_NOEXCEPT
-    {
-        table_.max_load_factor(m);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_map<K, T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
+{
+    table_.max_load_factor(m);
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_map<K,T,H,P,A>::rehash(size_type n)
-    {
-        table_.rehash(n);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_map<K, T, H, P, A>::rehash(size_type n)
+{
+    table_.rehash(n);
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_map<K,T,H,P,A>::reserve(size_type n)
-    {
-        table_.reserve(n);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_map<K, T, H, P, A>::reserve(size_type n)
+{
+    table_.reserve(n);
+}
 
-    template <class K, class T, class H, class P, class A>
-    inline bool operator==(
-            unordered_map<K,T,H,P,A> const& m1,
-            unordered_map<K,T,H,P,A> const& m2)
-    {
+template <class K, class T, class H, class P, class A>
+inline bool operator==(unordered_map<K, T, H, P, A> const& m1,
+    unordered_map<K, T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_map<K,T,H,P,A> x; };
-#endif
-        return m1.table_.equals(m2.table_);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator!=(
-            unordered_map<K,T,H,P,A> const& m1,
-            unordered_map<K,T,H,P,A> const& m2)
+    struct dummy
     {
-#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_map<K,T,H,P,A> x; };
+        unordered_map<K, T, H, P, A> x;
+    };
 #endif
-        return !m1.table_.equals(m2.table_);
-    }
+    return m1.table_.equals(m2.table_);
+}
 
-    template <class K, class T, class H, class P, class A>
-    inline void swap(
-            unordered_map<K,T,H,P,A> &m1,
-            unordered_map<K,T,H,P,A> &m2)
-    {
+template <class K, class T, class H, class P, class A>
+inline bool operator!=(unordered_map<K, T, H, P, A> const& m1,
+    unordered_map<K, T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_map<K,T,H,P,A> x; };
+    struct dummy
+    {
+        unordered_map<K, T, H, P, A> x;
+    };
 #endif
-        m1.swap(m2);
-    }
+    return !m1.table_.equals(m2.table_);
+}
+
+template <class K, class T, class H, class P, class A>
+inline void swap(
+    unordered_map<K, T, H, P, A>& m1, unordered_map<K, T, H, P, A>& m2)
+{
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+    struct dummy
+    {
+        unordered_map<K, T, H, P, A> x;
+    };
+#endif
+    m1.swap(m2);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap()
-      : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap()
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), allocator_type())
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            size_type n, const hasher &hf, const key_equal &eql,
-            const allocator_type &a)
-      : table_(n, hf, eql, a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(size_type n,
+    const hasher& hf, const key_equal& eql, const allocator_type& a)
+    : table_(n, hf, eql, a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            size_type n, const allocator_type &a)
-      : table_(n, hasher(), key_equal(), a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    size_type n, const allocator_type& a)
+    : table_(n, hasher(), key_equal(), a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            size_type n, const hasher &hf, const allocator_type &a)
-      : table_(n, hf, key_equal(), a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(n, hf, key_equal(), a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(allocator_type const& a)
-      : table_(boost::unordered::detail::default_bucket_count,
-            hasher(), key_equal(), a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(allocator_type const& a)
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            unordered_multimap const& other, allocator_type const& a)
-      : table_(other.table_, a)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    unordered_multimap const& other, allocator_type const& a)
+    : table_(other.table_, a)
+{
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(InputIt f, InputIt l)
-      : table_(boost::unordered::detail::initial_size(f, l),
-        hasher(), key_equal(), allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(InputIt f, InputIt l)
+    : table_(boost::unordered::detail::initial_size(f, l), hasher(),
+          key_equal(), allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, eql, allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    InputIt f, InputIt l, size_type n, const hasher& hf, const key_equal& eql)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql,
+          allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            InputIt f, InputIt l,
-            size_type n,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(InputIt f, InputIt l,
+    size_type n, const hasher& hf, const key_equal& eql,
+    const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::~unordered_multimap() BOOST_NOEXCEPT {}
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(InputIt f, InputIt l,
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(f, l, n), hf, key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            unordered_multimap const& other)
-      : table_(other.table_)
-    {
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    InputIt f, InputIt l, size_type n, const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hasher(),
+          key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            BOOST_RV_REF(unordered_multimap) other, allocator_type const& a)
-      : table_(other.table_, a, boost::unordered::detail::move_tag())
-    {
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::~unordered_multimap() BOOST_NOEXCEPT
+{
+}
+
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    unordered_multimap const& other)
+    : table_(other.table_)
+{
+}
+
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    BOOST_RV_REF(unordered_multimap) other, allocator_type const& a)
+    : table_(other.table_, a, boost::unordered::detail::move_tag())
+{
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const key_equal &eql, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, eql, a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    std::initializer_list<value_type> list, size_type n, const hasher& hf,
+    const key_equal& eql, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, eql, a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    std::initializer_list<value_type> list, size_type n, const hasher& hf,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>::unordered_multimap(
-            std::initializer_list<value_type> list, size_type n,
-            const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>::unordered_multimap(
+    std::initializer_list<value_type> list, size_type n,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hasher(), key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class K, class T, class H, class P, class A>
-    unordered_multimap<K,T,H,P,A>& unordered_multimap<K,T,H,P,A>::operator=(
-            std::initializer_list<value_type> list)
-    {
-        table_.clear();
-        table_.insert_range(list.begin(), list.end());
-        return *this;
-    }
+template <class K, class T, class H, class P, class A>
+unordered_multimap<K, T, H, P, A>& unordered_multimap<K, T, H, P, A>::operator=(
+    std::initializer_list<value_type> list)
+{
+    table_.clear();
+    table_.insert_range(list.begin(), list.end());
+    return *this;
+}
 
 #endif
 
-    // size and capacity
+// size and capacity
 
-    template <class K, class T, class H, class P, class A>
-    std::size_t unordered_multimap<K,T,H,P,A>::max_size() const BOOST_NOEXCEPT
-    {
-        return table_.max_size();
-    }
+template <class K, class T, class H, class P, class A>
+std::size_t unordered_multimap<K, T, H, P, A>::max_size() const BOOST_NOEXCEPT
+{
+    return table_.max_size();
+}
 
-    // modifiers
+// modifiers
 
-    template <class K, class T, class H, class P, class A>
-    template <class InputIt>
-    void unordered_multimap<K,T,H,P,A>::insert(InputIt first, InputIt last)
-    {
-        table_.insert_range(first, last);
-    }
+template <class K, class T, class H, class P, class A>
+template <class InputIt>
+void unordered_multimap<K, T, H, P, A>::insert(InputIt first, InputIt last)
+{
+    table_.insert_range(first, last);
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    template <class K, class T, class H, class P, class A>
-    void unordered_multimap<K,T,H,P,A>::insert(
-            std::initializer_list<value_type> list)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_multimap<K, T, H, P, A>::insert(
+    std::initializer_list<value_type> list)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 #endif
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::iterator
-        unordered_multimap<K,T,H,P,A>::erase(const_iterator position)
-    {
-        return table_.erase(position);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::iterator
+unordered_multimap<K, T, H, P, A>::erase(const_iterator position)
+{
+    return table_.erase(position);
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::size_type
-        unordered_multimap<K,T,H,P,A>::erase(const key_type& k)
-    {
-        return table_.erase_key(k);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::size_type
+unordered_multimap<K, T, H, P, A>::erase(const key_type& k)
+{
+    return table_.erase_key(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::iterator
-        unordered_multimap<K,T,H,P,A>::erase(
-            const_iterator first, const_iterator last)
-    {
-        return table_.erase_range(first, last);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::iterator
+unordered_multimap<K, T, H, P, A>::erase(
+    const_iterator first, const_iterator last)
+{
+    return table_.erase_range(first, last);
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_multimap<K,T,H,P,A>::clear()
-    {
-        table_.clear();
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_multimap<K, T, H, P, A>::clear()
+{
+    table_.clear();
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_multimap<K,T,H,P,A>::swap(unordered_multimap& other)
-    {
-        table_.swap(other.table_);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other)
+{
+    table_.swap(other.table_);
+}
 
-    // observers
+// observers
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::hasher
-        unordered_multimap<K,T,H,P,A>::hash_function() const
-    {
-        return table_.hash_function();
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::hasher
+unordered_multimap<K, T, H, P, A>::hash_function() const
+{
+    return table_.hash_function();
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::key_equal
-        unordered_multimap<K,T,H,P,A>::key_eq() const
-    {
-        return table_.key_eq();
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::key_equal
+unordered_multimap<K, T, H, P, A>::key_eq() const
+{
+    return table_.key_eq();
+}
 
-    // lookup
+// lookup
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::iterator
-        unordered_multimap<K,T,H,P,A>::find(const key_type& k)
-    {
-        return iterator(table_.find_node(k));
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::iterator
+unordered_multimap<K, T, H, P, A>::find(const key_type& k)
+{
+    return iterator(table_.find_node(k));
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::const_iterator
-        unordered_multimap<K,T,H,P,A>::find(const key_type& k) const
-    {
-        return const_iterator(table_.find_node(k));
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::const_iterator
+unordered_multimap<K, T, H, P, A>::find(const key_type& k) const
+{
+    return const_iterator(table_.find_node(k));
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    typename unordered_multimap<K,T,H,P,A>::iterator
-        unordered_multimap<K,T,H,P,A>::find(
-            CompatibleKey const& k,
-            CompatibleHash const& hash,
-            CompatiblePredicate const& eq)
-    {
-        return iterator(table_.generic_find_node(k, hash, eq));
-    }
+template <class K, class T, class H, class P, class A>
+template <class CompatibleKey, class CompatibleHash, class CompatiblePredicate>
+typename unordered_multimap<K, T, H, P, A>::iterator
+unordered_multimap<K, T, H, P, A>::find(CompatibleKey const& k,
+    CompatibleHash const& hash, CompatiblePredicate const& eq)
+{
+    return iterator(table_.generic_find_node(k, hash, eq));
+}
 
-    template <class K, class T, class H, class P, class A>
-    template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    typename unordered_multimap<K,T,H,P,A>::const_iterator
-        unordered_multimap<K,T,H,P,A>::find(
-            CompatibleKey const& k,
-            CompatibleHash const& hash,
-            CompatiblePredicate const& eq) const
-    {
-        return const_iterator(table_.generic_find_node(k, hash, eq));
-    }
+template <class K, class T, class H, class P, class A>
+template <class CompatibleKey, class CompatibleHash, class CompatiblePredicate>
+typename unordered_multimap<K, T, H, P, A>::const_iterator
+unordered_multimap<K, T, H, P, A>::find(CompatibleKey const& k,
+    CompatibleHash const& hash, CompatiblePredicate const& eq) const
+{
+    return const_iterator(table_.generic_find_node(k, hash, eq));
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::size_type
-        unordered_multimap<K,T,H,P,A>::count(const key_type& k) const
-    {
-        return table_.count(k);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::size_type
+unordered_multimap<K, T, H, P, A>::count(const key_type& k) const
+{
+    return table_.count(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    std::pair<
-            typename unordered_multimap<K,T,H,P,A>::iterator,
-            typename unordered_multimap<K,T,H,P,A>::iterator>
-        unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k)
-    {
-        return table_.equal_range(k);
-    }
+template <class K, class T, class H, class P, class A>
+std::pair<typename unordered_multimap<K, T, H, P, A>::iterator,
+    typename unordered_multimap<K, T, H, P, A>::iterator>
+unordered_multimap<K, T, H, P, A>::equal_range(const key_type& k)
+{
+    return table_.equal_range(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    std::pair<
-            typename unordered_multimap<K,T,H,P,A>::const_iterator,
-            typename unordered_multimap<K,T,H,P,A>::const_iterator>
-        unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k) const
-    {
-        return table_.equal_range(k);
-    }
+template <class K, class T, class H, class P, class A>
+std::pair<typename unordered_multimap<K, T, H, P, A>::const_iterator,
+    typename unordered_multimap<K, T, H, P, A>::const_iterator>
+unordered_multimap<K, T, H, P, A>::equal_range(const key_type& k) const
+{
+    return table_.equal_range(k);
+}
 
-    template <class K, class T, class H, class P, class A>
-    typename unordered_multimap<K,T,H,P,A>::size_type
-        unordered_multimap<K,T,H,P,A>::bucket_size(size_type n) const
-    {
-        return table_.bucket_size(n);
-    }
+template <class K, class T, class H, class P, class A>
+typename unordered_multimap<K, T, H, P, A>::size_type
+unordered_multimap<K, T, H, P, A>::bucket_size(size_type n) const
+{
+    return table_.bucket_size(n);
+}
 
-    // hash policy
+// hash policy
 
-    template <class K, class T, class H, class P, class A>
-    float unordered_multimap<K,T,H,P,A>::load_factor() const BOOST_NOEXCEPT
-    {
-        return table_.load_factor();
-    }
+template <class K, class T, class H, class P, class A>
+float unordered_multimap<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+{
+    return table_.load_factor();
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_multimap<K,T,H,P,A>::max_load_factor(float m) BOOST_NOEXCEPT
-    {
-        table_.max_load_factor(m);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_multimap<K, T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
+{
+    table_.max_load_factor(m);
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_multimap<K,T,H,P,A>::rehash(size_type n)
-    {
-        table_.rehash(n);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_multimap<K, T, H, P, A>::rehash(size_type n)
+{
+    table_.rehash(n);
+}
 
-    template <class K, class T, class H, class P, class A>
-    void unordered_multimap<K,T,H,P,A>::reserve(size_type n)
-    {
-        table_.reserve(n);
-    }
+template <class K, class T, class H, class P, class A>
+void unordered_multimap<K, T, H, P, A>::reserve(size_type n)
+{
+    table_.reserve(n);
+}
 
-    template <class K, class T, class H, class P, class A>
-    inline bool operator==(
-            unordered_multimap<K,T,H,P,A> const& m1,
-            unordered_multimap<K,T,H,P,A> const& m2)
-    {
+template <class K, class T, class H, class P, class A>
+inline bool operator==(unordered_multimap<K, T, H, P, A> const& m1,
+    unordered_multimap<K, T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_multimap<K,T,H,P,A> x; };
-#endif
-        return m1.table_.equals(m2.table_);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator!=(
-            unordered_multimap<K,T,H,P,A> const& m1,
-            unordered_multimap<K,T,H,P,A> const& m2)
+    struct dummy
     {
-#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_multimap<K,T,H,P,A> x; };
+        unordered_multimap<K, T, H, P, A> x;
+    };
 #endif
-        return !m1.table_.equals(m2.table_);
-    }
+    return m1.table_.equals(m2.table_);
+}
 
-    template <class K, class T, class H, class P, class A>
-    inline void swap(
-            unordered_multimap<K,T,H,P,A> &m1,
-            unordered_multimap<K,T,H,P,A> &m2)
-    {
+template <class K, class T, class H, class P, class A>
+inline bool operator!=(unordered_multimap<K, T, H, P, A> const& m1,
+    unordered_multimap<K, T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_multimap<K,T,H,P,A> x; };
+    struct dummy
+    {
+        unordered_multimap<K, T, H, P, A> x;
+    };
 #endif
-        m1.swap(m2);
-    }
+    return !m1.table_.equals(m2.table_);
+}
+
+template <class K, class T, class H, class P, class A>
+inline void swap(unordered_multimap<K, T, H, P, A>& m1,
+    unordered_multimap<K, T, H, P, A>& m2)
+{
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+    struct dummy
+    {
+        unordered_multimap<K, T, H, P, A> x;
+    };
+#endif
+    m1.swap(m2);
+}
 
 } // namespace unordered
 } // namespace boost
diff --git a/include/boost/unordered/unordered_map_fwd.hpp b/include/boost/unordered/unordered_map_fwd.hpp
index 1eb26ce9..08c35d70 100644
--- a/include/boost/unordered/unordered_map_fwd.hpp
+++ b/include/boost/unordered/unordered_map_fwd.hpp
@@ -11,55 +11,48 @@
 #pragma once
 #endif
 
-#include <memory>
-#include <functional>
 #include <boost/functional/hash_fwd.hpp>
 #include <boost/unordered/detail/fwd.hpp>
+#include <functional>
+#include <memory>
 
-namespace boost
-{
-    namespace unordered
-    {
-        template <class K,
-            class T,
-            class H = boost::hash<K>,
-            class P = std::equal_to<K>,
-            class A = std::allocator<std::pair<const K, T> > >
-        class unordered_map;
+namespace boost {
+namespace unordered {
+template <class K, class T, class H = boost::hash<K>,
+    class P = std::equal_to<K>,
+    class A = std::allocator<std::pair<const K, T> > >
+class unordered_map;
 
-        template <class K, class T, class H, class P, class A>
-        inline bool operator==(unordered_map<K, T, H, P, A> const&,
-            unordered_map<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline bool operator!=(unordered_map<K, T, H, P, A> const&,
-            unordered_map<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline void swap(unordered_map<K, T, H, P, A>&,
-                unordered_map<K, T, H, P, A>&);
+template <class K, class T, class H, class P, class A>
+inline bool operator==(
+    unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline bool operator!=(
+    unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline void swap(unordered_map<K, T, H, P, A>&, unordered_map<K, T, H, P, A>&);
 
-        template <class K,
-            class T,
-            class H = boost::hash<K>,
-            class P = std::equal_to<K>,
-            class A = std::allocator<std::pair<const K, T> > >
-        class unordered_multimap;
+template <class K, class T, class H = boost::hash<K>,
+    class P = std::equal_to<K>,
+    class A = std::allocator<std::pair<const K, T> > >
+class unordered_multimap;
 
-        template <class K, class T, class H, class P, class A>
-        inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
-            unordered_multimap<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
-            unordered_multimap<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline void swap(unordered_multimap<K, T, H, P, A>&,
-                unordered_multimap<K, T, H, P, A>&);
-    }
+template <class K, class T, class H, class P, class A>
+inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
+    unordered_multimap<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+    unordered_multimap<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline void swap(
+    unordered_multimap<K, T, H, P, A>&, unordered_multimap<K, T, H, P, A>&);
+}
 
-    using boost::unordered::unordered_map;
-    using boost::unordered::unordered_multimap;
-    using boost::unordered::swap;
-    using boost::unordered::operator==;
-    using boost::unordered::operator!=;
+using boost::unordered::unordered_map;
+using boost::unordered::unordered_multimap;
+using boost::unordered::swap;
+using boost::unordered::operator==;
+using boost::unordered::operator!=;
 }
 
 #endif
diff --git a/include/boost/unordered/unordered_set.hpp b/include/boost/unordered/unordered_set.hpp
index 77cd87e0..9137fbc1 100644
--- a/include/boost/unordered/unordered_set.hpp
+++ b/include/boost/unordered/unordered_set.hpp
@@ -14,9 +14,9 @@
 #pragma once
 #endif
 
-#include <boost/unordered/detail/set.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/move/move.hpp>
+#include <boost/unordered/detail/set.hpp>
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
@@ -25,1714 +25,1475 @@
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #if BOOST_MSVC >= 1400
-#pragma warning(disable:4396) //the inline specifier cannot be used when a
-                              // friend declaration refers to a specialization
-                              // of a function template
+#pragma warning(disable : 4396) // the inline specifier cannot be used when a
+// friend declaration refers to a specialization
+// of a function template
 #endif
 #endif
 
-namespace boost
+namespace boost {
+namespace unordered {
+template <class T, class H, class P, class A> class unordered_set
 {
-namespace unordered
-{
-    template <class T, class H, class P, class A>
-    class unordered_set
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    BOOST_COPYABLE_AND_MOVABLE(unordered_set)
+#endif
+  public:
+    typedef T key_type;
+    typedef T value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef A allocator_type;
+
+  private:
+    typedef boost::unordered::detail::set<A, T, H, P> types;
+    typedef typename types::traits allocator_traits;
+    typedef typename types::table table;
+
+  public:
+    typedef typename allocator_traits::pointer pointer;
+    typedef typename allocator_traits::const_pointer const_pointer;
+
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    typedef typename table::cl_iterator const_local_iterator;
+    typedef typename table::l_iterator local_iterator;
+    typedef typename table::c_iterator const_iterator;
+    typedef typename table::iterator iterator;
+
+  private:
+    table table_;
+
+  public:
+    // constructors
+
+    unordered_set();
+
+    explicit unordered_set(size_type, const hasher& = hasher(),
+        const key_equal& = key_equal(),
+        const allocator_type& = allocator_type());
+
+    explicit unordered_set(size_type, const allocator_type&);
+
+    explicit unordered_set(size_type, const hasher&, const allocator_type&);
+
+    explicit unordered_set(allocator_type const&);
+
+    template <class InputIt> unordered_set(InputIt, InputIt);
+
+    template <class InputIt>
+    unordered_set(InputIt, InputIt, size_type, const hasher& = hasher(),
+        const key_equal& = key_equal());
+
+    template <class InputIt>
+    unordered_set(InputIt, InputIt, size_type, const hasher&, const key_equal&,
+        const allocator_type&);
+
+    template <class InputIt>
+    unordered_set(
+        InputIt, InputIt, size_type, const hasher&, const allocator_type&);
+
+    template <class InputIt>
+    unordered_set(InputIt, InputIt, size_type, const allocator_type&);
+
+    // copy/move constructors
+
+    unordered_set(unordered_set const&);
+
+    unordered_set(unordered_set const&, allocator_type const&);
+    unordered_set(BOOST_RV_REF(unordered_set), allocator_type const&);
+
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    unordered_set(BOOST_RV_REF(unordered_set) other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        BOOST_COPYABLE_AND_MOVABLE(unordered_set)
-#endif
-    public:
-
-        typedef T key_type;
-        typedef T value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef A allocator_type;
-
-    private:
-
-        typedef boost::unordered::detail::set<A, T, H, P> types;
-        typedef typename types::traits allocator_traits;
-        typedef typename types::table table;
-
-    public:
-
-        typedef typename allocator_traits::pointer pointer;
-        typedef typename allocator_traits::const_pointer const_pointer;
-
-        typedef value_type& reference;
-        typedef value_type const& const_reference;
-
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-
-        typedef typename table::cl_iterator const_local_iterator;
-        typedef typename table::l_iterator local_iterator;
-        typedef typename table::c_iterator const_iterator;
-        typedef typename table::iterator iterator;
-
-    private:
-
-        table table_;
-
-    public:
-
-        // constructors
-
-        unordered_set();
-
-        explicit unordered_set(
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal(),
-                const allocator_type& = allocator_type());
-
-        explicit unordered_set(
-                size_type,
-                const allocator_type&);
-
-        explicit unordered_set(
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        explicit unordered_set(allocator_type const&);
-
-        template <class InputIt>
-        unordered_set(InputIt, InputIt);
-
-        template <class InputIt>
-        unordered_set(
-                InputIt, InputIt,
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal());
-
-        template <class InputIt>
-        unordered_set(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const key_equal&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_set(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_set(
-                InputIt, InputIt,
-                size_type,
-                const allocator_type&);
-
-        // copy/move constructors
-
-        unordered_set(unordered_set const&);
-
-        unordered_set(unordered_set const&, allocator_type const&);
-        unordered_set(BOOST_RV_REF(unordered_set), allocator_type const&);
-
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_set(BOOST_RV_REF(unordered_set) other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    }
 #elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_set(unordered_set&& other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    unordered_set(unordered_set&& other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
+    {
+    }
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_set(
-                std::initializer_list<value_type>,
-                size_type = boost::unordered::detail::default_bucket_count,
-                const hasher& = hasher(),
-                const key_equal&l = key_equal(),
-                const allocator_type& = allocator_type());
-        unordered_set(
-                std::initializer_list<value_type>,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-        unordered_set(
-                std::initializer_list<value_type>,
-                size_type,
-                const allocator_type&);
+    unordered_set(std::initializer_list<value_type>,
+        size_type = boost::unordered::detail::default_bucket_count,
+        const hasher& = hasher(), const key_equal& l = key_equal(),
+        const allocator_type& = allocator_type());
+    unordered_set(std::initializer_list<value_type>, size_type, const hasher&,
+        const allocator_type&);
+    unordered_set(
+        std::initializer_list<value_type>, size_type, const allocator_type&);
 #endif
 
-        // Destructor
+    // Destructor
 
-        ~unordered_set() BOOST_NOEXCEPT;
+    ~unordered_set() BOOST_NOEXCEPT;
 
-        // Assign
+// Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_set& operator=(BOOST_COPY_ASSIGN_REF(unordered_set) x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_set& operator=(BOOST_COPY_ASSIGN_REF(unordered_set) x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
-        unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #else
-        unordered_set& operator=(unordered_set const& x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_set& operator=(unordered_set const& x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_set& operator=(unordered_set&& x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_set& operator=(unordered_set&& x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_set& operator=(std::initializer_list<value_type>);
+    unordered_set& operator=(std::initializer_list<value_type>);
 #endif
 
-        allocator_type get_allocator() const BOOST_NOEXCEPT
-        {
-            return table_.node_alloc();
-        }
+    allocator_type get_allocator() const BOOST_NOEXCEPT
+    {
+        return table_.node_alloc();
+    }
 
-        // size and capacity
+    // size and capacity
 
-        bool empty() const BOOST_NOEXCEPT
-        {
-            return table_.size_ == 0;
-        }
+    bool empty() const BOOST_NOEXCEPT { return table_.size_ == 0; }
 
-        size_type size() const BOOST_NOEXCEPT
-        {
-            return table_.size_;
-        }
+    size_type size() const BOOST_NOEXCEPT { return table_.size_; }
 
-        size_type max_size() const BOOST_NOEXCEPT;
+    size_type max_size() const BOOST_NOEXCEPT;
 
-        // iterators
+    // iterators
 
-        iterator begin() BOOST_NOEXCEPT
-        {
-            return iterator(table_.begin());
-        }
+    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-        const_iterator begin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator begin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        iterator end() BOOST_NOEXCEPT
-        {
-            return iterator();
-        }
+    iterator end() BOOST_NOEXCEPT { return iterator(); }
 
-        const_iterator end() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        const_iterator cbegin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator cbegin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        const_iterator cend() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        // emplace
+// emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class... Args>
-        std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace(boost::forward<Args>(args)...);
-        }
+    template <class... Args>
+    std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace(boost::forward<Args>(args)...);
+    }
 
-        template <class... Args>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace_hint(hint, boost::forward<Args>(args)...);
-        }
+    template <class... Args>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace_hint(hint, boost::forward<Args>(args)...);
+    }
 #else
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
 
-        // 0 argument emplace requires special treatment in case
-        // the container is instantiated with a value type that
-        // doesn't have a default constructor.
+    // 0 argument emplace requires special treatment in case
+    // the container is instantiated with a value type that
+    // doesn't have a default constructor.
 
-        std::pair<iterator, bool> emplace(
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type())
-        {
-            return this->emplace(boost::move(v));
-        }
+    std::pair<iterator, bool> emplace(
+        boost::unordered::detail::empty_emplace =
+            boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace(boost::move(v));
+    }
 
-        iterator emplace_hint(const_iterator hint,
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type()
-            )
-        {
-            return this->emplace_hint(hint, boost::move(v));
-        }
+    iterator emplace_hint(const_iterator hint,
+        boost::unordered::detail::empty_emplace =
+            boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace_hint(hint, boost::move(v));
+    }
 
 #endif
 
-        template <typename A0>
-        std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0>
+    std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+    }
 
-        template <typename A0>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0)));
+    }
 
-        template <typename A0, typename A1>
-        std::pair<iterator, bool> emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    std::pair<iterator, bool> emplace(
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    iterator emplace_hint(
+        const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        std::pair<iterator, bool> emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    std::pair<iterator, bool> emplace(
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1),
+            boost::forward<A2>(a2)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1),
+                      boost::forward<A2>(a2)));
+    }
 
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                    \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            std::pair<iterator, bool> emplace(                              \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace(                                      \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }                                                               \
-                                                                            \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            iterator emplace_hint(                                          \
-                    const_iterator hint,                                    \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace_hint(hint,                            \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }
+#define BOOST_UNORDERED_EMPLACE(z, n, _)                                       \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    std::pair<iterator, bool> emplace(                                         \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
+    {                                                                          \
+        return table_.emplace(boost::unordered::detail::create_emplace_args(   \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));           \
+    }                                                                          \
+                                                                               \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    iterator emplace_hint(const_iterator hint,                                 \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
+    {                                                                          \
+        return table_.emplace_hint(                                            \
+            hint, boost::unordered::detail::create_emplace_args(               \
+                      BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a))); \
+    }
 
-        BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
+    BOOST_PP_REPEAT_FROM_TO(
+        4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EMPLACE, _)
 
 #undef BOOST_UNORDERED_EMPLACE
 
 #endif
 
-        std::pair<iterator, bool> insert(value_type const& x)
-        {
-            return this->emplace(x);
-        }
+    std::pair<iterator, bool> insert(value_type const& x)
+    {
+        return this->emplace(x);
+    }
 
-        std::pair<iterator, bool> insert(BOOST_UNORDERED_RV_REF(value_type) x)
-        {
-            return this->emplace(boost::move(x));
-        }
+    std::pair<iterator, bool> insert(BOOST_UNORDERED_RV_REF(value_type) x)
+    {
+        return this->emplace(boost::move(x));
+    }
 
-        iterator insert(const_iterator hint, value_type const& x)
-        {
-            return this->emplace_hint(hint, x);
-        }
+    iterator insert(const_iterator hint, value_type const& x)
+    {
+        return this->emplace_hint(hint, x);
+    }
 
-        iterator insert(const_iterator hint,
-                BOOST_UNORDERED_RV_REF(value_type) x)
-        {
-            return this->emplace_hint(hint, boost::move(x));
-        }
+    iterator insert(const_iterator hint, BOOST_UNORDERED_RV_REF(value_type) x)
+    {
+        return this->emplace_hint(hint, boost::move(x));
+    }
 
-        template <class InputIt> void insert(InputIt, InputIt);
+    template <class InputIt> void insert(InputIt, InputIt);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        void insert(std::initializer_list<value_type>);
+    void insert(std::initializer_list<value_type>);
 #endif
 
-        iterator erase(const_iterator);
-        size_type erase(const key_type&);
-        iterator erase(const_iterator, const_iterator);
-        void quick_erase(const_iterator it) { erase(it); }
-        void erase_return_void(const_iterator it) { erase(it); }
+    iterator erase(const_iterator);
+    size_type erase(const key_type&);
+    iterator erase(const_iterator, const_iterator);
+    void quick_erase(const_iterator it) { erase(it); }
+    void erase_return_void(const_iterator it) { erase(it); }
 
-        void clear();
-        void swap(unordered_set&);
+    void clear();
+    void swap(unordered_set&);
 
-        // observers
+    // observers
 
-        hasher hash_function() const;
-        key_equal key_eq() const;
+    hasher hash_function() const;
+    key_equal key_eq() const;
 
-        // lookup
+    // lookup
 
-        const_iterator find(const key_type&) const;
+    const_iterator find(const key_type&) const;
 
-        template <class CompatibleKey, class CompatibleHash,
-            class CompatiblePredicate>
-        const_iterator find(
-                CompatibleKey const&,
-                CompatibleHash const&,
-                CompatiblePredicate const&) const;
+    template <class CompatibleKey, class CompatibleHash,
+        class CompatiblePredicate>
+    const_iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&) const;
 
-        size_type count(const key_type&) const;
+    size_type count(const key_type&) const;
 
-        std::pair<const_iterator, const_iterator>
-        equal_range(const key_type&) const;
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_type&) const;
 
-        // bucket interface
+    // bucket interface
 
-        size_type bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.bucket_count_;
-        }
+    size_type bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.bucket_count_;
+    }
 
-        size_type max_bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.max_bucket_count();
-        }
+    size_type max_bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.max_bucket_count();
+    }
 
-        size_type bucket_size(size_type) const;
+    size_type bucket_size(size_type) const;
 
-        size_type bucket(const key_type& k) const
-        {
-            return table_.hash_to_bucket(table_.hash(k));
-        }
+    size_type bucket(const key_type& k) const
+    {
+        return table_.hash_to_bucket(table_.hash(k));
+    }
 
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    local_iterator begin(size_type n)
+    {
+        return local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator begin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        local_iterator end(size_type)
-        {
-            return local_iterator();
-        }
+    local_iterator end(size_type) { return local_iterator(); }
 
-        const_local_iterator end(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator end(size_type) const { return const_local_iterator(); }
 
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator cbegin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator cend(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator cend(size_type) const
+    {
+        return const_local_iterator();
+    }
 
-        // hash policy
+    // hash policy
 
-        float max_load_factor() const BOOST_NOEXCEPT
-        {
-            return table_.mlf_;
-        }
+    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
 
-        float load_factor() const BOOST_NOEXCEPT;
-        void max_load_factor(float) BOOST_NOEXCEPT;
-        void rehash(size_type);
-        void reserve(size_type);
+    float load_factor() const BOOST_NOEXCEPT;
+    void max_load_factor(float) BOOST_NOEXCEPT;
+    void rehash(size_type);
+    void reserve(size_type);
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-        friend bool operator==<T,H,P,A>(
-                unordered_set const&, unordered_set const&);
-        friend bool operator!=<T,H,P,A>(
-                unordered_set const&, unordered_set const&);
+    friend bool operator==
+        <T, H, P, A>(unordered_set const&, unordered_set const&);
+    friend bool operator!=
+        <T, H, P, A>(unordered_set const&, unordered_set const&);
 #endif
-    }; // class template unordered_set
+}; // class template unordered_set
 
-    template <class T, class H, class P, class A>
-    class unordered_multiset
+template <class T, class H, class P, class A> class unordered_multiset
+{
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    BOOST_COPYABLE_AND_MOVABLE(unordered_multiset)
+#endif
+  public:
+    typedef T key_type;
+    typedef T value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef A allocator_type;
+
+  private:
+    typedef boost::unordered::detail::multiset<A, T, H, P> types;
+    typedef typename types::traits allocator_traits;
+    typedef typename types::table table;
+
+  public:
+    typedef typename allocator_traits::pointer pointer;
+    typedef typename allocator_traits::const_pointer const_pointer;
+
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    typedef typename table::cl_iterator const_local_iterator;
+    typedef typename table::l_iterator local_iterator;
+    typedef typename table::c_iterator const_iterator;
+    typedef typename table::iterator iterator;
+
+  private:
+    table table_;
+
+  public:
+    // constructors
+
+    unordered_multiset();
+
+    explicit unordered_multiset(size_type, const hasher& = hasher(),
+        const key_equal& = key_equal(),
+        const allocator_type& = allocator_type());
+
+    explicit unordered_multiset(size_type, const allocator_type&);
+
+    explicit unordered_multiset(
+        size_type, const hasher&, const allocator_type&);
+
+    explicit unordered_multiset(allocator_type const&);
+
+    template <class InputIt> unordered_multiset(InputIt, InputIt);
+
+    template <class InputIt>
+    unordered_multiset(InputIt, InputIt, size_type, const hasher& = hasher(),
+        const key_equal& = key_equal());
+
+    template <class InputIt>
+    unordered_multiset(InputIt, InputIt, size_type, const hasher&,
+        const key_equal&, const allocator_type&);
+
+    template <class InputIt>
+    unordered_multiset(
+        InputIt, InputIt, size_type, const hasher&, const allocator_type&);
+
+    template <class InputIt>
+    unordered_multiset(InputIt, InputIt, size_type, const allocator_type&);
+
+    // copy/move constructors
+
+    unordered_multiset(unordered_multiset const&);
+
+    unordered_multiset(unordered_multiset const&, allocator_type const&);
+    unordered_multiset(BOOST_RV_REF(unordered_multiset), allocator_type const&);
+
+#if defined(BOOST_UNORDERED_USE_MOVE)
+    unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        BOOST_COPYABLE_AND_MOVABLE(unordered_multiset)
-#endif
-    public:
-
-        typedef T key_type;
-        typedef T value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef A allocator_type;
-
-    private:
-
-        typedef boost::unordered::detail::multiset<A, T, H, P> types;
-        typedef typename types::traits allocator_traits;
-        typedef typename types::table table;
-
-    public:
-
-        typedef typename allocator_traits::pointer pointer;
-        typedef typename allocator_traits::const_pointer const_pointer;
-
-        typedef value_type& reference;
-        typedef value_type const& const_reference;
-
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-
-        typedef typename table::cl_iterator const_local_iterator;
-        typedef typename table::l_iterator local_iterator;
-        typedef typename table::c_iterator const_iterator;
-        typedef typename table::iterator iterator;
-
-    private:
-
-        table table_;
-
-    public:
-
-        // constructors
-
-        unordered_multiset();
-
-        explicit unordered_multiset(
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal(),
-                const allocator_type& = allocator_type());
-
-        explicit unordered_multiset(
-                size_type,
-                const allocator_type&);
-
-        explicit unordered_multiset(
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        explicit unordered_multiset(allocator_type const&);
-
-        template <class InputIt>
-        unordered_multiset(InputIt, InputIt);
-
-        template <class InputIt>
-        unordered_multiset(
-                InputIt, InputIt,
-                size_type,
-                const hasher& = hasher(),
-                const key_equal& = key_equal());
-
-        template <class InputIt>
-        unordered_multiset(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const key_equal&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_multiset(
-                InputIt, InputIt,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-
-        template <class InputIt>
-        unordered_multiset(
-                InputIt, InputIt,
-                size_type,
-                const allocator_type&);
-
-        // copy/move constructors
-
-        unordered_multiset(unordered_multiset const&);
-
-        unordered_multiset(unordered_multiset const&, allocator_type const&);
-        unordered_multiset(BOOST_RV_REF(unordered_multiset), allocator_type const&);
-
-#if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    }
 #elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_multiset(unordered_multiset&& other)
-                BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-            : table_(other.table_, boost::unordered::detail::move_tag())
-        {
-        }
+    unordered_multiset(unordered_multiset&& other)
+        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+        : table_(other.table_, boost::unordered::detail::move_tag())
+    {
+    }
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_multiset(
-                std::initializer_list<value_type>,
-                size_type = boost::unordered::detail::default_bucket_count,
-                const hasher& = hasher(),
-                const key_equal&l = key_equal(),
-                const allocator_type& = allocator_type());
-        unordered_multiset(
-                std::initializer_list<value_type>,
-                size_type,
-                const hasher&,
-                const allocator_type&);
-        unordered_multiset(
-                std::initializer_list<value_type>,
-                size_type,
-                const allocator_type&);
+    unordered_multiset(std::initializer_list<value_type>,
+        size_type = boost::unordered::detail::default_bucket_count,
+        const hasher& = hasher(), const key_equal& l = key_equal(),
+        const allocator_type& = allocator_type());
+    unordered_multiset(std::initializer_list<value_type>, size_type,
+        const hasher&, const allocator_type&);
+    unordered_multiset(
+        std::initializer_list<value_type>, size_type, const allocator_type&);
 #endif
 
-        // Destructor
+    // Destructor
 
-        ~unordered_multiset() BOOST_NOEXCEPT;
+    ~unordered_multiset() BOOST_NOEXCEPT;
 
-        // Assign
+// Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-        unordered_multiset& operator=(
-                BOOST_COPY_ASSIGN_REF(unordered_multiset) x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_multiset& operator=(BOOST_COPY_ASSIGN_REF(unordered_multiset) x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
-        unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #else
-        unordered_multiset& operator=(unordered_multiset const& x)
-        {
-            table_.assign(x.table_);
-            return *this;
-        }
+    unordered_multiset& operator=(unordered_multiset const& x)
+    {
+        table_.assign(x.table_);
+        return *this;
+    }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        unordered_multiset& operator=(unordered_multiset&& x)
-        {
-            table_.move_assign(x.table_);
-            return *this;
-        }
+    unordered_multiset& operator=(unordered_multiset&& x)
+    {
+        table_.move_assign(x.table_);
+        return *this;
+    }
 #endif
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        unordered_multiset& operator=(std::initializer_list<value_type>);
+    unordered_multiset& operator=(std::initializer_list<value_type>);
 #endif
 
-        allocator_type get_allocator() const BOOST_NOEXCEPT
-        {
-            return table_.node_alloc();
-        }
+    allocator_type get_allocator() const BOOST_NOEXCEPT
+    {
+        return table_.node_alloc();
+    }
 
-        // size and capacity
+    // size and capacity
 
-        bool empty() const BOOST_NOEXCEPT
-        {
-            return table_.size_ == 0;
-        }
+    bool empty() const BOOST_NOEXCEPT { return table_.size_ == 0; }
 
-        size_type size() const BOOST_NOEXCEPT
-        {
-            return table_.size_;
-        }
+    size_type size() const BOOST_NOEXCEPT { return table_.size_; }
 
-        size_type max_size() const BOOST_NOEXCEPT;
+    size_type max_size() const BOOST_NOEXCEPT;
 
-        // iterators
+    // iterators
 
-        iterator begin() BOOST_NOEXCEPT
-        {
-            return iterator(table_.begin());
-        }
+    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-        const_iterator begin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator begin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        iterator end() BOOST_NOEXCEPT
-        {
-            return iterator();
-        }
+    iterator end() BOOST_NOEXCEPT { return iterator(); }
 
-        const_iterator end() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        const_iterator cbegin() const BOOST_NOEXCEPT
-        {
-            return const_iterator(table_.begin());
-        }
+    const_iterator cbegin() const BOOST_NOEXCEPT
+    {
+        return const_iterator(table_.begin());
+    }
 
-        const_iterator cend() const BOOST_NOEXCEPT
-        {
-            return const_iterator();
-        }
+    const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
 
-        // emplace
+// emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class... Args>
-        iterator emplace(BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace(boost::forward<Args>(args)...);
-        }
+    template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace(boost::forward<Args>(args)...);
+    }
 
-        template <class... Args>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-        {
-            return table_.emplace_hint(hint, boost::forward<Args>(args)...);
-        }
+    template <class... Args>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+    {
+        return table_.emplace_hint(hint, boost::forward<Args>(args)...);
+    }
 #else
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
 
-        // 0 argument emplace requires special treatment in case
-        // the container is instantiated with a value type that
-        // doesn't have a default constructor.
+    // 0 argument emplace requires special treatment in case
+    // the container is instantiated with a value type that
+    // doesn't have a default constructor.
 
-        iterator emplace(
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type())
-        {
-            return this->emplace(boost::move(v));
-        }
+    iterator emplace(boost::unordered::detail::empty_emplace =
+                         boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace(boost::move(v));
+    }
 
-        iterator emplace_hint(const_iterator hint,
-                boost::unordered::detail::empty_emplace
-                    = boost::unordered::detail::empty_emplace(),
-                value_type v = value_type()
-            )
-        {
-            return this->emplace_hint(hint, boost::move(v));
-        }
+    iterator emplace_hint(const_iterator hint,
+        boost::unordered::detail::empty_emplace =
+            boost::unordered::detail::empty_emplace(),
+        value_type v = value_type())
+    {
+        return this->emplace_hint(hint, boost::move(v));
+    }
 
 #endif
 
-        template <typename A0>
-        iterator emplace(BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+    }
 
-        template <typename A0>
-        iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0))
-            );
-        }
+    template <typename A0>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0)));
+    }
 
-        template <typename A0, typename A1>
-        iterator emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    iterator emplace(BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1))
-            );
-        }
+    template <typename A0, typename A1>
+    iterator emplace_hint(
+        const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        iterator emplace(
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace(
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    iterator emplace(
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace(boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1),
+            boost::forward<A2>(a2)));
+    }
 
-        template <typename A0, typename A1, typename A2>
-        iterator emplace_hint(const_iterator hint,
-            BOOST_FWD_REF(A0) a0,
-            BOOST_FWD_REF(A1) a1,
-            BOOST_FWD_REF(A2) a2)
-        {
-            return table_.emplace_hint(hint,
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0),
-                    boost::forward<A1>(a1),
-                    boost::forward<A2>(a2))
-            );
-        }
+    template <typename A0, typename A1, typename A2>
+    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+    {
+        return table_.emplace_hint(
+            hint, boost::unordered::detail::create_emplace_args(
+                      boost::forward<A0>(a0), boost::forward<A1>(a1),
+                      boost::forward<A2>(a2)));
+    }
 
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                    \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            iterator emplace(                                               \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace(                                      \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }                                                               \
-                                                                            \
-            template <                                                      \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                    \
-            >                                                               \
-            iterator emplace_hint(                                          \
-                    const_iterator hint,                                    \
-                    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)      \
-            )                                                               \
-            {                                                               \
-                return table_.emplace_hint(hint,                            \
-                    boost::unordered::detail::create_emplace_args(          \
-                        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD,  \
-                            a)                                              \
-                ));                                                         \
-            }
+#define BOOST_UNORDERED_EMPLACE(z, n, _)                                       \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    iterator emplace(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))       \
+    {                                                                          \
+        return table_.emplace(boost::unordered::detail::create_emplace_args(   \
+            BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));           \
+    }                                                                          \
+                                                                               \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
+    iterator emplace_hint(const_iterator hint,                                 \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
+    {                                                                          \
+        return table_.emplace_hint(                                            \
+            hint, boost::unordered::detail::create_emplace_args(               \
+                      BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a))); \
+    }
 
-        BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
+    BOOST_PP_REPEAT_FROM_TO(
+        4, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EMPLACE, _)
 
 #undef BOOST_UNORDERED_EMPLACE
 
 #endif
 
-        iterator insert(value_type const& x)
-        {
-            return this->emplace(x);
-        }
+    iterator insert(value_type const& x) { return this->emplace(x); }
 
-        iterator insert(BOOST_UNORDERED_RV_REF(value_type) x)
-        {
-            return this->emplace(boost::move(x));
-        }
+    iterator insert(BOOST_UNORDERED_RV_REF(value_type) x)
+    {
+        return this->emplace(boost::move(x));
+    }
 
-        iterator insert(const_iterator hint, value_type const& x)
-        {
-            return this->emplace_hint(hint, x);
-        }
+    iterator insert(const_iterator hint, value_type const& x)
+    {
+        return this->emplace_hint(hint, x);
+    }
 
-        iterator insert(const_iterator hint,
-                BOOST_UNORDERED_RV_REF(value_type) x)
-        {
-            return this->emplace_hint(hint, boost::move(x));
-        }
+    iterator insert(const_iterator hint, BOOST_UNORDERED_RV_REF(value_type) x)
+    {
+        return this->emplace_hint(hint, boost::move(x));
+    }
 
-        template <class InputIt> void insert(InputIt, InputIt);
+    template <class InputIt> void insert(InputIt, InputIt);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-        void insert(std::initializer_list<value_type>);
+    void insert(std::initializer_list<value_type>);
 #endif
 
-        iterator erase(const_iterator);
-        size_type erase(const key_type&);
-        iterator erase(const_iterator, const_iterator);
-        void quick_erase(const_iterator it) { erase(it); }
-        void erase_return_void(const_iterator it) { erase(it); }
+    iterator erase(const_iterator);
+    size_type erase(const key_type&);
+    iterator erase(const_iterator, const_iterator);
+    void quick_erase(const_iterator it) { erase(it); }
+    void erase_return_void(const_iterator it) { erase(it); }
 
-        void clear();
-        void swap(unordered_multiset&);
+    void clear();
+    void swap(unordered_multiset&);
 
-        // observers
+    // observers
 
-        hasher hash_function() const;
-        key_equal key_eq() const;
+    hasher hash_function() const;
+    key_equal key_eq() const;
 
-        // lookup
+    // lookup
 
-        const_iterator find(const key_type&) const;
+    const_iterator find(const key_type&) const;
 
-        template <class CompatibleKey, class CompatibleHash,
-            class CompatiblePredicate>
-        const_iterator find(
-                CompatibleKey const&,
-                CompatibleHash const&,
-                CompatiblePredicate const&) const;
+    template <class CompatibleKey, class CompatibleHash,
+        class CompatiblePredicate>
+    const_iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&) const;
 
-        size_type count(const key_type&) const;
+    size_type count(const key_type&) const;
 
-        std::pair<const_iterator, const_iterator>
-        equal_range(const key_type&) const;
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_type&) const;
 
-        // bucket interface
+    // bucket interface
 
-        size_type bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.bucket_count_;
-        }
+    size_type bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.bucket_count_;
+    }
 
-        size_type max_bucket_count() const BOOST_NOEXCEPT
-        {
-            return table_.max_bucket_count();
-        }
+    size_type max_bucket_count() const BOOST_NOEXCEPT
+    {
+        return table_.max_bucket_count();
+    }
 
-        size_type bucket_size(size_type) const;
+    size_type bucket_size(size_type) const;
 
-        size_type bucket(const key_type& k) const
-        {
-            return table_.hash_to_bucket(table_.hash(k));
-        }
+    size_type bucket(const key_type& k) const
+    {
+        return table_.hash_to_bucket(table_.hash(k));
+    }
 
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    local_iterator begin(size_type n)
+    {
+        return local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator begin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        local_iterator end(size_type)
-        {
-            return local_iterator();
-        }
+    local_iterator end(size_type) { return local_iterator(); }
 
-        const_local_iterator end(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator end(size_type) const { return const_local_iterator(); }
 
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(
-                table_.begin(n), n, table_.bucket_count_);
-        }
+    const_local_iterator cbegin(size_type n) const
+    {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+    }
 
-        const_local_iterator cend(size_type) const
-        {
-            return const_local_iterator();
-        }
+    const_local_iterator cend(size_type) const
+    {
+        return const_local_iterator();
+    }
 
-        // hash policy
+    // hash policy
 
-        float max_load_factor() const BOOST_NOEXCEPT
-        {
-            return table_.mlf_;
-        }
+    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
 
-        float load_factor() const BOOST_NOEXCEPT;
-        void max_load_factor(float) BOOST_NOEXCEPT;
-        void rehash(size_type);
-        void reserve(size_type);
+    float load_factor() const BOOST_NOEXCEPT;
+    void max_load_factor(float) BOOST_NOEXCEPT;
+    void rehash(size_type);
+    void reserve(size_type);
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-        friend bool operator==<T,H,P,A>(
-                unordered_multiset const&, unordered_multiset const&);
-        friend bool operator!=<T,H,P,A>(
-                unordered_multiset const&, unordered_multiset const&);
+    friend bool operator==
+        <T, H, P, A>(unordered_multiset const&, unordered_multiset const&);
+    friend bool operator!=
+        <T, H, P, A>(unordered_multiset const&, unordered_multiset const&);
 #endif
-    }; // class template unordered_multiset
+}; // class template unordered_multiset
 
 ////////////////////////////////////////////////////////////////////////////////
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set()
-      : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set()
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), allocator_type())
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            size_type n, const hasher &hf, const key_equal &eql,
-            const allocator_type &a)
-      : table_(n, hf, eql, a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(size_type n, const hasher& hf,
+    const key_equal& eql, const allocator_type& a)
+    : table_(n, hf, eql, a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            size_type n, const allocator_type &a)
-      : table_(n, hasher(), key_equal(), a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(size_type n, const allocator_type& a)
+    : table_(n, hasher(), key_equal(), a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            size_type n, const hasher &hf, const allocator_type &a)
-      : table_(n, hf, key_equal(), a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(n, hf, key_equal(), a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(allocator_type const& a)
-      : table_(boost::unordered::detail::default_bucket_count,
-            hasher(), key_equal(), a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(allocator_type const& a)
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            unordered_set const& other, allocator_type const& a)
-      : table_(other.table_, a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(
+    unordered_set const& other, allocator_type const& a)
+    : table_(other.table_, a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_set<T,H,P,A>::unordered_set(InputIt f, InputIt l)
-      : table_(boost::unordered::detail::initial_size(f, l),
-        hasher(), key_equal(), allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_set<T, H, P, A>::unordered_set(InputIt f, InputIt l)
+    : table_(boost::unordered::detail::initial_size(f, l), hasher(),
+          key_equal(), allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_set<T,H,P,A>::unordered_set(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, eql, allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_set<T,H,P,A>::unordered_set(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_set<T,H,P,A>::unordered_set(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_set<T, H, P, A>::unordered_set(
+    InputIt f, InputIt l, size_type n, const hasher& hf, const key_equal& eql)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql,
+          allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_set<T,H,P,A>::unordered_set(
-            InputIt f, InputIt l,
-            size_type n,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_set<T, H, P, A>::unordered_set(InputIt f, InputIt l, size_type n,
+    const hasher& hf, const key_equal& eql, const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::~unordered_set() BOOST_NOEXCEPT {}
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_set<T, H, P, A>::unordered_set(InputIt f, InputIt l, size_type n,
+    const hasher& hf, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(f, l, n), hf, key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            unordered_set const& other)
-      : table_(other.table_)
-    {
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_set<T, H, P, A>::unordered_set(
+    InputIt f, InputIt l, size_type n, const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hasher(),
+          key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            BOOST_RV_REF(unordered_set) other, allocator_type const& a)
-      : table_(other.table_, a, boost::unordered::detail::move_tag())
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::~unordered_set() BOOST_NOEXCEPT
+{
+}
+
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(unordered_set const& other)
+    : table_(other.table_)
+{
+}
+
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(
+    BOOST_RV_REF(unordered_set) other, allocator_type const& a)
+    : table_(other.table_, a, boost::unordered::detail::move_tag())
+{
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const key_equal &eql, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, eql, a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(std::initializer_list<value_type> list,
+    size_type n, const hasher& hf, const key_equal& eql,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, eql, a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(std::initializer_list<value_type> list,
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>::unordered_set(
-            std::initializer_list<value_type> list, size_type n,
-            const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>::unordered_set(std::initializer_list<value_type> list,
+    size_type n, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hasher(), key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class T, class H, class P, class A>
-    unordered_set<T,H,P,A>& unordered_set<T,H,P,A>::operator=(
-            std::initializer_list<value_type> list)
-    {
-        table_.clear();
-        table_.insert_range(list.begin(), list.end());
-        return *this;
-    }
+template <class T, class H, class P, class A>
+unordered_set<T, H, P, A>& unordered_set<T, H, P, A>::operator=(
+    std::initializer_list<value_type> list)
+{
+    table_.clear();
+    table_.insert_range(list.begin(), list.end());
+    return *this;
+}
 
 #endif
 
-    // size and capacity
+// size and capacity
 
-    template <class T, class H, class P, class A>
-    std::size_t unordered_set<T,H,P,A>::max_size() const BOOST_NOEXCEPT
-    {
-        return table_.max_size();
-    }
+template <class T, class H, class P, class A>
+std::size_t unordered_set<T, H, P, A>::max_size() const BOOST_NOEXCEPT
+{
+    return table_.max_size();
+}
 
-    // modifiers
+// modifiers
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    void unordered_set<T,H,P,A>::insert(InputIt first, InputIt last)
-    {
-        table_.insert_range(first, last);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+void unordered_set<T, H, P, A>::insert(InputIt first, InputIt last)
+{
+    table_.insert_range(first, last);
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    template <class T, class H, class P, class A>
-    void unordered_set<T,H,P,A>::insert(
-            std::initializer_list<value_type> list)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+void unordered_set<T, H, P, A>::insert(std::initializer_list<value_type> list)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 #endif
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::iterator
-        unordered_set<T,H,P,A>::erase(const_iterator position)
-    {
-        return table_.erase(position);
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::iterator unordered_set<T, H, P, A>::erase(
+    const_iterator position)
+{
+    return table_.erase(position);
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::size_type
-        unordered_set<T,H,P,A>::erase(const key_type& k)
-    {
-        return table_.erase_key(k);
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::size_type unordered_set<T, H, P, A>::erase(
+    const key_type& k)
+{
+    return table_.erase_key(k);
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::iterator
-        unordered_set<T,H,P,A>::erase(
-            const_iterator first, const_iterator last)
-    {
-        return table_.erase_range(first, last);
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::iterator unordered_set<T, H, P, A>::erase(
+    const_iterator first, const_iterator last)
+{
+    return table_.erase_range(first, last);
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_set<T,H,P,A>::clear()
-    {
-        table_.clear();
-    }
+template <class T, class H, class P, class A>
+void unordered_set<T, H, P, A>::clear()
+{
+    table_.clear();
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_set<T,H,P,A>::swap(unordered_set& other)
-    {
-        table_.swap(other.table_);
-    }
+template <class T, class H, class P, class A>
+void unordered_set<T, H, P, A>::swap(unordered_set& other)
+{
+    table_.swap(other.table_);
+}
 
-    // observers
+// observers
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::hasher
-        unordered_set<T,H,P,A>::hash_function() const
-    {
-        return table_.hash_function();
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::hasher
+unordered_set<T, H, P, A>::hash_function() const
+{
+    return table_.hash_function();
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::key_equal
-        unordered_set<T,H,P,A>::key_eq() const
-    {
-        return table_.key_eq();
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::key_equal
+unordered_set<T, H, P, A>::key_eq() const
+{
+    return table_.key_eq();
+}
 
-    // lookup
+// lookup
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::const_iterator
-        unordered_set<T,H,P,A>::find(const key_type& k) const
-    {
-        return const_iterator(table_.find_node(k));
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::const_iterator
+unordered_set<T, H, P, A>::find(const key_type& k) const
+{
+    return const_iterator(table_.find_node(k));
+}
 
-    template <class T, class H, class P, class A>
-    template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    typename unordered_set<T,H,P,A>::const_iterator
-        unordered_set<T,H,P,A>::find(
-            CompatibleKey const& k,
-            CompatibleHash const& hash,
-            CompatiblePredicate const& eq) const
-    {
-        return const_iterator(table_.generic_find_node(k, hash, eq));
-    }
+template <class T, class H, class P, class A>
+template <class CompatibleKey, class CompatibleHash, class CompatiblePredicate>
+typename unordered_set<T, H, P, A>::const_iterator
+unordered_set<T, H, P, A>::find(CompatibleKey const& k,
+    CompatibleHash const& hash, CompatiblePredicate const& eq) const
+{
+    return const_iterator(table_.generic_find_node(k, hash, eq));
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::size_type
-        unordered_set<T,H,P,A>::count(const key_type& k) const
-    {
-        return table_.count(k);
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::size_type unordered_set<T, H, P, A>::count(
+    const key_type& k) const
+{
+    return table_.count(k);
+}
 
-    template <class T, class H, class P, class A>
-    std::pair<
-            typename unordered_set<T,H,P,A>::const_iterator,
-            typename unordered_set<T,H,P,A>::const_iterator>
-        unordered_set<T,H,P,A>::equal_range(const key_type& k) const
-    {
-        return table_.equal_range(k);
-    }
+template <class T, class H, class P, class A>
+std::pair<typename unordered_set<T, H, P, A>::const_iterator,
+    typename unordered_set<T, H, P, A>::const_iterator>
+unordered_set<T, H, P, A>::equal_range(const key_type& k) const
+{
+    return table_.equal_range(k);
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_set<T,H,P,A>::size_type
-        unordered_set<T,H,P,A>::bucket_size(size_type n) const
-    {
-        return table_.bucket_size(n);
-    }
+template <class T, class H, class P, class A>
+typename unordered_set<T, H, P, A>::size_type
+unordered_set<T, H, P, A>::bucket_size(size_type n) const
+{
+    return table_.bucket_size(n);
+}
 
-    // hash policy
+// hash policy
 
-    template <class T, class H, class P, class A>
-    float unordered_set<T,H,P,A>::load_factor() const BOOST_NOEXCEPT
-    {
-        return table_.load_factor();
-    }
+template <class T, class H, class P, class A>
+float unordered_set<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+{
+    return table_.load_factor();
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_set<T,H,P,A>::max_load_factor(float m) BOOST_NOEXCEPT
-    {
-        table_.max_load_factor(m);
-    }
+template <class T, class H, class P, class A>
+void unordered_set<T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
+{
+    table_.max_load_factor(m);
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_set<T,H,P,A>::rehash(size_type n)
-    {
-        table_.rehash(n);
-    }
+template <class T, class H, class P, class A>
+void unordered_set<T, H, P, A>::rehash(size_type n)
+{
+    table_.rehash(n);
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_set<T,H,P,A>::reserve(size_type n)
-    {
-        table_.reserve(n);
-    }
+template <class T, class H, class P, class A>
+void unordered_set<T, H, P, A>::reserve(size_type n)
+{
+    table_.reserve(n);
+}
 
-    template <class T, class H, class P, class A>
-    inline bool operator==(
-            unordered_set<T,H,P,A> const& m1,
-            unordered_set<T,H,P,A> const& m2)
-    {
+template <class T, class H, class P, class A>
+inline bool operator==(
+    unordered_set<T, H, P, A> const& m1, unordered_set<T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_set<T,H,P,A> x; };
-#endif
-        return m1.table_.equals(m2.table_);
-    }
-
-    template <class T, class H, class P, class A>
-    inline bool operator!=(
-            unordered_set<T,H,P,A> const& m1,
-            unordered_set<T,H,P,A> const& m2)
+    struct dummy
     {
-#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_set<T,H,P,A> x; };
+        unordered_set<T, H, P, A> x;
+    };
 #endif
-        return !m1.table_.equals(m2.table_);
-    }
+    return m1.table_.equals(m2.table_);
+}
 
-    template <class T, class H, class P, class A>
-    inline void swap(
-            unordered_set<T,H,P,A> &m1,
-            unordered_set<T,H,P,A> &m2)
-    {
+template <class T, class H, class P, class A>
+inline bool operator!=(
+    unordered_set<T, H, P, A> const& m1, unordered_set<T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_set<T,H,P,A> x; };
+    struct dummy
+    {
+        unordered_set<T, H, P, A> x;
+    };
 #endif
-        m1.swap(m2);
-    }
+    return !m1.table_.equals(m2.table_);
+}
+
+template <class T, class H, class P, class A>
+inline void swap(unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
+{
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+    struct dummy
+    {
+        unordered_set<T, H, P, A> x;
+    };
+#endif
+    m1.swap(m2);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset()
-      : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset()
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), allocator_type())
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            size_type n, const hasher &hf, const key_equal &eql,
-            const allocator_type &a)
-      : table_(n, hf, eql, a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(size_type n,
+    const hasher& hf, const key_equal& eql, const allocator_type& a)
+    : table_(n, hf, eql, a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            size_type n, const allocator_type &a)
-      : table_(n, hasher(), key_equal(), a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    size_type n, const allocator_type& a)
+    : table_(n, hasher(), key_equal(), a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            size_type n, const hasher &hf, const allocator_type &a)
-      : table_(n, hf, key_equal(), a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(n, hf, key_equal(), a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(allocator_type const& a)
-      : table_(boost::unordered::detail::default_bucket_count,
-            hasher(), key_equal(), a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(allocator_type const& a)
+    : table_(boost::unordered::detail::default_bucket_count, hasher(),
+          key_equal(), a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            unordered_multiset const& other, allocator_type const& a)
-      : table_(other.table_, a)
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    unordered_multiset const& other, allocator_type const& a)
+    : table_(other.table_, a)
+{
+}
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multiset<T,H,P,A>::unordered_multiset(InputIt f, InputIt l)
-      : table_(boost::unordered::detail::initial_size(f, l),
-        hasher(), key_equal(), allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_multiset<T, H, P, A>::unordered_multiset(InputIt f, InputIt l)
+    : table_(boost::unordered::detail::initial_size(f, l), hasher(),
+          key_equal(), allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, eql, allocator_type())
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const key_equal &eql,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
-    {
-        table_.insert_range(f, l);
-    }
-    
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            InputIt f, InputIt l,
-            size_type n,
-            const hasher &hf,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    InputIt f, InputIt l, size_type n, const hasher& hf, const key_equal& eql)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql,
+          allocator_type())
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            InputIt f, InputIt l,
-            size_type n,
-            const allocator_type &a)
-      : table_(boost::unordered::detail::initial_size(f, l, n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(f, l);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_multiset<T, H, P, A>::unordered_multiset(InputIt f, InputIt l,
+    size_type n, const hasher& hf, const key_equal& eql,
+    const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::~unordered_multiset() BOOST_NOEXCEPT {}
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_multiset<T, H, P, A>::unordered_multiset(InputIt f, InputIt l,
+    size_type n, const hasher& hf, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(f, l, n), hf, key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            unordered_multiset const& other)
-      : table_(other.table_)
-    {
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    InputIt f, InputIt l, size_type n, const allocator_type& a)
+    : table_(boost::unordered::detail::initial_size(f, l, n), hasher(),
+          key_equal(), a)
+{
+    table_.insert_range(f, l);
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            BOOST_RV_REF(unordered_multiset) other, allocator_type const& a)
-      : table_(other.table_, a, boost::unordered::detail::move_tag())
-    {
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::~unordered_multiset() BOOST_NOEXCEPT
+{
+}
+
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    unordered_multiset const& other)
+    : table_(other.table_)
+{
+}
+
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    BOOST_RV_REF(unordered_multiset) other, allocator_type const& a)
+    : table_(other.table_, a, boost::unordered::detail::move_tag())
+{
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const key_equal &eql, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, eql, a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    std::initializer_list<value_type> list, size_type n, const hasher& hf,
+    const key_equal& eql, const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, eql, a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            std::initializer_list<value_type> list, size_type n,
-            const hasher &hf, const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hf, key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    std::initializer_list<value_type> list, size_type n, const hasher& hf,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hf, key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>::unordered_multiset(
-            std::initializer_list<value_type> list, size_type n,
-            const allocator_type &a)
-      : table_(
-            boost::unordered::detail::initial_size(
-                list.begin(), list.end(), n),
-            hasher(), key_equal(), a)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>::unordered_multiset(
+    std::initializer_list<value_type> list, size_type n,
+    const allocator_type& a)
+    : table_(
+          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+          hasher(), key_equal(), a)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 
-    template <class T, class H, class P, class A>
-    unordered_multiset<T,H,P,A>& unordered_multiset<T,H,P,A>::operator=(
-            std::initializer_list<value_type> list)
-    {
-        table_.clear();
-        table_.insert_range(list.begin(), list.end());
-        return *this;
-    }
+template <class T, class H, class P, class A>
+unordered_multiset<T, H, P, A>& unordered_multiset<T, H, P, A>::operator=(
+    std::initializer_list<value_type> list)
+{
+    table_.clear();
+    table_.insert_range(list.begin(), list.end());
+    return *this;
+}
 
 #endif
 
-    // size and capacity
+// size and capacity
 
-    template <class T, class H, class P, class A>
-    std::size_t unordered_multiset<T,H,P,A>::max_size() const BOOST_NOEXCEPT
-    {
-        return table_.max_size();
-    }
+template <class T, class H, class P, class A>
+std::size_t unordered_multiset<T, H, P, A>::max_size() const BOOST_NOEXCEPT
+{
+    return table_.max_size();
+}
 
-    // modifiers
+// modifiers
 
-    template <class T, class H, class P, class A>
-    template <class InputIt>
-    void unordered_multiset<T,H,P,A>::insert(InputIt first, InputIt last)
-    {
-        table_.insert_range(first, last);
-    }
+template <class T, class H, class P, class A>
+template <class InputIt>
+void unordered_multiset<T, H, P, A>::insert(InputIt first, InputIt last)
+{
+    table_.insert_range(first, last);
+}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    template <class T, class H, class P, class A>
-    void unordered_multiset<T,H,P,A>::insert(
-            std::initializer_list<value_type> list)
-    {
-        table_.insert_range(list.begin(), list.end());
-    }
+template <class T, class H, class P, class A>
+void unordered_multiset<T, H, P, A>::insert(
+    std::initializer_list<value_type> list)
+{
+    table_.insert_range(list.begin(), list.end());
+}
 #endif
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::iterator
-        unordered_multiset<T,H,P,A>::erase(const_iterator position)
-    {
-        return table_.erase(position);
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::iterator
+unordered_multiset<T, H, P, A>::erase(const_iterator position)
+{
+    return table_.erase(position);
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::size_type
-        unordered_multiset<T,H,P,A>::erase(const key_type& k)
-    {
-        return table_.erase_key(k);
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::size_type
+unordered_multiset<T, H, P, A>::erase(const key_type& k)
+{
+    return table_.erase_key(k);
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::iterator
-        unordered_multiset<T,H,P,A>::erase(
-                const_iterator first, const_iterator last)
-    {
-        return table_.erase_range(first, last);
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::iterator
+unordered_multiset<T, H, P, A>::erase(const_iterator first, const_iterator last)
+{
+    return table_.erase_range(first, last);
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_multiset<T,H,P,A>::clear()
-    {
-        table_.clear();
-    }
+template <class T, class H, class P, class A>
+void unordered_multiset<T, H, P, A>::clear()
+{
+    table_.clear();
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_multiset<T,H,P,A>::swap(unordered_multiset& other)
-    {
-        table_.swap(other.table_);
-    }
+template <class T, class H, class P, class A>
+void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other)
+{
+    table_.swap(other.table_);
+}
 
-    // observers
+// observers
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::hasher
-        unordered_multiset<T,H,P,A>::hash_function() const
-    {
-        return table_.hash_function();
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::hasher
+unordered_multiset<T, H, P, A>::hash_function() const
+{
+    return table_.hash_function();
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::key_equal
-        unordered_multiset<T,H,P,A>::key_eq() const
-    {
-        return table_.key_eq();
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::key_equal
+unordered_multiset<T, H, P, A>::key_eq() const
+{
+    return table_.key_eq();
+}
 
-    // lookup
+// lookup
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::const_iterator
-        unordered_multiset<T,H,P,A>::find(const key_type& k) const
-    {
-        return const_iterator(table_.find_node(k));
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::const_iterator
+unordered_multiset<T, H, P, A>::find(const key_type& k) const
+{
+    return const_iterator(table_.find_node(k));
+}
 
-    template <class T, class H, class P, class A>
-    template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    typename unordered_multiset<T,H,P,A>::const_iterator
-        unordered_multiset<T,H,P,A>::find(
-            CompatibleKey const& k,
-            CompatibleHash const& hash,
-            CompatiblePredicate const& eq) const
-    {
-        return const_iterator(table_.generic_find_node(k, hash, eq));
-    }
+template <class T, class H, class P, class A>
+template <class CompatibleKey, class CompatibleHash, class CompatiblePredicate>
+typename unordered_multiset<T, H, P, A>::const_iterator
+unordered_multiset<T, H, P, A>::find(CompatibleKey const& k,
+    CompatibleHash const& hash, CompatiblePredicate const& eq) const
+{
+    return const_iterator(table_.generic_find_node(k, hash, eq));
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::size_type
-        unordered_multiset<T,H,P,A>::count(const key_type& k) const
-    {
-        return table_.count(k);
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::size_type
+unordered_multiset<T, H, P, A>::count(const key_type& k) const
+{
+    return table_.count(k);
+}
 
-    template <class T, class H, class P, class A>
-    std::pair<
-            typename unordered_multiset<T,H,P,A>::const_iterator,
-            typename unordered_multiset<T,H,P,A>::const_iterator>
-        unordered_multiset<T,H,P,A>::equal_range(const key_type& k) const
-    {
-        return table_.equal_range(k);
-    }
+template <class T, class H, class P, class A>
+std::pair<typename unordered_multiset<T, H, P, A>::const_iterator,
+    typename unordered_multiset<T, H, P, A>::const_iterator>
+unordered_multiset<T, H, P, A>::equal_range(const key_type& k) const
+{
+    return table_.equal_range(k);
+}
 
-    template <class T, class H, class P, class A>
-    typename unordered_multiset<T,H,P,A>::size_type
-        unordered_multiset<T,H,P,A>::bucket_size(size_type n) const
-    {
-        return table_.bucket_size(n);
-    }
+template <class T, class H, class P, class A>
+typename unordered_multiset<T, H, P, A>::size_type
+unordered_multiset<T, H, P, A>::bucket_size(size_type n) const
+{
+    return table_.bucket_size(n);
+}
 
-    // hash policy
+// hash policy
 
-    template <class T, class H, class P, class A>
-    float unordered_multiset<T,H,P,A>::load_factor() const BOOST_NOEXCEPT
-    {
-        return table_.load_factor();
-    }
+template <class T, class H, class P, class A>
+float unordered_multiset<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+{
+    return table_.load_factor();
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_multiset<T,H,P,A>::max_load_factor(float m) BOOST_NOEXCEPT
-    {
-        table_.max_load_factor(m);
-    }
+template <class T, class H, class P, class A>
+void unordered_multiset<T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
+{
+    table_.max_load_factor(m);
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_multiset<T,H,P,A>::rehash(size_type n)
-    {
-        table_.rehash(n);
-    }
+template <class T, class H, class P, class A>
+void unordered_multiset<T, H, P, A>::rehash(size_type n)
+{
+    table_.rehash(n);
+}
 
-    template <class T, class H, class P, class A>
-    void unordered_multiset<T,H,P,A>::reserve(size_type n)
-    {
-        table_.reserve(n);
-    }
+template <class T, class H, class P, class A>
+void unordered_multiset<T, H, P, A>::reserve(size_type n)
+{
+    table_.reserve(n);
+}
 
-    template <class T, class H, class P, class A>
-    inline bool operator==(
-            unordered_multiset<T,H,P,A> const& m1,
-            unordered_multiset<T,H,P,A> const& m2)
-    {
+template <class T, class H, class P, class A>
+inline bool operator==(unordered_multiset<T, H, P, A> const& m1,
+    unordered_multiset<T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_multiset<T,H,P,A> x; };
-#endif
-        return m1.table_.equals(m2.table_);
-    }
-
-    template <class T, class H, class P, class A>
-    inline bool operator!=(
-            unordered_multiset<T,H,P,A> const& m1,
-            unordered_multiset<T,H,P,A> const& m2)
+    struct dummy
     {
-#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_multiset<T,H,P,A> x; };
+        unordered_multiset<T, H, P, A> x;
+    };
 #endif
-        return !m1.table_.equals(m2.table_);
-    }
+    return m1.table_.equals(m2.table_);
+}
 
-    template <class T, class H, class P, class A>
-    inline void swap(
-            unordered_multiset<T,H,P,A> &m1,
-            unordered_multiset<T,H,P,A> &m2)
-    {
+template <class T, class H, class P, class A>
+inline bool operator!=(unordered_multiset<T, H, P, A> const& m1,
+    unordered_multiset<T, H, P, A> const& m2)
+{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy { unordered_multiset<T,H,P,A> x; };
+    struct dummy
+    {
+        unordered_multiset<T, H, P, A> x;
+    };
 #endif
-        m1.swap(m2);
-    }
+    return !m1.table_.equals(m2.table_);
+}
+
+template <class T, class H, class P, class A>
+inline void swap(
+    unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
+{
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+    struct dummy
+    {
+        unordered_multiset<T, H, P, A> x;
+    };
+#endif
+    m1.swap(m2);
+}
 } // namespace unordered
 } // namespace boost
 
diff --git a/include/boost/unordered/unordered_set_fwd.hpp b/include/boost/unordered/unordered_set_fwd.hpp
index 52b9e822..cc606274 100644
--- a/include/boost/unordered/unordered_set_fwd.hpp
+++ b/include/boost/unordered/unordered_set_fwd.hpp
@@ -11,53 +11,46 @@
 #pragma once
 #endif
 
-#include <memory>
-#include <functional>
 #include <boost/functional/hash_fwd.hpp>
 #include <boost/unordered/detail/fwd.hpp>
+#include <functional>
+#include <memory>
 
-namespace boost
-{
-    namespace unordered
-    {
-        template <class T,
-            class H = boost::hash<T>,
-            class P = std::equal_to<T>,
-            class A = std::allocator<T> >
-        class unordered_set;
+namespace boost {
+namespace unordered {
+template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
+    class A = std::allocator<T> >
+class unordered_set;
 
-        template <class T, class H, class P, class A>
-        inline bool operator==(unordered_set<T, H, P, A> const&,
-            unordered_set<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline bool operator!=(unordered_set<T, H, P, A> const&,
-            unordered_set<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline void swap(unordered_set<T, H, P, A> &m1,
-                unordered_set<T, H, P, A> &m2);
+template <class T, class H, class P, class A>
+inline bool operator==(
+    unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
+template <class T, class H, class P, class A>
+inline bool operator!=(
+    unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
+template <class T, class H, class P, class A>
+inline void swap(unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2);
 
-        template <class T,
-            class H = boost::hash<T>,
-            class P = std::equal_to<T>,
-            class A = std::allocator<T> >
-        class unordered_multiset;
+template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
+    class A = std::allocator<T> >
+class unordered_multiset;
 
-        template <class T, class H, class P, class A>
-        inline bool operator==(unordered_multiset<T, H, P, A> const&,
-            unordered_multiset<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline bool operator!=(unordered_multiset<T, H, P, A> const&,
-            unordered_multiset<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline void swap(unordered_multiset<T, H, P, A> &m1,
-                unordered_multiset<T, H, P, A> &m2);
-    }
+template <class T, class H, class P, class A>
+inline bool operator==(unordered_multiset<T, H, P, A> const&,
+    unordered_multiset<T, H, P, A> const&);
+template <class T, class H, class P, class A>
+inline bool operator!=(unordered_multiset<T, H, P, A> const&,
+    unordered_multiset<T, H, P, A> const&);
+template <class T, class H, class P, class A>
+inline void swap(
+    unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2);
+}
 
-    using boost::unordered::unordered_set;
-    using boost::unordered::unordered_multiset;
-    using boost::unordered::swap;
-    using boost::unordered::operator==;
-    using boost::unordered::operator!=;
+using boost::unordered::unordered_set;
+using boost::unordered::unordered_multiset;
+using boost::unordered::swap;
+using boost::unordered::operator==;
+using boost::unordered::operator!=;
 }
 
 #endif
diff --git a/test/exception/assign_exception_tests.cpp b/test/exception/assign_exception_tests.cpp
index 1831f808..3295a4e8 100644
--- a/test/exception/assign_exception_tests.cpp
+++ b/test/exception/assign_exception_tests.cpp
@@ -5,17 +5,16 @@
 
 #include "./containers.hpp"
 
-#include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
 
 #if defined(BOOST_MSVC)
-#pragma warning(disable:4512) // assignment operator could not be generated
+#pragma warning(disable : 4512) // assignment operator could not be generated
 #endif
 
 test::seed_t initialize_seed(12847);
 
-template <class T>
-struct self_assign_base : public test::exception_base
+template <class T> struct self_assign_base : public test::exception_base
 {
     test::random_values<T> values;
     self_assign_base(std::size_t count = 0) : values(count) {}
@@ -24,33 +23,33 @@ struct self_assign_base : public test::exception_base
     T init() const { return T(values.begin(), values.end()); }
     void run(T& x) const { x = x; }
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
-        { test::check_equivalent_keys(x); }
+    {
+        test::check_equivalent_keys(x);
+    }
 };
 
-template <class T>
-struct self_assign_test1 : self_assign_base<T> {};
+template <class T> struct self_assign_test1 : self_assign_base<T>
+{
+};
 
-template <class T>
-struct self_assign_test2 : self_assign_base<T>
+template <class T> struct self_assign_test2 : self_assign_base<T>
 {
     self_assign_test2() : self_assign_base<T>(100) {}
 };
 
-template <class T>
-struct assign_base : public test::exception_base
+template <class T> struct assign_base : public test::exception_base
 {
     test::random_values<T> x_values, y_values;
-    T x,y;
+    T x, y;
 
     typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
     typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
-    assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        x_values(),
-        y_values(),
-        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
+    assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
+        : x_values(), y_values(),
+          x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
+          y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
     {
         x.max_load_factor(mlf1);
         y.max_load_factor(mlf2);
@@ -74,12 +73,11 @@ struct assign_base : public test::exception_base
     }
 };
 
-template <class T>
-struct assign_values : assign_base<T>
+template <class T> struct assign_values : assign_base<T>
 {
-    assign_values(unsigned int count1, unsigned int count2,
-            int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        assign_base<T>(tag1, tag2, mlf1, mlf2)
+    assign_values(unsigned int count1, unsigned int count2, int tag1, int tag2,
+        float mlf1 = 1.0, float mlf2 = 1.0)
+        : assign_base<T>(tag1, tag2, mlf1, mlf2)
     {
         this->x_values.fill(count1);
         this->y_values.fill(count2);
@@ -88,47 +86,39 @@ struct assign_values : assign_base<T>
     }
 };
 
-template <class T>
-struct assign_test1 : assign_values<T>
+template <class T> struct assign_test1 : assign_values<T>
 {
     assign_test1() : assign_values<T>(0, 0, 0, 0) {}
 };
 
-template <class T>
-struct assign_test2 : assign_values<T>
+template <class T> struct assign_test2 : assign_values<T>
 {
     assign_test2() : assign_values<T>(60, 0, 0, 0) {}
 };
 
-template <class T>
-struct assign_test3 : assign_values<T>
+template <class T> struct assign_test3 : assign_values<T>
 {
     assign_test3() : assign_values<T>(0, 60, 0, 0) {}
 };
 
-template <class T>
-struct assign_test4 : assign_values<T>
+template <class T> struct assign_test4 : assign_values<T>
 {
     assign_test4() : assign_values<T>(10, 10, 1, 2) {}
 };
 
-template <class T>
-struct assign_test4a : assign_values<T>
+template <class T> struct assign_test4a : assign_values<T>
 {
     assign_test4a() : assign_values<T>(10, 100, 1, 2) {}
 };
 
-template <class T>
-struct assign_test5 : assign_values<T>
+template <class T> struct assign_test5 : assign_values<T>
 {
     assign_test5() : assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
 };
 
-template <class T>
-struct equivalent_test1 : assign_base<T>
+template <class T> struct equivalent_test1 : assign_base<T>
 {
-    equivalent_test1() :
-        assign_base<T>(0, 0)
+    equivalent_test1() : assign_base<T>(0, 0)
     {
         test::random_values<T> x_values2(10);
         this->x_values.insert(x_values2.begin(), x_values2.end());
@@ -141,9 +131,8 @@ struct equivalent_test1 : assign_base<T>
     }
 };
 
-EXCEPTION_TESTS(
-    (self_assign_test1)(self_assign_test2)
-    (assign_test1)(assign_test2)(assign_test3)(assign_test4)(assign_test4a)(assign_test5)
-    (equivalent_test1),
+EXCEPTION_TESTS((self_assign_test1)(self_assign_test2)(assign_test1)(
+                    assign_test2)(assign_test3)(assign_test4)(assign_test4a)(
+                    assign_test5)(equivalent_test1),
     CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/exception/constructor_exception_tests.cpp b/test/exception/constructor_exception_tests.cpp
index eaa9ae58..db5023f7 100644
--- a/test/exception/constructor_exception_tests.cpp
+++ b/test/exception/constructor_exception_tests.cpp
@@ -5,8 +5,8 @@
 
 #include "./containers.hpp"
 
-#include "../helpers/random_values.hpp"
 #include "../helpers/input_iterator.hpp"
+#include "../helpers/random_values.hpp"
 
 template <typename T> inline void avoid_unused_warning(T const&) {}
 
@@ -20,62 +20,61 @@ struct objects
     test::exception::allocator<test::exception::object> allocator;
 };
 
-template <class T>
-struct construct_test1 : public objects, test::exception_base
+template <class T> struct construct_test1 : public objects, test::exception_base
 {
-    void run() const {
+    void run() const
+    {
         T x;
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct construct_test2 : public objects, test::exception_base
+template <class T> struct construct_test2 : public objects, test::exception_base
 {
-    void run() const {
+    void run() const
+    {
         T x(300);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct construct_test3 : public objects, test::exception_base
+template <class T> struct construct_test3 : public objects, test::exception_base
 {
-    void run() const {
+    void run() const
+    {
         T x(0, hash);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct construct_test4 : public objects, test::exception_base
+template <class T> struct construct_test4 : public objects, test::exception_base
 {
-    void run() const {
+    void run() const
+    {
         T x(0, hash, equal_to);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct construct_test5 : public objects, test::exception_base
+template <class T> struct construct_test5 : public objects, test::exception_base
 {
-    void run() const {
+    void run() const
+    {
         T x(50, hash, equal_to, allocator);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct construct_test6 : public objects, test::exception_base
+template <class T> struct construct_test6 : public objects, test::exception_base
 {
-    void run() const {
+    void run() const
+    {
         T x(allocator);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct range : public test::exception_base
+template <class T> struct range : public test::exception_base
 {
     test::random_values<T> values;
 
@@ -83,37 +82,37 @@ struct range : public test::exception_base
     range(unsigned int count) : values(count) {}
 };
 
-template <class T>
-struct range_construct_test1 : public range<T>, objects
+template <class T> struct range_construct_test1 : public range<T>, objects
 {
-    void run() const {
+    void run() const
+    {
         T x(this->values.begin(), this->values.end());
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct range_construct_test2 : public range<T>, objects
+template <class T> struct range_construct_test2 : public range<T>, objects
 {
-    void run() const {
+    void run() const
+    {
         T x(this->values.begin(), this->values.end(), 0);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct range_construct_test3 : public range<T>, objects
+template <class T> struct range_construct_test3 : public range<T>, objects
 {
-    void run() const {
+    void run() const
+    {
         T x(this->values.begin(), this->values.end(), 0, hash);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct range_construct_test4 : public range<T>, objects
+template <class T> struct range_construct_test4 : public range<T>, objects
 {
-    void run() const {
+    void run() const
+    {
         T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
         avoid_unused_warning(x);
     }
@@ -121,58 +120,51 @@ struct range_construct_test4 : public range<T>, objects
 
 // Need to run at least one test with a fairly large number
 // of objects in case it triggers a rehash.
-template <class T>
-struct range_construct_test5 : public range<T>, objects
+template <class T> struct range_construct_test5 : public range<T>, objects
 {
     range_construct_test5() : range<T>(60) {}
 
-    void run() const {
-        T x(this->values.begin(), this->values.end(), 0,
-            hash, equal_to, allocator);
+    void run() const
+    {
+        T x(this->values.begin(), this->values.end(), 0, hash, equal_to,
+            allocator);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct input_range_construct_test : public range<T>, objects
+template <class T> struct input_range_construct_test : public range<T>, objects
 {
     input_range_construct_test() : range<T>(60) {}
 
-    void run() const {
+    void run() const
+    {
         BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            begin = this->values.begin(), end = this->values.end();
-        T x(test::input_iterator(begin), test::input_iterator(end),
-                0, hash, equal_to, allocator);
+            begin = this->values.begin(),
+            end = this->values.end();
+        T x(test::input_iterator(begin), test::input_iterator(end), 0, hash,
+            equal_to, allocator);
         avoid_unused_warning(x);
     }
 };
 
-template <class T>
-struct copy_range_construct_test : public range<T>, objects
+template <class T> struct copy_range_construct_test : public range<T>, objects
 {
     copy_range_construct_test() : range<T>(60) {}
 
-    void run() const {
+    void run() const
+    {
         T x(test::copy_iterator(this->values.begin()),
-                test::copy_iterator(this->values.end()),
-                0, hash, equal_to, allocator);
+            test::copy_iterator(this->values.end()), 0, hash, equal_to,
+            allocator);
         avoid_unused_warning(x);
     }
 };
 
 EXCEPTION_TESTS(
-    (construct_test1)
-    (construct_test2)
-    (construct_test3)
-    (construct_test4)
-    (construct_test5)
-    (construct_test6)
-    (range_construct_test1)
-    (range_construct_test2)
-    (range_construct_test3)
-    (range_construct_test4)
-    (range_construct_test5)
-    (input_range_construct_test)
-    (copy_range_construct_test),
+    (construct_test1)(construct_test2)(construct_test3)(construct_test4)(
+        construct_test5)(construct_test6)(range_construct_test1)(
+        range_construct_test2)(range_construct_test3)(range_construct_test4)(
+        range_construct_test5)(input_range_construct_test)(
+        copy_range_construct_test),
     CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/exception/containers.hpp b/test/exception/containers.hpp
index b1a873e4..c8ca5a2f 100644
--- a/test/exception/containers.hpp
+++ b/test/exception/containers.hpp
@@ -12,39 +12,33 @@
 
 #include "../objects/exception.hpp"
 
-typedef boost::unordered_set<
-    test::exception::object,
-    test::exception::hash,
+typedef boost::unordered_set<test::exception::object, test::exception::hash,
     test::exception::equal_to,
-    test::exception::allocator<test::exception::object> > test_set;
-typedef boost::unordered_multiset<
-    test::exception::object,
-    test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> > test_multiset;
-typedef boost::unordered_map<
-    test::exception::object,
-    test::exception::object,
-    test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> > test_map;
-typedef boost::unordered_multimap<
-    test::exception::object,
-    test::exception::object,
-    test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator<test::exception::object> > test_multimap;
+    test::exception::allocator<test::exception::object> >
+    test_set;
+typedef boost::unordered_multiset<test::exception::object,
+    test::exception::hash, test::exception::equal_to,
+    test::exception::allocator2<test::exception::object> >
+    test_multiset;
+typedef boost::unordered_map<test::exception::object, test::exception::object,
+    test::exception::hash, test::exception::equal_to,
+    test::exception::allocator2<test::exception::object> >
+    test_map;
+typedef boost::unordered_multimap<test::exception::object,
+    test::exception::object, test::exception::hash, test::exception::equal_to,
+    test::exception::allocator<test::exception::object> >
+    test_multimap;
 typedef boost::unordered_set<
     std::pair<test::exception::object, test::exception::object>,
-    test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator<test::exception::object> > test_pair_set;
+    test::exception::hash, test::exception::equal_to,
+    test::exception::allocator<test::exception::object> >
+    test_pair_set;
 typedef boost::unordered_multiset<
     std::pair<test::exception::object, test::exception::object>,
-    test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> > test_pair_multiset;
-
+    test::exception::hash, test::exception::equal_to,
+    test::exception::allocator2<test::exception::object> >
+    test_pair_multiset;
 
 #define CONTAINER_SEQ (test_set)(test_multiset)(test_map)(test_multimap)
-#define CONTAINER_PAIR_SEQ (test_pair_set)(test_pair_multiset)(test_map)(test_multimap)
+#define CONTAINER_PAIR_SEQ                                                     \
+    (test_pair_set)(test_pair_multiset)(test_map)(test_multimap)
diff --git a/test/exception/copy_exception_tests.cpp b/test/exception/copy_exception_tests.cpp
index 564db33c..9bb87eca 100644
--- a/test/exception/copy_exception_tests.cpp
+++ b/test/exception/copy_exception_tests.cpp
@@ -11,47 +11,46 @@ template <typename T> inline void avoid_unused_warning(T const&) {}
 
 test::seed_t initialize_seed(73041);
 
-template <class T>
-struct copy_test1 : public test::exception_base
+template <class T> struct copy_test1 : public test::exception_base
 {
     T x;
 
-    void run() const {
+    void run() const
+    {
         T y(x);
         avoid_unused_warning(y);
     }
 };
 
-template <class T>
-struct copy_test2 : public test::exception_base
+template <class T> struct copy_test2 : public test::exception_base
 {
     test::random_values<T> values;
     T x;
 
     copy_test2() : values(5), x(values.begin(), values.end()) {}
 
-    void run() const {
+    void run() const
+    {
         T y(x);
         avoid_unused_warning(y);
     }
 };
 
-template <class T>
-struct copy_test3 : public test::exception_base
+template <class T> struct copy_test3 : public test::exception_base
 {
     test::random_values<T> values;
     T x;
 
     copy_test3() : values(100), x(values.begin(), values.end()) {}
 
-    void run() const {
+    void run() const
+    {
         T y(x);
         avoid_unused_warning(y);
     }
 };
 
-template <class T>
-struct copy_with_allocator_test : public test::exception_base
+template <class T> struct copy_with_allocator_test : public test::exception_base
 {
     test::random_values<T> values;
     T x;
@@ -59,13 +58,13 @@ struct copy_with_allocator_test : public test::exception_base
 
     copy_with_allocator_test() : values(100), x(values.begin(), values.end()) {}
 
-    void run() const {
+    void run() const
+    {
         T y(x, allocator);
         avoid_unused_warning(y);
     }
 };
 
-EXCEPTION_TESTS(
-    (copy_test1)(copy_test2)(copy_test3)(copy_with_allocator_test),
+EXCEPTION_TESTS((copy_test1)(copy_test2)(copy_test3)(copy_with_allocator_test),
     CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/exception/erase_exception_tests.cpp b/test/exception/erase_exception_tests.cpp
index 11b8c3d4..a939ded3 100644
--- a/test/exception/erase_exception_tests.cpp
+++ b/test/exception/erase_exception_tests.cpp
@@ -5,52 +5,46 @@
 
 #include "./containers.hpp"
 
-#include "../helpers/random_values.hpp"
-#include "../helpers/invariants.hpp"
 #include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
 
 test::seed_t initialize_seed(835193);
 
-template <class T>
-struct erase_test_base : public test::exception_base
+template <class T> struct erase_test_base : public test::exception_base
 {
     test::random_values<T> values;
     erase_test_base(unsigned int count = 5) : values(count) {}
 
     typedef T data_type;
 
-    data_type init() const {
-        return T(values.begin(), values.end());
-    }
+    data_type init() const { return T(values.begin(), values.end()); }
 
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+    {
         std::string scope(test::scope);
 
         BOOST_TEST(scope.find("hash::") != std::string::npos ||
-                scope.find("equal_to::") != std::string::npos ||
-                scope == "operator==(object, object)");
+                   scope.find("equal_to::") != std::string::npos ||
+                   scope == "operator==(object, object)");
 
         test::check_equivalent_keys(x);
     }
 };
 
-template <class T>
-struct erase_by_key_test1 : public erase_test_base<T>
+template <class T> struct erase_by_key_test1 : public erase_test_base<T>
 {
     void run(T& x) const
     {
-        typedef BOOST_DEDUCED_TYPENAME
-            test::random_values<T>::const_iterator iterator;
+        typedef BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+            iterator;
 
-        for(iterator it = this->values.begin(), end = this->values.end();
-                it != end; ++it)
-        {
+        for (iterator it = this->values.begin(), end = this->values.end();
+             it != end; ++it) {
             x.erase(test::get_key<T>(*it));
         }
     }
 };
 
-EXCEPTION_TESTS(
-    (erase_by_key_test1),
-    CONTAINER_SEQ)
+EXCEPTION_TESTS((erase_by_key_test1), CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/exception/insert_exception_tests.cpp b/test/exception/insert_exception_tests.cpp
index 1b0cf6e3..f8d635de 100644
--- a/test/exception/insert_exception_tests.cpp
+++ b/test/exception/insert_exception_tests.cpp
@@ -5,51 +5,52 @@
 
 #include "./containers.hpp"
 
-#include <string>
-#include "../helpers/random_values.hpp"
-#include "../helpers/invariants.hpp"
-#include "../helpers/strong.hpp"
 #include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/strong.hpp"
 #include <cmath>
+#include <string>
 
 test::seed_t initialize_seed(747373);
 
-template <class T>
-struct insert_test_base : public test::exception_base
+template <class T> struct insert_test_base : public test::exception_base
 {
     test::random_values<T> values;
-    insert_test_base(unsigned int count = 5) : values(count, test::limited_range) {}
+    insert_test_base(unsigned int count = 5)
+        : values(count, test::limited_range)
+    {
+    }
 
     typedef T data_type;
     typedef test::strong<T> strong_type;
 
-    data_type init() const {
-        return T();
-    }
+    data_type init() const { return T(); }
 
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(
         T const& x, strong_type const& strong) const
     {
         std::string scope(test::scope);
 
-        if(scope.find("hash::operator()") == std::string::npos)
+        if (scope.find("hash::operator()") == std::string::npos)
             strong.test(x, test::detail::tracker.count_allocations);
         test::check_equivalent_keys(x);
     }
 };
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) &&                              \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-template <class T>
-struct emplace_test1 : public insert_test_base<T>
+template <class T> struct emplace_test1 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.emplace(*it);
         }
@@ -58,74 +59,72 @@ struct emplace_test1 : public insert_test_base<T>
 
 #endif
 
-template <class T>
-struct insert_test1 : public insert_test_base<T>
+template <class T> struct insert_test1 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.insert(*it);
         }
     }
 };
 
-template <class T>
-struct insert_test2 : public insert_test_base<T>
+template <class T> struct insert_test2 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.insert(x.begin(), *it);
         }
     }
 };
 
-template <class T>
-struct insert_test3 : public insert_test_base<T>
+template <class T> struct insert_test3 : public insert_test_base<T>
 {
-    void run(T& x) const {
-        x.insert(this->values.begin(), this->values.end());
-    }
+    void run(T& x) const { x.insert(this->values.begin(), this->values.end()); }
 
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+    {
         test::check_equivalent_keys(x);
     }
 };
 
-template <class T>
-struct insert_test4 : public insert_test_base<T>
+template <class T> struct insert_test4 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.insert(it, test::next(it));
         }
     }
 };
 
-template <class T>
-struct insert_test_rehash1 : public insert_test_base<T>
+template <class T> struct insert_test_rehash1 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
     insert_test_rehash1() : insert_test_base<T>(1000) {}
 
-    T init() const {
+    T init() const
+    {
         using namespace std;
         typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
 
@@ -134,24 +133,24 @@ struct insert_test_rehash1 : public insert_test_base<T>
         // TODO: This doesn't really work is bucket_count is 0
         size_type bucket_count = x.bucket_count();
         size_type initial_elements = static_cast<size_type>(
-            ceil((double) bucket_count * (double) x.max_load_factor()) - 1);
+            ceil((double)bucket_count * (double)x.max_load_factor()) - 1);
         BOOST_TEST(initial_elements < this->values.size());
         x.insert(this->values.begin(),
-                test::next(this->values.begin(), initial_elements));
+            test::next(this->values.begin(), initial_elements));
         BOOST_TEST(bucket_count == x.bucket_count());
         return x;
     }
 
-    void run(T& x, strong_type& strong) const {
+    void run(T& x, strong_type& strong) const
+    {
         BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
         int count = 0;
         BOOST_DEDUCED_TYPENAME T::const_iterator pos = x.cbegin();
 
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = test::next(this->values.begin(), x.size()),
-                end = this->values.end();
-            it != end && count < 10; ++it, ++count)
-        {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = test::next(this->values.begin(), x.size()),
+                 end = this->values.end();
+             it != end && count < 10; ++it, ++count) {
             strong.store(x, test::detail::tracker.count_allocations);
             pos = x.insert(pos, *it);
         }
@@ -162,20 +161,19 @@ struct insert_test_rehash1 : public insert_test_base<T>
     }
 };
 
-template <class T>
-struct insert_test_rehash2 : public insert_test_rehash1<T>
+template <class T> struct insert_test_rehash2 : public insert_test_rehash1<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
+    void run(T& x, strong_type& strong) const
+    {
         BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
         int count = 0;
 
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = test::next(this->values.begin(), x.size()),
-                end = this->values.end();
-            it != end && count < 10; ++it, ++count)
-        {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = test::next(this->values.begin(), x.size()),
+                 end = this->values.end();
+             it != end && count < 10; ++it, ++count) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.insert(*it);
         }
@@ -186,15 +184,15 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>
     }
 };
 
-template <class T>
-struct insert_test_rehash3 : public insert_test_base<T>
+template <class T> struct insert_test_rehash3 : public insert_test_base<T>
 {
-    BOOST_DEDUCED_TYPENAME T::size_type mutable
-        rehash_bucket_count, original_bucket_count;
+    BOOST_DEDUCED_TYPENAME T::size_type mutable rehash_bucket_count,
+        original_bucket_count;
 
     insert_test_rehash3() : insert_test_base<T>(1000) {}
 
-    T init() const {
+    T init() const
+    {
         using namespace std;
         typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
 
@@ -202,78 +200,82 @@ struct insert_test_rehash3 : public insert_test_base<T>
         x.max_load_factor(0.25);
 
         original_bucket_count = x.bucket_count();
-        rehash_bucket_count = static_cast<size_type>(
-            ceil((double) original_bucket_count * (double) x.max_load_factor())) - 1;
+        rehash_bucket_count =
+            static_cast<size_type>(ceil(
+                (double)original_bucket_count * (double)x.max_load_factor())) -
+            1;
 
         size_type initial_elements =
             rehash_bucket_count > 5 ? rehash_bucket_count - 5 : 1;
 
         BOOST_TEST(initial_elements < this->values.size());
         x.insert(this->values.begin(),
-                test::next(this->values.begin(), initial_elements));
+            test::next(this->values.begin(), initial_elements));
         BOOST_TEST(original_bucket_count == x.bucket_count());
         return x;
     }
 
-    void run(T& x) const {
+    void run(T& x) const
+    {
         BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
 
         x.insert(test::next(this->values.begin(), x.size()),
-                test::next(this->values.begin(), x.size() + 20));
+            test::next(this->values.begin(), x.size() + 20));
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
         BOOST_TEST(x.bucket_count() != bucket_count);
     }
 
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
-        if(x.size() < rehash_bucket_count) {
-            //BOOST_TEST(x.bucket_count() == original_bucket_count);
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+    {
+        if (x.size() < rehash_bucket_count) {
+            // BOOST_TEST(x.bucket_count() == original_bucket_count);
         }
         test::check_equivalent_keys(x);
     }
 };
 
-#define BASIC_TESTS \
-    (insert_test1)(insert_test2)(insert_test3)(insert_test4) \
-    (insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
+#define BASIC_TESTS                                                            \
+    (insert_test1)(insert_test2)(insert_test3)(insert_test4)(                  \
+        insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#define ALL_TESTS (emplace_test1)BASIC_TESTS
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) &&                              \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#define ALL_TESTS (emplace_test1) BASIC_TESTS
 #else
 #define ALL_TESTS BASIC_TESTS
 #endif
 
 EXCEPTION_TESTS(ALL_TESTS, CONTAINER_SEQ)
 
-template <class T>
-struct pair_emplace_test1 : public insert_test_base<T>
+template <class T> struct pair_emplace_test1 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(it->first),
-                boost::make_tuple(it->second));
+                boost::make_tuple(it->first), boost::make_tuple(it->second));
         }
     }
 };
 
-template <class T>
-struct pair_emplace_test2 : public insert_test_base<T>
+template <class T> struct pair_emplace_test2 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x.emplace(boost::unordered::piecewise_construct,
                 boost::make_tuple(it->first),
@@ -284,16 +286,16 @@ struct pair_emplace_test2 : public insert_test_base<T>
 
 EXCEPTION_TESTS((pair_emplace_test1)(pair_emplace_test2), CONTAINER_PAIR_SEQ)
 
-template <class T>
-struct index_insert_test1 : public insert_test_base<T>
+template <class T> struct index_insert_test1 : public insert_test_base<T>
 {
     typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
 
-    void run(T& x, strong_type& strong) const {
-        for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = this->values.begin(), end = this->values.end();
-            it != end; ++it)
-        {
+    void run(T& x, strong_type& strong) const
+    {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+                 it = this->values.begin(),
+                 end = this->values.end();
+             it != end; ++it) {
             strong.store(x, test::detail::tracker.count_allocations);
             x[it->first];
         }
diff --git a/test/exception/move_assign_exception_tests.cpp b/test/exception/move_assign_exception_tests.cpp
index 2a2f70ee..9a8d122b 100644
--- a/test/exception/move_assign_exception_tests.cpp
+++ b/test/exception/move_assign_exception_tests.cpp
@@ -5,31 +5,30 @@
 
 #include "./containers.hpp"
 
-#include <iostream>
-#include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include <iostream>
 
 #if defined(BOOST_MSVC)
-#pragma warning(disable:4512) // move_assignment operator could not be generated
+#pragma warning(                                                               \
+    disable : 4512) // move_assignment operator could not be generated
 #endif
 
 test::seed_t initialize_seed(12847);
 
-template <class T>
-struct move_assign_base : public test::exception_base
+template <class T> struct move_assign_base : public test::exception_base
 {
     test::random_values<T> x_values, y_values;
-    T x,y;
+    T x, y;
 
     typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
     typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
-    move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        x_values(),
-        y_values(),
-        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
+    move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
+        : x_values(), y_values(),
+          x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
+          y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
     {
         x.max_load_factor(mlf1);
         y.max_load_factor(mlf2);
@@ -37,7 +36,8 @@ struct move_assign_base : public test::exception_base
 
     typedef T data_type;
     T init() const { return T(x); }
-    void run(T& x1) const {
+    void run(T& x1) const
+    {
         test::exceptions_enable disable_exceptions(false);
         T y1 = y;
         disable_exceptions.release();
@@ -58,12 +58,11 @@ struct move_assign_base : public test::exception_base
     }
 };
 
-template <class T>
-struct move_assign_values : move_assign_base<T>
+template <class T> struct move_assign_values : move_assign_base<T>
 {
-    move_assign_values(unsigned int count1, unsigned int count2,
-            int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        move_assign_base<T>(tag1, tag2, mlf1, mlf2)
+    move_assign_values(unsigned int count1, unsigned int count2, int tag1,
+        int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
+        : move_assign_base<T>(tag1, tag2, mlf1, mlf2)
     {
         this->x_values.fill(count1);
         this->y_values.fill(count2);
@@ -72,47 +71,39 @@ struct move_assign_values : move_assign_base<T>
     }
 };
 
-template <class T>
-struct move_assign_test1 : move_assign_values<T>
+template <class T> struct move_assign_test1 : move_assign_values<T>
 {
     move_assign_test1() : move_assign_values<T>(0, 0, 0, 0) {}
 };
 
-template <class T>
-struct move_assign_test2 : move_assign_values<T>
+template <class T> struct move_assign_test2 : move_assign_values<T>
 {
     move_assign_test2() : move_assign_values<T>(60, 0, 0, 0) {}
 };
 
-template <class T>
-struct move_assign_test3 : move_assign_values<T>
+template <class T> struct move_assign_test3 : move_assign_values<T>
 {
     move_assign_test3() : move_assign_values<T>(0, 60, 0, 0) {}
 };
 
-template <class T>
-struct move_assign_test4 : move_assign_values<T>
+template <class T> struct move_assign_test4 : move_assign_values<T>
 {
     move_assign_test4() : move_assign_values<T>(10, 10, 1, 2) {}
 };
 
-template <class T>
-struct move_assign_test4a : move_assign_values<T>
+template <class T> struct move_assign_test4a : move_assign_values<T>
 {
     move_assign_test4a() : move_assign_values<T>(10, 100, 1, 2) {}
 };
 
-template <class T>
-struct move_assign_test5 : move_assign_values<T>
+template <class T> struct move_assign_test5 : move_assign_values<T>
 {
     move_assign_test5() : move_assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
 };
 
-template <class T>
-struct equivalent_test1 : move_assign_base<T>
+template <class T> struct equivalent_test1 : move_assign_base<T>
 {
-    equivalent_test1() :
-        move_assign_base<T>(0, 0)
+    equivalent_test1() : move_assign_base<T>(0, 0)
     {
         test::random_values<T> x_values2(10);
         this->x_values.insert(x_values2.begin(), x_values2.end());
@@ -125,8 +116,8 @@ struct equivalent_test1 : move_assign_base<T>
     }
 };
 
-EXCEPTION_TESTS(
-    (move_assign_test1)(move_assign_test2)(move_assign_test3)(move_assign_test4)(move_assign_test4a)(move_assign_test5)
-    (equivalent_test1),
+EXCEPTION_TESTS((move_assign_test1)(move_assign_test2)(move_assign_test3)(
+                    move_assign_test4)(move_assign_test4a)(move_assign_test5)(
+                    equivalent_test1),
     CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/exception/rehash_exception_tests.cpp b/test/exception/rehash_exception_tests.cpp
index 46c70504..a65ebae9 100644
--- a/test/exception/rehash_exception_tests.cpp
+++ b/test/exception/rehash_exception_tests.cpp
@@ -5,76 +5,72 @@
 
 #include "./containers.hpp"
 
-#include <string>
-#include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
 #include "../helpers/strong.hpp"
+#include <string>
 
 #include <iostream>
 
 test::seed_t initialize_seed(3298597);
 
-template <class T>
-struct rehash_test_base : public test::exception_base
+template <class T> struct rehash_test_base : public test::exception_base
 {
     test::random_values<T> values;
     unsigned int n;
     rehash_test_base(unsigned int count = 100, unsigned int n_ = 0)
         : values(count), n(n_)
-    {}
+    {
+    }
 
     typedef T data_type;
     typedef test::strong<T> strong_type;
 
-    data_type init() const {
+    data_type init() const
+    {
         T x(values.begin(), values.end(), n);
         return x;
     }
 
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x,
-        strong_type const& strong) const
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(
+        T const& x, strong_type const& strong) const
     {
         std::string scope(test::scope);
 
-        if(scope.find("hash::operator()") == std::string::npos &&
-                scope.find("equal_to::operator()") == std::string::npos &&
-                scope != "operator==(object, object)")
+        if (scope.find("hash::operator()") == std::string::npos &&
+            scope.find("equal_to::operator()") == std::string::npos &&
+            scope != "operator==(object, object)")
             strong.test(x);
 
         test::check_equivalent_keys(x);
     }
 };
 
-template <class T>
-struct rehash_test0 : rehash_test_base<T>
+template <class T> struct rehash_test0 : rehash_test_base<T>
 {
     rehash_test0() : rehash_test_base<T>(0) {}
     void run(T& x) const { x.rehash(0); }
 };
 
-template <class T>
-struct rehash_test1 : rehash_test_base<T>
+template <class T> struct rehash_test1 : rehash_test_base<T>
 {
     rehash_test1() : rehash_test_base<T>(0) {}
     void run(T& x) const { x.rehash(200); }
 };
 
-template <class T>
-struct rehash_test2 : rehash_test_base<T>
+template <class T> struct rehash_test2 : rehash_test_base<T>
 {
     rehash_test2() : rehash_test_base<T>(0, 200) {}
     void run(T& x) const { x.rehash(0); }
 };
 
-template <class T>
-struct rehash_test3 : rehash_test_base<T>
+template <class T> struct rehash_test3 : rehash_test_base<T>
 {
     rehash_test3() : rehash_test_base<T>(10, 0) {}
     void run(T& x) const { x.rehash(200); }
 };
 
-template <class T>
-struct rehash_test4 : rehash_test_base<T>
+template <class T> struct rehash_test4 : rehash_test_base<T>
 {
     rehash_test4() : rehash_test_base<T>(10, 200) {}
     void run(T& x) const { x.rehash(0); }
diff --git a/test/exception/swap_exception_tests.cpp b/test/exception/swap_exception_tests.cpp
index e6ec789e..12ba6403 100644
--- a/test/exception/swap_exception_tests.cpp
+++ b/test/exception/swap_exception_tests.cpp
@@ -5,17 +5,16 @@
 
 #include "./containers.hpp"
 
-#include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
 
 #if defined(BOOST_MSVC)
-#pragma warning(disable:4512) // assignment operator could not be generated
+#pragma warning(disable : 4512) // assignment operator could not be generated
 #endif
 
 test::seed_t initialize_seed(9387);
 
-template <class T>
-struct self_swap_base : public test::exception_base
+template <class T> struct self_swap_base : public test::exception_base
 {
     test::random_values<T> values;
     self_swap_base(std::size_t count = 0) : values(count) {}
@@ -23,31 +22,30 @@ struct self_swap_base : public test::exception_base
     typedef T data_type;
     T init() const { return T(values.begin(), values.end()); }
     void run(T& x) const { x.swap(x); }
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+    {
         std::string scope(test::scope);
 
         // TODO: In C++11 exceptions are only allowed in the swap function.
-        BOOST_TEST(
-                scope == "hash::hash(hash)" ||
-                scope == "hash::operator=(hash)" ||
-                scope == "equal_to::equal_to(equal_to)" ||
-                scope == "equal_to::operator=(equal_to)");
+        BOOST_TEST(scope == "hash::hash(hash)" ||
+                   scope == "hash::operator=(hash)" ||
+                   scope == "equal_to::equal_to(equal_to)" ||
+                   scope == "equal_to::operator=(equal_to)");
 
         test::check_equivalent_keys(x);
     }
 };
 
-template <class T>
-struct self_swap_test1 : self_swap_base<T> {};
+template <class T> struct self_swap_test1 : self_swap_base<T>
+{
+};
 
-template <class T>
-struct self_swap_test2 : self_swap_base<T>
+template <class T> struct self_swap_test2 : self_swap_base<T>
 {
     self_swap_test2() : self_swap_base<T>(100) {}
 };
 
-template <class T>
-struct swap_base : public test::exception_base
+template <class T> struct swap_base : public test::exception_base
 {
     const test::random_values<T> x_values, y_values;
     const T initial_x, initial_y;
@@ -58,69 +56,69 @@ struct swap_base : public test::exception_base
 
     swap_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
         : x_values(count1), y_values(count2),
-        initial_x(x_values.begin(), x_values.end(), 0, hasher(tag1),
-                key_equal(tag1), allocator_type(tag1)),
-        initial_y(y_values.begin(), y_values.end(), 0, hasher(tag2),
-                key_equal(tag2), allocator_type(
-                    T::allocator_type::propagate_on_container_swap::value ?
-                        tag2 : tag1))
-    {}
+          initial_x(x_values.begin(), x_values.end(), 0, hasher(tag1),
+              key_equal(tag1), allocator_type(tag1)),
+          initial_y(
+              y_values.begin(), y_values.end(), 0, hasher(tag2),
+              key_equal(tag2),
+              allocator_type(
+                  T::allocator_type::propagate_on_container_swap::value ? tag2
+                                                                        : tag1))
+    {
+    }
 
-    struct data_type {
-        data_type(T const& x_, T const& y_)
-            : x(x_), y(y_) {}
+    struct data_type
+    {
+        data_type(T const& x_, T const& y_) : x(x_), y(y_) {}
 
         T x, y;
     };
 
     data_type init() const { return data_type(initial_x, initial_y); }
 
-    void run(data_type& d) const {
+    void run(data_type& d) const
+    {
         try {
             d.x.swap(d.y);
-        } catch (std::runtime_error) {}
+        } catch (std::runtime_error) {
+        }
     }
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const {
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const
+    {
         std::string scope(test::scope);
 
         // TODO: In C++11 exceptions are only allowed in the swap function.
-        BOOST_TEST(
-                scope == "hash::hash(hash)" ||
-                scope == "hash::operator=(hash)" ||
-                scope == "equal_to::equal_to(equal_to)" ||
-                scope == "equal_to::operator=(equal_to)");
-        
+        BOOST_TEST(scope == "hash::hash(hash)" ||
+                   scope == "hash::operator=(hash)" ||
+                   scope == "equal_to::equal_to(equal_to)" ||
+                   scope == "equal_to::operator=(equal_to)");
+
         test::check_equivalent_keys(d.x);
         test::check_equivalent_keys(d.y);
     }
 };
 
-template <class T>
-struct swap_test1 : swap_base<T>
+template <class T> struct swap_test1 : swap_base<T>
 {
     swap_test1() : swap_base<T>(0, 0, 0, 0) {}
 };
 
-template <class T>
-struct swap_test2 : swap_base<T>
+template <class T> struct swap_test2 : swap_base<T>
 {
-    swap_test2() : swap_base<T>(60, 0, 0, 0) {}    
+    swap_test2() : swap_base<T>(60, 0, 0, 0) {}
 };
 
-template <class T>
-struct swap_test3 : swap_base<T>
+template <class T> struct swap_test3 : swap_base<T>
 {
-    swap_test3() : swap_base<T>(0, 60, 0, 0) {}    
+    swap_test3() : swap_base<T>(0, 60, 0, 0) {}
 };
 
-template <class T>
-struct swap_test4 : swap_base<T>
+template <class T> struct swap_test4 : swap_base<T>
 {
     swap_test4() : swap_base<T>(10, 10, 1, 2) {}
 };
 
-EXCEPTION_TESTS(
-    (self_swap_test1)(self_swap_test2)
-    (swap_test1)(swap_test2)(swap_test3)(swap_test4),
+EXCEPTION_TESTS((self_swap_test1)(self_swap_test2)(swap_test1)(swap_test2)(
+                    swap_test3)(swap_test4),
     CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/helpers/check_return_type.hpp b/test/helpers/check_return_type.hpp
index b73f9869..83a2d7f8 100644
--- a/test/helpers/check_return_type.hpp
+++ b/test/helpers/check_return_type.hpp
@@ -7,32 +7,27 @@
 #define BOOST_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER
 
 #include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
 
-namespace test
+namespace test {
+template <class T1> struct check_return_type
 {
-    template <class T1>
-    struct check_return_type
+    template <class T2> static void equals(T2)
     {
-        template <class T2>
-        static void equals(T2)
-        {
-            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
-        }
+        BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
+    }
 
-        template <class T2>
-        static void equals_ref(T2&)
-        {
-            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
-        }
+    template <class T2> static void equals_ref(T2&)
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
+    }
 
-        template <class T2>
-        static void convertible(T2)
-        {
-            BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
-        }
-    };
+    template <class T2> static void convertible(T2)
+    {
+        BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
+    }
+};
 }
 
 #endif
diff --git a/test/helpers/count.hpp b/test/helpers/count.hpp
index 69004dcf..c432fd1f 100644
--- a/test/helpers/count.hpp
+++ b/test/helpers/count.hpp
@@ -10,77 +10,81 @@
 #include <iostream>
 
 namespace test {
-    struct object_count {
-        int instances;
-        int constructions;
+struct object_count
+{
+    int instances;
+    int constructions;
 
-        object_count() : instances(0), constructions(0) {}
-        void reset() { *this = object_count(); }
+    object_count() : instances(0), constructions(0) {}
+    void reset() { *this = object_count(); }
 
-        void construct() {
-            ++instances;
-            ++constructions;
-        }
-
-        void destruct() {
-            if(instances == 0) {
-                BOOST_ERROR("Unbalanced constructions.");
-            }
-            else {
-                --instances;
-            }
-        }
-
-        bool operator==(object_count const& x) const {
-            return instances == x.instances &&
-                constructions == x.constructions;
-        }
-
-        bool operator!=(object_count const& x) const {
-            return !(*this == x);
-        }
-        
-        friend std::ostream& operator<<(std::ostream& out,
-            object_count const& c)
-        {
-            out
-                << "[instances: "
-                << c.instances
-                << ", constructions: "
-                << c.constructions
-                << "]";
-            return out;
-        }
-    };
-
-    // This won't be a problem as I'm only using a single compile unit
-    // in each test (this is actually require by the minimal test
-    // framework).
-    // 
-    // boostinspect:nounnamed
-    namespace {
-        object_count global_object_count;
-    }
-    
-    struct counted_object
+    void construct()
     {
-        counted_object() { global_object_count.construct(); }
-        counted_object(counted_object const&) { global_object_count.construct(); }
-        ~counted_object() { global_object_count.destruct(); }
-    };
+        ++instances;
+        ++constructions;
+    }
 
-    struct check_instances {
-        int instances_;
-        int constructions_;
-        
-        check_instances() :
-            instances_(global_object_count.instances),
-            constructions_(global_object_count.constructions) {}
-        ~check_instances() { BOOST_TEST(global_object_count.instances == instances_); }
+    void destruct()
+    {
+        if (instances == 0) {
+            BOOST_ERROR("Unbalanced constructions.");
+        } else {
+            --instances;
+        }
+    }
 
-        int instances() const { return global_object_count.instances - instances_; }
-        int constructions() const { return global_object_count.constructions - constructions_; }
-    };
+    bool operator==(object_count const& x) const
+    {
+        return instances == x.instances && constructions == x.constructions;
+    }
+
+    bool operator!=(object_count const& x) const { return !(*this == x); }
+
+    friend std::ostream& operator<<(std::ostream& out, object_count const& c)
+    {
+        out << "[instances: " << c.instances
+            << ", constructions: " << c.constructions << "]";
+        return out;
+    }
+};
+
+// This won't be a problem as I'm only using a single compile unit
+// in each test (this is actually require by the minimal test
+// framework).
+//
+// boostinspect:nounnamed
+namespace {
+object_count global_object_count;
+}
+
+struct counted_object
+{
+    counted_object() { global_object_count.construct(); }
+    counted_object(counted_object const&) { global_object_count.construct(); }
+    ~counted_object() { global_object_count.destruct(); }
+};
+
+struct check_instances
+{
+    int instances_;
+    int constructions_;
+
+    check_instances()
+        : instances_(global_object_count.instances),
+          constructions_(global_object_count.constructions)
+    {
+    }
+    ~check_instances()
+    {
+        BOOST_TEST(global_object_count.instances == instances_);
+    }
+
+    int instances() const { return global_object_count.instances - instances_; }
+    int constructions() const
+    {
+        return global_object_count.constructions - constructions_;
+    }
+};
 }
 
 #endif
diff --git a/test/helpers/equivalent.hpp b/test/helpers/equivalent.hpp
index 61b91538..4bb4137f 100644
--- a/test/helpers/equivalent.hpp
+++ b/test/helpers/equivalent.hpp
@@ -6,88 +6,89 @@
 #if !defined(BOOST_UNORDERED_TESTS_EQUIVALENT_HEADER)
 #define BOOST_UNORDERED_TESTS_EQUIVALENT_HEADER
 
-#include <boost/unordered_map.hpp>
-#include <boost/unordered_set.hpp>
-#include <algorithm>
-#include "./metafunctions.hpp"
 #include "./fwd.hpp"
 #include "./list.hpp"
+#include "./metafunctions.hpp"
+#include <algorithm>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
 
-namespace test
+namespace test {
+template <class T1, class T2>
+bool equivalent_impl(T1 const& x, T2 const& y, base_type)
 {
+    return x == y;
+}
+
+template <class T>
+bool equivalent_impl(boost::hash<T> const&, boost::hash<T> const&, derived_type)
+{
+    return true;
+}
+
+template <class T>
+bool equivalent_impl(
+    std::equal_to<T> const&, std::equal_to<T> const&, derived_type)
+{
+    return true;
+}
+
+template <class T1, class T2, class T3, class T4>
+bool equivalent_impl(
+    std::pair<T1, T2> const& x1, std::pair<T3, T4> const& x2, derived_type)
+{
+    return equivalent_impl(x1.first, x2.first, derived) &&
+           equivalent_impl(x1.second, x2.second, derived);
+}
+
+struct equivalent_type
+{
+    equivalent_type() {}
+
     template <class T1, class T2>
-    bool equivalent_impl(T1 const& x, T2 const& y, base_type) {
-        return x == y;
-    }
-
-    template <class T>
-    bool equivalent_impl(boost::hash<T> const&, boost::hash<T> const&,
-        derived_type)
+    bool operator()(T1 const& x, T2 const& y) const
     {
-        return true;
+        return equivalent_impl(x, y, derived);
     }
+};
 
-    template <class T>
-    bool equivalent_impl(std::equal_to<T> const&, std::equal_to<T> const&,
-        derived_type)
+const equivalent_type equivalent;
+
+template <class Container> class unordered_equivalence_tester
+{
+    BOOST_DEDUCED_TYPENAME Container::size_type size_;
+    BOOST_DEDUCED_TYPENAME Container::hasher hasher_;
+    BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_;
+    float max_load_factor_;
+
+    typedef test::list<BOOST_DEDUCED_TYPENAME Container::value_type> value_list;
+    value_list values_;
+
+  public:
+    unordered_equivalence_tester(Container const& x)
+        : size_(x.size()), hasher_(x.hash_function()), key_equal_(x.key_eq()),
+          max_load_factor_(x.max_load_factor()), values_(x.begin(), x.end())
     {
-        return true;
+        values_.sort();
     }
 
-    template <class T1, class T2, class T3, class T4>
-    bool equivalent_impl(std::pair<T1, T2> const& x1,
-            std::pair<T3, T4> const& x2, derived_type) {
-        return equivalent_impl(x1.first, x2.first, derived) &&
-            equivalent_impl(x1.second, x2.second, derived);
-    }
-
-    struct equivalent_type {
-        equivalent_type() {}
-
-        template <class T1, class T2>
-        bool operator()(T1 const& x, T2 const& y) const {
-            return equivalent_impl(x, y, derived);
-        }
-    };
-
-    const equivalent_type equivalent;
-
-    template <class Container>
-    class unordered_equivalence_tester
+    bool operator()(Container const& x) const
     {
-        BOOST_DEDUCED_TYPENAME Container::size_type size_;
-        BOOST_DEDUCED_TYPENAME Container::hasher hasher_;
-        BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_;
-        float max_load_factor_;
-
-        typedef test::list<BOOST_DEDUCED_TYPENAME Container::value_type>
-            value_list;
-        value_list values_;
-    public:
-        unordered_equivalence_tester(Container const &x)
-            : size_(x.size()),
-            hasher_(x.hash_function()), key_equal_(x.key_eq()),
-            max_load_factor_(x.max_load_factor()),
-            values_(x.begin(), x.end())
-        {
-            values_.sort();
-        }
-
-        bool operator()(Container const& x) const
-        {
-            if(!((size_ == x.size()) &&
+        if (!((size_ == x.size()) &&
                 (test::equivalent(hasher_, x.hash_function())) &&
                 (test::equivalent(key_equal_, x.key_eq())) &&
                 (max_load_factor_ == x.max_load_factor()) &&
-                (values_.size() == x.size()))) return false;
+                (values_.size() == x.size())))
+            return false;
 
-            value_list copy(x.begin(), x.end());
-            copy.sort();
-            return values_ == copy;
-        }
-    private:
-        unordered_equivalence_tester();
-    };
+        value_list copy(x.begin(), x.end());
+        copy.sort();
+        return values_ == copy;
+    }
+
+  private:
+    unordered_equivalence_tester();
+};
 }
 
 #endif
diff --git a/test/helpers/exception_test.hpp b/test/helpers/exception_test.hpp
index ad7ae7ea..3bc0f734 100644
--- a/test/helpers/exception_test.hpp
+++ b/test/helpers/exception_test.hpp
@@ -6,275 +6,266 @@
 #if !defined(BOOST_UNORDERED_EXCEPTION_TEST_HEADER)
 #define BOOST_UNORDERED_EXCEPTION_TEST_HEADER
 
-#include "./test.hpp"
 #include "./count.hpp"
+#include "./test.hpp"
 
-#include <boost/preprocessor/seq/for_each_product.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
 #include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/seq/for_each_product.hpp>
 
-#   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type)             \
-        UNORDERED_AUTO_TEST(name)                                           \
-        {                                                                   \
-            test_func< type > fixture;                                      \
-            ::test::lightweight::exception_safety(                          \
-                fixture, BOOST_STRINGIZE(test_func<type>));                 \
-        }                                                                   \
+#define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type)                   \
+    UNORDERED_AUTO_TEST(name)                                                  \
+    {                                                                          \
+        test_func<type> fixture;                                               \
+        ::test::lightweight::exception_safety(                                 \
+            fixture, BOOST_STRINGIZE(test_func<type>));                        \
+    }
 
-#   define UNORDERED_EXCEPTION_TEST_CASE_REPEAT(name, test_func, n, type)   \
-        UNORDERED_AUTO_TEST(name)                                           \
-        {                                                                   \
-            for (unsigned i = 0; i < n; ++i) {                              \
-                test_func< type > fixture;                                  \
-                ::test::lightweight::exception_safety(                      \
-                    fixture, BOOST_STRINGIZE(test_func<type>));             \
-            }                                                               \
-        }                                                                   \
+#define UNORDERED_EXCEPTION_TEST_CASE_REPEAT(name, test_func, n, type)         \
+    UNORDERED_AUTO_TEST(name)                                                  \
+    {                                                                          \
+        for (unsigned i = 0; i < n; ++i) {                                     \
+            test_func<type> fixture;                                           \
+            ::test::lightweight::exception_safety(                             \
+                fixture, BOOST_STRINGIZE(test_func<type>));                    \
+        }                                                                      \
+    }
 
-
-#    define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
+#define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
 
 #define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS()
 
-#define EXCEPTION_TESTS(test_seq, param_seq)                                \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP,                       \
-        (test_seq)((1))(param_seq))
+#define EXCEPTION_TESTS(test_seq, param_seq)                                   \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                             \
+        EXCEPTION_TESTS_OP, (test_seq)((1))(param_seq))
 
-#define EXCEPTION_TESTS_REPEAT(n, test_seq, param_seq)                      \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP,                       \
-        (test_seq)((n))(param_seq))
+#define EXCEPTION_TESTS_REPEAT(n, test_seq, param_seq)                         \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                             \
+        EXCEPTION_TESTS_OP, (test_seq)((n))(param_seq))
 
-#define EXCEPTION_TESTS_OP(r, product)                                      \
-    UNORDERED_EXCEPTION_TEST_CASE_REPEAT(                                   \
-        BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product),                         \
-            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(2, product))                  \
-        ),                                                                  \
-        BOOST_PP_SEQ_ELEM(0, product),                                      \
-        BOOST_PP_SEQ_ELEM(1, product),                                      \
-        BOOST_PP_SEQ_ELEM(2, product)                                       \
-    )                                                                       \
+#define EXCEPTION_TESTS_OP(r, product)                                         \
+    UNORDERED_EXCEPTION_TEST_CASE_REPEAT(                                      \
+        BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product),                            \
+            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(2, product))),                   \
+        BOOST_PP_SEQ_ELEM(0, product), BOOST_PP_SEQ_ELEM(1, product),          \
+        BOOST_PP_SEQ_ELEM(2, product))
 
-#define UNORDERED_SCOPE(scope_name)                                         \
-    for(::test::scope_guard unordered_test_guard(                           \
-            BOOST_STRINGIZE(scope_name));                                   \
-        !unordered_test_guard.dismissed();                                  \
-        unordered_test_guard.dismiss())                                     \
+#define UNORDERED_SCOPE(scope_name)                                            \
+    for (::test::scope_guard unordered_test_guard(                             \
+             BOOST_STRINGIZE(scope_name));                                     \
+         !unordered_test_guard.dismissed(); unordered_test_guard.dismiss())
 
-#define UNORDERED_EPOINT(name)                                              \
-    if(::test::exceptions_enabled) {                                        \
-        UNORDERED_EPOINT_IMPL(name);                                        \
-    }                                                                       \
+#define UNORDERED_EPOINT(name)                                                 \
+    if (::test::exceptions_enabled) {                                          \
+        UNORDERED_EPOINT_IMPL(name);                                           \
+    }
 
-#define ENABLE_EXCEPTIONS                                                   \
-    ::test::exceptions_enable BOOST_PP_CAT(                                 \
-        ENABLE_EXCEPTIONS_, __LINE__)(true)                                 \
+#define ENABLE_EXCEPTIONS                                                      \
+    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
 
-#define DISABLE_EXCEPTIONS                                                  \
-    ::test::exceptions_enable BOOST_PP_CAT(                                 \
-        ENABLE_EXCEPTIONS_, __LINE__)(false)                                \
+#define DISABLE_EXCEPTIONS                                                     \
+    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
 
 namespace test {
-    static char const* scope = "";
-    bool exceptions_enabled = false;
+static char const* scope = "";
+bool exceptions_enabled = false;
 
-    class scope_guard {
-        scope_guard& operator=(scope_guard const&);
-        scope_guard(scope_guard const&);
+class scope_guard
+{
+    scope_guard& operator=(scope_guard const&);
+    scope_guard(scope_guard const&);
 
-        char const* old_scope_;
-        char const* scope_;
-        bool dismissed_;
-    public:
-        scope_guard(char const* name)
-            : old_scope_(scope),
-            scope_(name),
-            dismissed_(false)
-        {
-            scope = scope_;
+    char const* old_scope_;
+    char const* scope_;
+    bool dismissed_;
+
+  public:
+    scope_guard(char const* name)
+        : old_scope_(scope), scope_(name), dismissed_(false)
+    {
+        scope = scope_;
+    }
+
+    ~scope_guard()
+    {
+        if (dismissed_)
+            scope = old_scope_;
+    }
+
+    void dismiss() { dismissed_ = true; }
+
+    bool dismissed() const { return dismissed_; }
+};
+
+class exceptions_enable
+{
+    exceptions_enable& operator=(exceptions_enable const&);
+    exceptions_enable(exceptions_enable const&);
+
+    bool old_value_;
+    bool released_;
+
+  public:
+    exceptions_enable(bool enable)
+        : old_value_(exceptions_enabled), released_(false)
+    {
+        exceptions_enabled = enable;
+    }
+
+    ~exceptions_enable()
+    {
+        if (!released_) {
+            exceptions_enabled = old_value_;
+            released_ = true;
         }
+    }
 
-        ~scope_guard() {
-            if(dismissed_) scope = old_scope_;
+    void release()
+    {
+        if (!released_) {
+            exceptions_enabled = old_value_;
+            released_ = true;
         }
+    }
+};
 
-        void dismiss() {
-            dismissed_ = true;
-        }
-
-        bool dismissed() const {
-            return dismissed_;
-        }
+struct exception_base
+{
+    struct data_type
+    {
     };
-
-    class exceptions_enable
+    struct strong_type
     {
-        exceptions_enable& operator=(exceptions_enable const&);
-        exceptions_enable(exceptions_enable const&);
-
-        bool old_value_;
-        bool released_;
-    public:
-        exceptions_enable(bool enable)
-            : old_value_(exceptions_enabled), released_(false)
-        {
-            exceptions_enabled = enable;
-        }
-
-        ~exceptions_enable()
-        {
-            if (!released_) {
-                exceptions_enabled = old_value_;
-                released_ = true;
-            }
-        }
-
-        void release()
-        {
-            if (!released_) {
-                exceptions_enabled = old_value_;
-                released_ = true;
-            }
-        }
+        template <class T> void store(T const&) {}
+        template <class T> void test(T const&) const {}
     };
+    data_type init() const { return data_type(); }
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION() const {}
+};
 
-    struct exception_base {
-        struct data_type {};
-        struct strong_type {
-            template <class T> void store(T const&) {}
-            template <class T> void test(T const&) const {}
-        };
-        data_type init() const { return data_type(); }
-        void check BOOST_PREVENT_MACRO_SUBSTITUTION() const {}
-    };
+template <class T, class P1, class P2, class T2>
+inline void call_ignore_extra_parameters(
+    void (T::*fn)() const, T2 const& obj, P1&, P2&)
+{
+    (obj.*fn)();
+}
 
-    template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(
-            void (T::*fn)() const, T2 const& obj,
-            P1&, P2&)
+template <class T, class P1, class P2, class T2>
+inline void call_ignore_extra_parameters(
+    void (T::*fn)(P1&) const, T2 const& obj, P1& p1, P2&)
+{
+    (obj.*fn)(p1);
+}
+
+template <class T, class P1, class P2, class T2>
+inline void call_ignore_extra_parameters(
+    void (T::*fn)(P1&, P2&) const, T2 const& obj, P1& p1, P2& p2)
+{
+    (obj.*fn)(p1, p2);
+}
+
+template <class T> T const& constant(T const& x) { return x; }
+
+template <class Test> class test_runner
+{
+    Test const& test_;
+    bool exception_in_check_;
+
+    test_runner(test_runner const&);
+    test_runner& operator=(test_runner const&);
+
+  public:
+    test_runner(Test const& t) : test_(t), exception_in_check_(false) {}
+    void run()
     {
-        (obj.*fn)();
-    }
-
-    template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(
-            void (T::*fn)(P1&) const, T2 const& obj,
-            P1& p1, P2&)
-    {
-        (obj.*fn)(p1);
-    }
-
-    template <class T, class P1, class P2, class T2>
-    inline void call_ignore_extra_parameters(
-            void (T::*fn)(P1&, P2&) const, T2 const& obj,
-            P1& p1, P2& p2)
-    {
-        (obj.*fn)(p1, p2);
-    }
-
-    template <class T>
-    T const& constant(T const& x) {
-        return x;
-    }
-
-    template <class Test>
-    class test_runner
-    {
-        Test const& test_;
-        bool exception_in_check_;
-
-        test_runner(test_runner const&);
-        test_runner& operator=(test_runner const&);
-    public:
-        test_runner(Test const& t) : test_(t), exception_in_check_(false) {}
-        void run() {
-            DISABLE_EXCEPTIONS;
-            test::check_instances check;
-            test::scope = "";
-            BOOST_DEDUCED_TYPENAME Test::data_type x(test_.init());
-            BOOST_DEDUCED_TYPENAME Test::strong_type strong;
-            strong.store(x);
+        DISABLE_EXCEPTIONS;
+        test::check_instances check;
+        test::scope = "";
+        BOOST_DEDUCED_TYPENAME Test::data_type x(test_.init());
+        BOOST_DEDUCED_TYPENAME Test::strong_type strong;
+        strong.store(x);
+        try {
+            ENABLE_EXCEPTIONS;
+            call_ignore_extra_parameters<Test,
+                BOOST_DEDUCED_TYPENAME Test::data_type,
+                BOOST_DEDUCED_TYPENAME Test::strong_type>(
+                &Test::run, test_, x, strong);
+        } catch (...) {
             try {
-                ENABLE_EXCEPTIONS;
-                call_ignore_extra_parameters<
-                    Test,
-                    BOOST_DEDUCED_TYPENAME Test::data_type,
-                    BOOST_DEDUCED_TYPENAME Test::strong_type
-                >(&Test::run, test_, x, strong);
-            }
-            catch(...) {
-                try {
-                    DISABLE_EXCEPTIONS;
-                    call_ignore_extra_parameters<
-                        Test,
-                        BOOST_DEDUCED_TYPENAME Test::data_type const,
-                        BOOST_DEDUCED_TYPENAME Test::strong_type const
-                    >(&Test::check, test_, constant(x), constant(strong));
-                } catch(...) {
-                    exception_in_check_ = true;
-                }
-                throw;
+                DISABLE_EXCEPTIONS;
+                call_ignore_extra_parameters<Test,
+                    BOOST_DEDUCED_TYPENAME Test::data_type const,
+                    BOOST_DEDUCED_TYPENAME Test::strong_type const>(
+                    &Test::check, test_, constant(x), constant(strong));
+            } catch (...) {
+                exception_in_check_ = true;
             }
+            throw;
         }
-        void end() {
-            if (exception_in_check_) {
-                BOOST_ERROR("Unexcpected exception in test_runner check call.");
-            }
+    }
+    void end()
+    {
+        if (exception_in_check_) {
+            BOOST_ERROR("Unexcpected exception in test_runner check call.");
         }
-    };
+    }
+};
 
-    // Quick exception testing based on lightweight test
+// Quick exception testing based on lightweight test
 
-    namespace lightweight {
-        static int iteration;
-        static int count;
+namespace lightweight {
+static int iteration;
+static int count;
 
-        struct test_exception {
-            char const* name;
-            test_exception(char const* n) : name(n) {}
-        };
+struct test_exception
+{
+    char const* name;
+    test_exception(char const* n) : name(n) {}
+};
 
-        struct test_failure {
-        };
+struct test_failure
+{
+};
 
-        void epoint(char const* name) {
-            ++count;
-            if(count == iteration) {
-                throw test_exception(name);
-            }
-        }
-
-        template <class Test>
-        void exception_safety(Test const& f, char const* /*name*/) {
-            test_runner<Test> runner(f);
-
-            iteration = 0;
-            bool success = false;
-            char const* error_msg = 0;
-            do {
-                ++iteration;
-                count = 0;
-
-                try {
-                    runner.run();
-                    success = true;
-                }
-                catch(test_failure) {
-                    error_msg = "test_failure caught.";
-                    break;
-                }
-                catch(test_exception) {
-                    continue;
-                }
-                catch(...) {
-                    error_msg = "Unexpected exception.";
-                    break;
-                }
-            } while(!success);
-
-            if (error_msg) { BOOST_ERROR(error_msg); }
-            runner.end();
-        }
+void epoint(char const* name)
+{
+    ++count;
+    if (count == iteration) {
+        throw test_exception(name);
     }
 }
 
+template <class Test> void exception_safety(Test const& f, char const* /*name*/)
+{
+    test_runner<Test> runner(f);
+
+    iteration = 0;
+    bool success = false;
+    char const* error_msg = 0;
+    do {
+        ++iteration;
+        count = 0;
+
+        try {
+            runner.run();
+            success = true;
+        } catch (test_failure) {
+            error_msg = "test_failure caught.";
+            break;
+        } catch (test_exception) {
+            continue;
+        } catch (...) {
+            error_msg = "Unexpected exception.";
+            break;
+        }
+    } while (!success);
+
+    if (error_msg) {
+        BOOST_ERROR(error_msg);
+    }
+    runner.end();
+}
+}
+}
+
 #endif
diff --git a/test/helpers/fwd.hpp b/test/helpers/fwd.hpp
index 14476dda..29b2e8cc 100644
--- a/test/helpers/fwd.hpp
+++ b/test/helpers/fwd.hpp
@@ -8,23 +8,25 @@
 
 #include <string>
 
-namespace test
+namespace test {
+typedef enum {
+    default_generator,
+    generate_collisions,
+    limited_range
+} random_generator;
+
+int generate(int const*, random_generator);
+char generate(char const*, random_generator);
+signed char generate(signed char const*, random_generator);
+std::string generate(std::string const*, random_generator);
+float generate(float const*, random_generator);
+
+struct base_type
 {
-    typedef enum {
-        default_generator,
-        generate_collisions,
-        limited_range
-    } random_generator;
-
-    int generate(int const*, random_generator);
-    char generate(char const*, random_generator);
-    signed char generate(signed char const*, random_generator);
-    std::string generate(std::string const*, random_generator);
-    float generate(float const*, random_generator);
-
-    struct base_type {} base;
-    struct derived_type : base_type {} derived;
+} base;
+struct derived_type : base_type
+{
+} derived;
 }
 
 #endif
-
diff --git a/test/helpers/generators.hpp b/test/helpers/generators.hpp
index 3265a77b..8d5abaa5 100644
--- a/test/helpers/generators.hpp
+++ b/test/helpers/generators.hpp
@@ -11,80 +11,84 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_GENERATORS_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_GENERATORS_HEADER
 
+#include "./fwd.hpp"
+#include <boost/type_traits/add_const.hpp>
+#include <cstdlib>
+#include <stdexcept>
 #include <string>
 #include <utility>
-#include <stdexcept>
-#include <cstdlib>
-#include <boost/type_traits/add_const.hpp>
-#include "./fwd.hpp"
 
-namespace test
+namespace test {
+struct seed_t
 {
-    struct seed_t {
-        seed_t(unsigned int x) {
-            using namespace std;
-            srand(x);
+    seed_t(unsigned int x)
+    {
+        using namespace std;
+        srand(x);
+    }
+};
+
+std::size_t random_value(std::size_t max)
+{
+    using namespace std;
+    return static_cast<std::size_t>(rand()) % max;
+}
+
+inline int generate(int const*, random_generator g)
+{
+    using namespace std;
+    int value = rand();
+    if (g == limited_range) {
+        value = value % 100;
+    }
+    return value;
+}
+
+inline char generate(char const*, random_generator)
+{
+    using namespace std;
+    return static_cast<char>((rand() >> 1) % (128 - 32) + 32);
+}
+
+inline signed char generate(signed char const*, random_generator)
+{
+    using namespace std;
+    return static_cast<signed char>(rand());
+}
+
+inline std::string generate(std::string const*, random_generator g)
+{
+    using namespace std;
+
+    char* char_ptr = 0;
+
+    std::string result;
+
+    if (g == limited_range) {
+        std::size_t length = test::random_value(2) + 2;
+
+        char const* strings[] = {"'vZh(3~ms", "%m", "_Y%U", "N'Y", "4,J_J"};
+        for (std::size_t i = 0; i < length; ++i) {
+            result +=
+                strings[random_value(sizeof(strings) / sizeof(strings[0]))];
         }
-    };
-
-    std::size_t random_value(std::size_t max) {
-        using namespace std;
-        return static_cast<std::size_t>(rand()) % max;
-    }
-
-    inline int generate(int const*, random_generator g)
-    {
-        using namespace std;
-        int value = rand();
-        if (g == limited_range) { value = value % 100; }
-        return value;
-    }
-
-    inline char generate(char const*, random_generator)
-    {
-        using namespace std;
-        return static_cast<char>((rand() >> 1) % (128-32) + 32);
-    }
-
-    inline signed char generate(signed char const*, random_generator)
-    {
-        using namespace std;
-        return static_cast<signed char>(rand());
-    }
-
-    inline std::string generate(std::string const*, random_generator g)
-    {
-        using namespace std;
-
-        char* char_ptr = 0;
-
-        std::string result;
-
-        if (g == limited_range) {
-            std::size_t length = test::random_value(2) + 2;
-
-            char const* strings[] = { "'vZh(3~ms", "%m", "_Y%U", "N'Y", "4,J_J" };
-            for (std::size_t i = 0; i < length; ++i) {
-                result += strings[random_value(sizeof(strings) / sizeof(strings[0]))];
-            }
+    } else {
+        std::size_t length = test::random_value(10) + 1;
+        for (std::size_t i = 0; i < length; ++i) {
+            result += generate(char_ptr, g);
         }
-        else {
-            std::size_t length = test::random_value(10) + 1;
-            for (std::size_t i = 0; i < length; ++i) {
-                result += generate(char_ptr, g);
-            }
-        }
-
-        return result;
     }
 
-    float generate(float const*, random_generator g)
-    {
-        using namespace std;
-        int x = 0;
-        int value = generate(&x, g);
-        return (float) value / (float) RAND_MAX;
-    }
+    return result;
+}
+
+float generate(float const*, random_generator g)
+{
+    using namespace std;
+    int x = 0;
+    int value = generate(&x, g);
+    return (float)value / (float)RAND_MAX;
+}
 }
 
 #endif
diff --git a/test/helpers/helpers.hpp b/test/helpers/helpers.hpp
index 96e90cdc..a1453fe5 100644
--- a/test/helpers/helpers.hpp
+++ b/test/helpers/helpers.hpp
@@ -6,58 +6,48 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_HEADER
 
-namespace test
+namespace test {
+template <class Container> struct get_key_impl
 {
-    template <class Container>
-    struct get_key_impl
+    typedef BOOST_DEDUCED_TYPENAME Container::key_type key_type;
+
+    static key_type const& get_key(key_type const& x) { return x; }
+
+    template <class T>
+    static key_type const& get_key(std::pair<key_type, T> const& x, char = 0)
     {
-        typedef BOOST_DEDUCED_TYPENAME Container::key_type key_type;
-
-        static key_type const& get_key(key_type const& x)
-        {
-            return x;
-        }
-
-        template <class T>
-        static key_type const& get_key(
-            std::pair<key_type, T> const& x, char = 0)
-        {
-            return x.first;
-        }
-
-        template <class T>
-        static key_type const& get_key(std::pair<key_type const, T> const& x,
-            unsigned char = 0)
-        {
-            return x.first;
-        }
-    };
-    
-    template <class Container, class T>
-    inline BOOST_DEDUCED_TYPENAME Container::key_type const& get_key(T const& x)
-    {
-        return get_key_impl<Container>::get_key(x);
+        return x.first;
     }
 
-    // test::next
-    //
-    // Increments an iterator by 1 or a given value.
-    // Like boost::next, but simpler and slower.
-
-    template <typename Iterator>
-    Iterator next(Iterator it)
+    template <class T>
+    static key_type const& get_key(
+        std::pair<key_type const, T> const& x, unsigned char = 0)
     {
-        return ++it;
+        return x.first;
     }
+};
 
-    template <typename Iterator, typename IntType>
-    Iterator next(Iterator it, IntType x)
-    {
-        for(; x > 0; --x) {
-            ++it;
-        }
-        return it;
+template <class Container, class T>
+inline BOOST_DEDUCED_TYPENAME Container::key_type const& get_key(T const& x)
+{
+    return get_key_impl<Container>::get_key(x);
+}
+
+// test::next
+//
+// Increments an iterator by 1 or a given value.
+// Like boost::next, but simpler and slower.
+
+template <typename Iterator> Iterator next(Iterator it) { return ++it; }
+
+template <typename Iterator, typename IntType>
+Iterator next(Iterator it, IntType x)
+{
+    for (; x > 0; --x) {
+        ++it;
     }
+    return it;
+}
 }
 
 #endif
diff --git a/test/helpers/input_iterator.hpp b/test/helpers/input_iterator.hpp
index d3c91afb..146ec7a4 100644
--- a/test/helpers/input_iterator.hpp
+++ b/test/helpers/input_iterator.hpp
@@ -10,156 +10,164 @@
 #include <boost/iterator/iterator_traits.hpp>
 #include <iterator>
 
-namespace test
+namespace test {
+template <class Iterator> struct proxy
 {
-    template <class Iterator>
-    struct proxy
-    {
-        typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
+    typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
 
-        explicit proxy(value_type const& v) : v_(v) {}
-        proxy(proxy const& x) : v_(x.v_) {}
-        operator value_type const&() const { return v_; }
-        
-        value_type v_;
-    private:
-        proxy& operator=(proxy const&);
-    };
+    explicit proxy(value_type const& v) : v_(v) {}
+    proxy(proxy const& x) : v_(x.v_) {}
+    operator value_type const&() const { return v_; }
 
-    template <class Iterator>
-    struct input_iterator_adaptor
-        : public std::iterator<
-            std::input_iterator_tag,
-            BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
-            std::ptrdiff_t,
-            BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
-            proxy<Iterator>
-        >
-    {
-        typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
-            value_type;
-    
-        input_iterator_adaptor()
-            : base_() {}
-        explicit input_iterator_adaptor(Iterator& it)
-            : base_(&it) {}
-        proxy<Iterator> operator*() const {
-            return proxy<Iterator>(**base_);
-        }
-        value_type* operator->() const {
-            return &**base_;
-        }
-        input_iterator_adaptor& operator++() {
-            ++*base_; return *this;
-        }
-        //input_iterator_adaptor operator++(int) {
-        //}
-        bool operator==(input_iterator_adaptor const& x) const {
-            return *base_ == *x.base_;
-        }
-        bool operator!=(input_iterator_adaptor const& x) const {
-            return *base_ != *x.base_;
-        }
-    private:
-        Iterator* base_;
-    };
+    value_type v_;
 
-    template <class Iterator>
-    input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
+  private:
+    proxy& operator=(proxy const&);
+};
+
+template <class Iterator>
+struct input_iterator_adaptor
+    : public std::iterator<std::input_iterator_tag,
+          BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
+          std::ptrdiff_t,
+          BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
+          proxy<Iterator> >
+{
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
+        value_type;
+
+    input_iterator_adaptor() : base_() {}
+    explicit input_iterator_adaptor(Iterator& it) : base_(&it) {}
+    proxy<Iterator> operator*() const { return proxy<Iterator>(**base_); }
+    value_type* operator->() const { return &**base_; }
+    input_iterator_adaptor& operator++()
     {
-        return input_iterator_adaptor<Iterator>(it);
+        ++*base_;
+        return *this;
+    }
+    // input_iterator_adaptor operator++(int) {
+    //}
+    bool operator==(input_iterator_adaptor const& x) const
+    {
+        return *base_ == *x.base_;
+    }
+    bool operator!=(input_iterator_adaptor const& x) const
+    {
+        return *base_ != *x.base_;
     }
 
-    template <class Iterator>
-    struct copy_iterator_adaptor
-        : public std::iterator<
-            BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
-            BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
-            BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
-            BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
-            proxy<Iterator>
-        >
-    {
-        typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
-            value_type;
-        typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
-            difference_type;
-    
-        copy_iterator_adaptor()
-            : base_() {}
-        explicit copy_iterator_adaptor(Iterator const& it)
-            : base_(it) {}
-        value_type operator*() const {
-            return *base_;
-        }
-        value_type* operator->() const {
-            return &*base_;
-        }
-        value_type operator[](difference_type d) {
-            return base_[d];
-        }
-        copy_iterator_adaptor& operator++() {
-            ++base_; return *this;
-        }
-        copy_iterator_adaptor operator++(int) {
-            copy_iterator_adaptor tmp(*this); ++base_; return tmp;
-        }
-        copy_iterator_adaptor& operator--() {
-            --base_; return *this;
-        }
-        copy_iterator_adaptor operator--(int) {
-            copy_iterator_adaptor tmp(*this); --base_; return tmp;
-        }
-        copy_iterator_adaptor operator+=(difference_type x) {
-            base_ += x;
-            return *this;
-        }
-        copy_iterator_adaptor operator-=(difference_type x) {
-            base_ -= x;
-            return *this;
-        }
-        copy_iterator_adaptor operator+(difference_type n) {
-            return copy_iterator_adaptor(base_+n);
-        }
-        copy_iterator_adaptor operator-(difference_type n) {
-            return copy_iterator_adaptor(base_-n);
-        }
-        friend copy_iterator_adaptor operator+(
-                difference_type n, copy_iterator_adaptor x) {
-            return x+n;
-        }
-        difference_type operator-(copy_iterator_adaptor const& other) {
-            return base_-other.base_;
-        }
-        bool operator==(copy_iterator_adaptor const& x) const {
-            return base_ == x.base_;
-        }
-        bool operator!=(copy_iterator_adaptor const& x) const {
-            return base_ != x.base_;
-        }
-        bool operator<(copy_iterator_adaptor const& x) const {
-            return base_ < x.base_;
-        }
-        bool operator>(copy_iterator_adaptor const& x) const {
-            return base_ > x.base_;
-        }
-        bool operator<=(copy_iterator_adaptor const& x) const {
-            return base_ <= x.base_;
-        }
-        bool operator>=(copy_iterator_adaptor const& x) const {
-            return base_ >= x.base_;
-        }
-    private:
-        Iterator base_;
-    };
+  private:
+    Iterator* base_;
+};
 
-    template <class Iterator>
-    copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+template <class Iterator>
+input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
+{
+    return input_iterator_adaptor<Iterator>(it);
+}
+
+template <class Iterator>
+struct copy_iterator_adaptor
+    : public std::iterator<
+          BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
+          BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
+          BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
+          BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
+          proxy<Iterator> >
+{
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
+        value_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
+        difference_type;
+
+    copy_iterator_adaptor() : base_() {}
+    explicit copy_iterator_adaptor(Iterator const& it) : base_(it) {}
+    value_type operator*() const { return *base_; }
+    value_type* operator->() const { return &*base_; }
+    value_type operator[](difference_type d) { return base_[d]; }
+    copy_iterator_adaptor& operator++()
     {
-        return copy_iterator_adaptor<Iterator>(it);
+        ++base_;
+        return *this;
+    }
+    copy_iterator_adaptor operator++(int)
+    {
+        copy_iterator_adaptor tmp(*this);
+        ++base_;
+        return tmp;
+    }
+    copy_iterator_adaptor& operator--()
+    {
+        --base_;
+        return *this;
+    }
+    copy_iterator_adaptor operator--(int)
+    {
+        copy_iterator_adaptor tmp(*this);
+        --base_;
+        return tmp;
+    }
+    copy_iterator_adaptor operator+=(difference_type x)
+    {
+        base_ += x;
+        return *this;
+    }
+    copy_iterator_adaptor operator-=(difference_type x)
+    {
+        base_ -= x;
+        return *this;
+    }
+    copy_iterator_adaptor operator+(difference_type n)
+    {
+        return copy_iterator_adaptor(base_ + n);
+    }
+    copy_iterator_adaptor operator-(difference_type n)
+    {
+        return copy_iterator_adaptor(base_ - n);
+    }
+    friend copy_iterator_adaptor operator+(
+        difference_type n, copy_iterator_adaptor x)
+    {
+        return x + n;
+    }
+    difference_type operator-(copy_iterator_adaptor const& other)
+    {
+        return base_ - other.base_;
+    }
+    bool operator==(copy_iterator_adaptor const& x) const
+    {
+        return base_ == x.base_;
+    }
+    bool operator!=(copy_iterator_adaptor const& x) const
+    {
+        return base_ != x.base_;
+    }
+    bool operator<(copy_iterator_adaptor const& x) const
+    {
+        return base_ < x.base_;
+    }
+    bool operator>(copy_iterator_adaptor const& x) const
+    {
+        return base_ > x.base_;
+    }
+    bool operator<=(copy_iterator_adaptor const& x) const
+    {
+        return base_ <= x.base_;
+    }
+    bool operator>=(copy_iterator_adaptor const& x) const
+    {
+        return base_ >= x.base_;
     }
 
+  private:
+    Iterator base_;
+};
+
+template <class Iterator>
+copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+{
+    return copy_iterator_adaptor<Iterator>(it);
+}
 }
 
 #endif
-
diff --git a/test/helpers/invariants.hpp b/test/helpers/invariants.hpp
index 5c2048b7..ffc5de4e 100644
--- a/test/helpers/invariants.hpp
+++ b/test/helpers/invariants.hpp
@@ -9,114 +9,113 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_INVARIANT_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_INVARIANT_HEADER
 
-#include <set>
-#include <cmath>
-#include "./metafunctions.hpp"
 #include "./helpers.hpp"
+#include "./metafunctions.hpp"
+#include <cmath>
+#include <set>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4127)   // conditional expression is constant
-#pragma warning(disable:4267)   // conversion from 'size_t' to 'unsigned int',
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4267) // conversion from 'size_t' to 'unsigned int',
                                 // possible loss of data
 #endif
 
-namespace test
+namespace test {
+template <class X> void check_equivalent_keys(X const& x1)
 {
-    template <class X>
-    void check_equivalent_keys(X const& x1)
-    {
-        BOOST_DEDUCED_TYPENAME X::key_equal eq = x1.key_eq();
-        typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-        std::set<key_type, std::less<key_type> > found_;
+    BOOST_DEDUCED_TYPENAME X::key_equal eq = x1.key_eq();
+    typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+    std::set<key_type, std::less<key_type> > found_;
 
-        BOOST_DEDUCED_TYPENAME X::const_iterator
-            it = x1.begin(), end = x1.end();
-        BOOST_DEDUCED_TYPENAME X::size_type size = 0;
-        while(it != end) {
-            // First test that the current key has not occurred before, required
-            // to test either that keys are unique or that equivalent keys are
-            // adjacent. (6.3.1/6)
-            key_type key = get_key<X>(*it);
-            if(!found_.insert(key).second)
-                BOOST_ERROR("Elements with equivalent keys aren't adjacent.");
+    BOOST_DEDUCED_TYPENAME X::const_iterator it = x1.begin(), end = x1.end();
+    BOOST_DEDUCED_TYPENAME X::size_type size = 0;
+    while (it != end) {
+        // First test that the current key has not occurred before, required
+        // to test either that keys are unique or that equivalent keys are
+        // adjacent. (6.3.1/6)
+        key_type key = get_key<X>(*it);
+        if (!found_.insert(key).second)
+            BOOST_ERROR("Elements with equivalent keys aren't adjacent.");
 
-            // Iterate over equivalent keys, counting them.
-            unsigned int count = 0;
-            do {
-                ++it;
-                ++count;
-                ++size;
-            } while(it != end && eq(get_key<X>(*it), key));
+        // Iterate over equivalent keys, counting them.
+        unsigned int count = 0;
+        do {
+            ++it;
+            ++count;
+            ++size;
+        } while (it != end && eq(get_key<X>(*it), key));
 
-            // If the container has unique keys, test that there's only one.
-            // Since the previous test makes sure that all equivalent keys are
-            // adjacent, this is all the equivalent keys - so the test is
-            // sufficient. (6.3.1/6 again).
-            if(test::has_unique_keys<X>::value && count != 1)
-                BOOST_ERROR("Non-unique key.");
+        // If the container has unique keys, test that there's only one.
+        // Since the previous test makes sure that all equivalent keys are
+        // adjacent, this is all the equivalent keys - so the test is
+        // sufficient. (6.3.1/6 again).
+        if (test::has_unique_keys<X>::value && count != 1)
+            BOOST_ERROR("Non-unique key.");
 
-            if(x1.count(key) != count) {
-                BOOST_ERROR("Incorrect output of count.");
-                std::cerr<<x1.count(key)<<","<<count<<"\n";
-            }
-
-            // Check that the keys are in the correct bucket and are
-            // adjacent in the bucket.
-            BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
-            BOOST_DEDUCED_TYPENAME X::const_local_iterator
-                lit = x1.begin(bucket), lend = x1.end(bucket);
-            for(; lit != lend && !eq(get_key<X>(*lit), key); ++lit) continue;
-            if(lit == lend)
-                BOOST_ERROR("Unable to find element with a local_iterator");
-            unsigned int count2 = 0;
-            for(; lit != lend && eq(get_key<X>(*lit), key); ++lit) ++count2;
-            if(count != count2)
-                BOOST_ERROR("Element count doesn't match local_iterator.");
-            for(; lit != lend; ++lit) {
-                if(eq(get_key<X>(*lit), key)) {
-                    BOOST_ERROR("Non-adjacent element with equivalent key "
-                        "in bucket.");
-                    break;
-                }
-            }
-        };
-
-        // Check that size matches up.
-
-        if(x1.size() != size) {
-            BOOST_ERROR("x1.size() doesn't match actual size.");
-            std::cout<<x1.size()<<"/"<<size<<std::endl;
+        if (x1.count(key) != count) {
+            BOOST_ERROR("Incorrect output of count.");
+            std::cerr << x1.count(key) << "," << count << "\n";
         }
 
-        // Check the load factor.
-
-        float load_factor = size == 0 ? 0 :
-            static_cast<float>(size) / static_cast<float>(x1.bucket_count());
-        using namespace std;
-        if(fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
-            BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
-
-        // Check that size in the buckets matches up.
-
-        BOOST_DEDUCED_TYPENAME X::size_type bucket_size = 0;
-
-        for (BOOST_DEDUCED_TYPENAME X::size_type
-                i = 0; i < x1.bucket_count(); ++i)
-        {
-            for (BOOST_DEDUCED_TYPENAME X::const_local_iterator
-                    begin2 = x1.begin(i), end2 = x1.end(i);
-                    begin2 != end2; ++begin2)
-            {
-                ++bucket_size;
+        // Check that the keys are in the correct bucket and are
+        // adjacent in the bucket.
+        BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
+        BOOST_DEDUCED_TYPENAME X::const_local_iterator lit = x1.begin(bucket),
+                                                       lend = x1.end(bucket);
+        for (; lit != lend && !eq(get_key<X>(*lit), key); ++lit)
+            continue;
+        if (lit == lend)
+            BOOST_ERROR("Unable to find element with a local_iterator");
+        unsigned int count2 = 0;
+        for (; lit != lend && eq(get_key<X>(*lit), key); ++lit)
+            ++count2;
+        if (count != count2)
+            BOOST_ERROR("Element count doesn't match local_iterator.");
+        for (; lit != lend; ++lit) {
+            if (eq(get_key<X>(*lit), key)) {
+                BOOST_ERROR("Non-adjacent element with equivalent key "
+                            "in bucket.");
+                break;
             }
         }
+    };
 
-        if(x1.size() != bucket_size) {
-            BOOST_ERROR("x1.size() doesn't match bucket size.");
-            std::cout<<x1.size()<<"/"<<bucket_size<<std::endl;
+    // Check that size matches up.
+
+    if (x1.size() != size) {
+        BOOST_ERROR("x1.size() doesn't match actual size.");
+        std::cout << x1.size() << "/" << size << std::endl;
+    }
+
+    // Check the load factor.
+
+    float load_factor =
+        size == 0 ? 0 : static_cast<float>(size) /
+                            static_cast<float>(x1.bucket_count());
+    using namespace std;
+    if (fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
+        BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
+
+    // Check that size in the buckets matches up.
+
+    BOOST_DEDUCED_TYPENAME X::size_type bucket_size = 0;
+
+    for (BOOST_DEDUCED_TYPENAME X::size_type i = 0; i < x1.bucket_count();
+         ++i) {
+        for (BOOST_DEDUCED_TYPENAME X::const_local_iterator
+                 begin2 = x1.begin(i),
+                 end2 = x1.end(i);
+             begin2 != end2; ++begin2) {
+            ++bucket_size;
         }
     }
+
+    if (x1.size() != bucket_size) {
+        BOOST_ERROR("x1.size() doesn't match bucket size.");
+        std::cout << x1.size() << "/" << bucket_size << std::endl;
+    }
+}
 }
 
 #if defined(BOOST_MSVC)
@@ -124,4 +123,3 @@ namespace test
 #endif
 
 #endif
-
diff --git a/test/helpers/list.hpp b/test/helpers/list.hpp
index 0c92928d..3453706c 100644
--- a/test/helpers/list.hpp
+++ b/test/helpers/list.hpp
@@ -12,307 +12,309 @@
 #define UNORDERED_TEST_LIST_HEADER
 
 #include <boost/limits.hpp>
-#include <iterator>
 #include <functional>
+#include <iterator>
 
-namespace test
+namespace test {
+template <typename It1, typename It2>
+bool equal(It1 begin, It1 end, It2 compare)
 {
-    template <typename It1, typename It2>
-    bool equal(It1 begin, It1 end, It2 compare)
+    for (; begin != end; ++begin, ++compare)
+        if (*begin != *compare)
+            return false;
+    return true;
+}
+
+template <typename It1, typename It2, typename Pred>
+bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
+{
+    for (; begin != end; ++begin, ++compare)
+        if (!predicate(*begin, *compare))
+            return false;
+    return true;
+}
+
+template <typename T> class list;
+
+namespace test_detail {
+template <typename T> class list_node;
+template <typename T> class list_data;
+template <typename T> class list_iterator;
+template <typename T> class list_const_iterator;
+
+template <typename T> class list_node
+{
+    list_node(list_node const&);
+    list_node& operator=(list_node const&);
+
+  public:
+    T value_;
+    list_node* next_;
+
+    list_node(T const& v) : value_(v), next_(0) {}
+    list_node(T const& v, list_node* n) : value_(v), next_(n) {}
+};
+
+template <typename T> class list_data
+{
+  public:
+    typedef list_node<T> node;
+    typedef unsigned int size_type;
+
+    node* first_;
+    node** last_ptr_;
+    size_type size_;
+
+    list_data() : first_(0), last_ptr_(&first_), size_(0) {}
+
+    ~list_data()
     {
-        for(;begin != end; ++begin, ++compare)
-            if(*begin != *compare) return false;
-        return true;
+        while (first_) {
+            node* tmp = first_;
+            first_ = first_->next_;
+            delete tmp;
+        }
     }
 
-    template <typename It1, typename It2, typename Pred>
-    bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
+  private:
+    list_data(list_data const&);
+    list_data& operator=(list_data const&);
+};
+
+template <typename T>
+class list_iterator
+    : public std::iterator<std::forward_iterator_tag, T, int, T*, T&>
+{
+    friend class list_const_iterator<T>;
+    friend class test::list<T>;
+    typedef list_node<T> node;
+    typedef list_const_iterator<T> const_iterator;
+
+    node* ptr_;
+
+  public:
+    list_iterator() : ptr_(0) {}
+    explicit list_iterator(node* x) : ptr_(x) {}
+
+    T& operator*() const { return ptr_->value_; }
+    T* operator->() const { return &ptr_->value_; }
+    list_iterator& operator++()
     {
-        for(;begin != end; ++begin, ++compare)
-            if(!predicate(*begin, *compare)) return false;
-        return true;
+        ptr_ = ptr_->next_;
+        return *this;
+    }
+    list_iterator operator++(int)
+    {
+        list_iterator tmp = *this;
+        ptr_ = ptr_->next_;
+        return tmp;
+    }
+    bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
+    bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
+};
+
+template <typename T>
+class list_const_iterator : public std::iterator<std::forward_iterator_tag, T,
+                                int, T const*, T const&>
+{
+    friend class list_iterator<T>;
+    friend class test::list<T>;
+    typedef list_node<T> node;
+    typedef list_iterator<T> iterator;
+    typedef list_const_iterator<T> const_iterator;
+
+    node* ptr_;
+
+  public:
+    list_const_iterator() : ptr_(0) {}
+    list_const_iterator(list_iterator<T> const& x) : ptr_(x.ptr_) {}
+
+    T const& operator*() const { return ptr_->value_; }
+    T const* operator->() const { return &ptr_->value_; }
+
+    list_const_iterator& operator++()
+    {
+        ptr_ = ptr_->next_;
+        return *this;
     }
 
-
-    template <typename T> class list;
-
-    namespace test_detail
+    list_const_iterator operator++(int)
     {
-        template <typename T> class list_node;
-        template <typename T> class list_data;
-        template <typename T> class list_iterator;
-        template <typename T> class list_const_iterator;
-
-        template <typename T>
-        class list_node
-        {
-            list_node(list_node const&);
-            list_node& operator=(list_node const&);
-        public:
-            T value_;
-            list_node* next_;
-                    
-            list_node(T const& v) : value_(v), next_(0) {}
-            list_node(T const& v, list_node* n) : value_(v), next_(n) {}
-        };
-
-        template <typename T>
-        class list_data
-        {
-        public:
-            typedef list_node<T> node;
-            typedef unsigned int size_type;
-
-            node* first_;
-            node** last_ptr_;
-            size_type size_;
-            
-            list_data() : first_(0), last_ptr_(&first_), size_(0) {}
-
-            ~list_data() {
-                while(first_) {
-                    node* tmp = first_;
-                    first_ = first_->next_;
-                    delete tmp;
-                }
-            }
-        private:
-            list_data(list_data const&);
-            list_data& operator=(list_data const&);
-        };
-
-        template <typename T>
-        class list_iterator
-            : public std::iterator<
-                std::forward_iterator_tag, T,
-                  int, T*, T&>
-        {
-            friend class list_const_iterator<T>;
-            friend class test::list<T>;
-            typedef list_node<T> node;
-            typedef list_const_iterator<T> const_iterator;
-
-            node* ptr_;
-        public:
-            list_iterator() : ptr_(0) {}
-            explicit list_iterator(node* x) : ptr_(x) {}
-
-            T& operator*() const { return ptr_->value_; }
-            T* operator->() const { return &ptr_->value_; }
-            list_iterator& operator++() {
-                ptr_ = ptr_->next_; return *this; }
-            list_iterator operator++(int) {
-                list_iterator tmp = *this; ptr_ = ptr_->next_; return tmp; }
-            bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
-            bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
-        };
-
-        template <typename T>
-        class list_const_iterator
-            : public std::iterator<
-                std::forward_iterator_tag, T,
-                  int, T const*, T const&>
-        {
-            friend class list_iterator<T>;
-            friend class test::list<T>;
-            typedef list_node<T> node;
-            typedef list_iterator<T> iterator;
-            typedef list_const_iterator<T> const_iterator;
-
-            node* ptr_;
-        public:
-            list_const_iterator() : ptr_(0) {}
-            list_const_iterator(list_iterator<T> const& x) : ptr_(x.ptr_) {}
-
-            T const& operator*() const { return ptr_->value_; }
-            T const* operator->() const { return &ptr_->value_; }
-
-            list_const_iterator& operator++()
-            {
-                ptr_ = ptr_->next_;
-                return *this;
-            }
-
-            list_const_iterator operator++(int)
-            {
-                list_const_iterator tmp = *this;
-                ptr_ = ptr_->next_;
-                return tmp;
-            }
-
-            bool operator==(const_iterator y) const
-            {
-                return ptr_ == y.ptr_;
-            }
-
-            bool operator!=(const_iterator y) const
-            {
-                return ptr_ != y.ptr_;
-            }
-        };
+        list_const_iterator tmp = *this;
+        ptr_ = ptr_->next_;
+        return tmp;
     }
 
-    template <typename T>
-    class list
+    bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
+
+    bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
+};
+}
+
+template <typename T> class list
+{
+    typedef test::test_detail::list_data<T> data;
+    typedef test::test_detail::list_node<T> node;
+    data data_;
+
+  public:
+    typedef T value_type;
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+    typedef unsigned int size_type;
+
+    typedef test::test_detail::list_iterator<T> iterator;
+    typedef test::test_detail::list_const_iterator<T> const_iterator;
+
+    list() : data_() {}
+
+    list(list const& other) : data_() { insert(other.begin(), other.end()); }
+
+    template <class InputIterator>
+    list(InputIterator i, InputIterator j) : data_()
     {
-        typedef test::test_detail::list_data<T> data;
-        typedef test::test_detail::list_node<T> node;
-        data data_;
-    public:
-        typedef T value_type;
-        typedef value_type& reference;
-        typedef value_type const& const_reference;
-        typedef unsigned int size_type;
+        insert(i, j);
+    }
 
-        typedef test::test_detail::list_iterator<T> iterator;
-        typedef test::test_detail::list_const_iterator<T> const_iterator;
+    list& operator=(list const& other)
+    {
+        clear();
+        insert(other.begin(), other.end());
+        return *this;
+    }
 
-        list() : data_() {}
+    iterator begin() { return iterator(data_.first_); }
+    iterator end() { return iterator(); }
+    const_iterator begin() const { return iterator(data_.first_); }
+    const_iterator end() const { return iterator(); }
+    const_iterator cbegin() const { return iterator(data_.first_); }
+    const_iterator cend() const { return iterator(); }
 
-        list(list const& other) : data_() {
-            insert(other.begin(), other.end());
-        }
+    template <class InputIterator> void insert(InputIterator i, InputIterator j)
+    {
+        for (; i != j; ++i)
+            push_back(*i);
+    }
 
-        template <class InputIterator>
-        list(InputIterator i, InputIterator j) : data_() {
-            insert(i, j);
-        }
-
-        list& operator=(list const& other) {
-            clear();
-            insert(other.begin(), other.end());
-            return *this;
-        }
-
-        iterator begin() { return iterator(data_.first_); }
-        iterator end() { return iterator(); }
-        const_iterator begin() const { return iterator(data_.first_); }
-        const_iterator end() const { return iterator(); }
-        const_iterator cbegin() const { return iterator(data_.first_); }
-        const_iterator cend() const { return iterator(); }
-
-        template <class InputIterator>
-        void insert(InputIterator i, InputIterator j) {
-            for(; i != j; ++i)
-                push_back(*i);
-        }
-
-        void push_front(value_type const& v) {
-            data_.first_ = new node(v, data_.first_);
-            if(!data_.size_) data_.last_ptr_ = &(*data_.last_ptr_)->next_;
-            ++data_.size_;
-        }
-    
-        void push_back(value_type const& v) {
-            *data_.last_ptr_ = new node(v);
+    void push_front(value_type const& v)
+    {
+        data_.first_ = new node(v, data_.first_);
+        if (!data_.size_)
             data_.last_ptr_ = &(*data_.last_ptr_)->next_;
-            ++data_.size_;
+        ++data_.size_;
+    }
+
+    void push_back(value_type const& v)
+    {
+        *data_.last_ptr_ = new node(v);
+        data_.last_ptr_ = &(*data_.last_ptr_)->next_;
+        ++data_.size_;
+    }
+
+    void clear()
+    {
+        while (data_.first_) {
+            node* tmp = data_.first_;
+            data_.first_ = data_.first_->next_;
+            --data_.size_;
+            delete tmp;
         }
-        
-        void clear() {
-            while(data_.first_) {
-                node* tmp = data_.first_;
-                data_.first_ = data_.first_->next_;
-                --data_.size_;
-                delete tmp;
-            }
-            data_.last_ptr_ = &data_.first_;
+        data_.last_ptr_ = &data_.first_;
+    }
+
+    void erase(const_iterator i, const_iterator j)
+    {
+        node** ptr = &data_.first_;
+
+        while (*ptr != i.ptr_) {
+            ptr = &(*ptr)->next_;
         }
 
-        void erase(const_iterator i, const_iterator j) {
-            node** ptr = &data_.first_;
-
-            while(*ptr != i.ptr_) {
-                ptr = &(*ptr)->next_;
-            }
-
-            while(*ptr != j.ptr_) {
-                node* to_delete = *ptr;
-                *ptr = (*ptr)->next_;
-                --data_.size_;
-                delete to_delete;
-            }
-
-            if(!*ptr) data_.last_ptr_ = ptr;
+        while (*ptr != j.ptr_) {
+            node* to_delete = *ptr;
+            *ptr = (*ptr)->next_;
+            --data_.size_;
+            delete to_delete;
         }
 
-        bool empty() const {
-            return !data_.size_;
+        if (!*ptr)
+            data_.last_ptr_ = ptr;
+    }
+
+    bool empty() const { return !data_.size_; }
+
+    size_type size() const { return data_.size_; }
+
+    void sort() { sort(std::less<T>()); }
+
+    template <typename Less> void sort(Less less = Less())
+    {
+        if (!empty())
+            merge_sort(
+                &data_.first_, (std::numeric_limits<size_type>::max)(), less);
+    }
+
+    bool operator==(list const& y) const
+    {
+        return size() == y.size() && test::equal(begin(), end(), y.begin());
+    }
+
+    bool operator!=(list const& y) const { return !(*this == y); }
+
+  private:
+    template <typename Less>
+    node** merge_sort(node** l, size_type recurse_limit, Less less)
+    {
+        node** ptr = &(*l)->next_;
+        for (size_type count = 0; count < recurse_limit && *ptr; ++count) {
+            ptr = merge_adjacent_ranges(
+                l, ptr, merge_sort(ptr, count, less), less);
         }
+        return ptr;
+    }
 
-        size_type size() const {
-            return data_.size_;
-        }
-
-        void sort() {
-            sort(std::less<T>());
-        }
-
-        template <typename Less>
-        void sort(Less less = Less()) {
-            if(!empty()) merge_sort(&data_.first_,
-                    (std::numeric_limits<size_type>::max)(), less);
-        }
-
-        bool operator==(list const& y) const {
-            return size() == y.size() &&
-                test::equal(begin(), end(), y.begin());
-        }
-
-        bool operator!=(list const& y) const {
-            return !(*this == y);
-        }
-
-    private:
-        template <typename Less>
-        node** merge_sort(node** l, size_type recurse_limit, Less less)
-        {
-            node** ptr = &(*l)->next_;
-            for(size_type count = 0; count < recurse_limit && *ptr; ++count)
-            {
-                ptr = merge_adjacent_ranges(l, ptr,
-                        merge_sort(ptr, count, less), less);
-            }
-            return ptr;
-        }
-        
-        template <typename Less>
-        node** merge_adjacent_ranges(node** first, node** second,
-                node** third, Less less)
-        {
-            for(;;) {
-                for(;;) {
-                    if(first == second) return third;
-                    if(less((*second)->value_, (*first)->value_)) break;
-                    first = &(*first)->next_;
-                }
-
-                swap_adjacent_ranges(first, second, third);
-                first = &(*first)->next_;
-                
-                // Since the two ranges we just swapped, the order is now:
-                // first...third...second
-                
-                for(;;) {
-                    if(first == third) return second;
-                    if(!less((*first)->value_, (*third)->value_)) break;
-                    first = &(*first)->next_;
-                }
-
-                swap_adjacent_ranges(first, third, second);
+    template <typename Less>
+    node** merge_adjacent_ranges(
+        node** first, node** second, node** third, Less less)
+    {
+        for (;;) {
+            for (;;) {
+                if (first == second)
+                    return third;
+                if (less((*second)->value_, (*first)->value_))
+                    break;
                 first = &(*first)->next_;
             }
+
+            swap_adjacent_ranges(first, second, third);
+            first = &(*first)->next_;
+
+            // Since the two ranges we just swapped, the order is now:
+            // first...third...second
+
+            for (;;) {
+                if (first == third)
+                    return second;
+                if (!less((*first)->value_, (*third)->value_))
+                    break;
+                first = &(*first)->next_;
+            }
+
+            swap_adjacent_ranges(first, third, second);
+            first = &(*first)->next_;
         }
-        
-        void swap_adjacent_ranges(node** first, node** second, node** third)
-        {
-            node* tmp = *first;
-            *first = *second;
-            *second = *third;
-            *third = tmp;
-            if(!*second) data_.last_ptr_ = second;
-        }
-    };
+    }
+
+    void swap_adjacent_ranges(node** first, node** second, node** third)
+    {
+        node* tmp = *first;
+        *first = *second;
+        *second = *third;
+        *third = tmp;
+        if (!*second)
+            data_.last_ptr_ = second;
+    }
+};
 }
 
 #endif
diff --git a/test/helpers/memory.hpp b/test/helpers/memory.hpp
index 6c095e98..84822b4a 100644
--- a/test/helpers/memory.hpp
+++ b/test/helpers/memory.hpp
@@ -6,158 +6,153 @@
 #if !defined(BOOST_UNORDERED_TEST_MEMORY_HEADER)
 #define BOOST_UNORDERED_TEST_MEMORY_HEADER
 
-#include <memory>
-#include <map>
+#include "../helpers/test.hpp"
 #include <boost/assert.hpp>
 #include <boost/unordered/detail/implementation.hpp>
-#include "../helpers/test.hpp"
+#include <map>
+#include <memory>
 
-namespace test
+namespace test {
+namespace detail {
+struct memory_area
 {
-    namespace detail
+    void const* start;
+    void const* end;
+
+    memory_area(void const* s, void const* e) : start(s), end(e)
     {
-        struct memory_area {
-            void const* start;
-            void const* end;
+        BOOST_ASSERT(start != end);
+    }
+};
 
-            memory_area(void const* s, void const* e)
-                : start(s), end(e)
-            {
-                BOOST_ASSERT(start != end);
-            }
-        };
+struct memory_track
+{
+    explicit memory_track(int tag = -1) : constructed_(0), tag_(tag) {}
 
-        struct memory_track {
-            explicit memory_track(int tag = -1) :
-                constructed_(0),
-                tag_(tag) {}
+    int constructed_;
+    int tag_;
+};
 
-            int constructed_;
-            int tag_;
-        };
+// This is a bit dodgy as it defines overlapping
+// areas as 'equal', so this isn't a total ordering.
+// But it is for non-overlapping memory regions - which
+// is what'll be stored.
+//
+// All searches will be for areas entirely contained by
+// a member of the set - so it should find the area that contains
+// the region that is searched for.
 
-        // This is a bit dodgy as it defines overlapping
-        // areas as 'equal', so this isn't a total ordering.
-        // But it is for non-overlapping memory regions - which
-        // is what'll be stored.
-        //
-        // All searches will be for areas entirely contained by
-        // a member of the set - so it should find the area that contains
-        // the region that is searched for.
+struct memory_area_compare
+{
+    bool operator()(memory_area const& x, memory_area const& y) const
+    {
+        return x.end <= y.start;
+    }
+};
 
-        struct memory_area_compare {
-            bool operator()(memory_area const& x, memory_area const& y) const {
-                return x.end <= y.start;
-            }
-        };
+struct memory_tracker
+{
+    typedef std::map<memory_area, memory_track, memory_area_compare,
+        std::allocator<std::pair<memory_area const, memory_track> > >
+        allocated_memory_type;
 
-        struct memory_tracker {
-            typedef std::map<memory_area, memory_track, memory_area_compare,
-                    std::allocator<std::pair<memory_area const, memory_track> >
-                > allocated_memory_type;
+    allocated_memory_type allocated_memory;
+    unsigned int count_allocators;
+    unsigned int count_allocations;
+    unsigned int count_constructions;
 
-            allocated_memory_type allocated_memory;
-            unsigned int count_allocators;
-            unsigned int count_allocations;
-            unsigned int count_constructions;
-
-            memory_tracker() :
-                count_allocators(0), count_allocations(0),
-                count_constructions(0)
-            {}
-
-            void allocator_ref()
-            {
-                if(count_allocators == 0) {
-                    count_allocations = 0;
-                    count_constructions = 0;
-                    allocated_memory.clear();
-                }
-                ++count_allocators;
-            }
-
-            void allocator_unref()
-            {
-                BOOST_TEST(count_allocators > 0);
-                if(count_allocators > 0) {
-                    --count_allocators;
-                    if(count_allocators == 0) {
-                        bool no_allocations_left = (count_allocations == 0);
-                        bool no_constructions_left = (count_constructions == 0);
-                        bool allocated_memory_empty = allocated_memory.empty();
-
-                        // Clearing the data before the checks terminate the
-                        // tests.
-                        count_allocations = 0;
-                        count_constructions = 0;
-                        allocated_memory.clear();
-
-                        BOOST_TEST(no_allocations_left);
-                        BOOST_TEST(no_constructions_left);
-                        BOOST_TEST(allocated_memory_empty);
-                    }
-                }
-            }
-
-            void track_allocate(void *ptr, std::size_t n, std::size_t size,
-                int tag)
-            {
-                if(n == 0) {
-                    BOOST_ERROR("Allocating 0 length array.");
-                }
-                else {
-                    ++count_allocations;
-                    allocated_memory.insert(
-                        std::pair<memory_area const, memory_track>(
-                            memory_area(ptr, (char*) ptr + n * size),
-                            memory_track(tag)));
-                }
-            }
-
-            void track_deallocate(void* ptr, std::size_t n, std::size_t size,
-                int tag, bool check_tag_ = true)
-            {
-                allocated_memory_type::iterator pos =
-                    allocated_memory.find(
-                        memory_area(ptr, (char*) ptr + n * size));
-                if(pos == allocated_memory.end()) {
-                    BOOST_ERROR("Deallocating unknown pointer.");
-                } else {
-                    BOOST_TEST(pos->first.start == ptr);
-                    BOOST_TEST(pos->first.end == (char*) ptr + n * size);
-                    if (check_tag_) BOOST_TEST(pos->second.tag_ == tag);
-                    allocated_memory.erase(pos);
-                }
-                BOOST_TEST(count_allocations > 0);
-                if(count_allocations > 0) --count_allocations;
-            }
-
-            void track_construct(void* /*ptr*/, std::size_t /*size*/,
-                int /*tag*/)
-            {
-                ++count_constructions;
-            }
-
-            void track_destroy(void* /*ptr*/, std::size_t /*size*/,
-                int /*tag*/)
-            {
-                BOOST_TEST(count_constructions > 0);
-                if(count_constructions > 0) --count_constructions;
-            }
-        };
+    memory_tracker()
+        : count_allocators(0), count_allocations(0), count_constructions(0)
+    {
     }
 
-    namespace detail
+    void allocator_ref()
     {
-        // This won't be a problem as I'm only using a single compile unit
-        // in each test (this is actually required by the minimal test
-        // framework).
-        // 
-        // boostinspect:nounnamed
-        namespace {
-            test::detail::memory_tracker tracker;
+        if (count_allocators == 0) {
+            count_allocations = 0;
+            count_constructions = 0;
+            allocated_memory.clear();
+        }
+        ++count_allocators;
+    }
+
+    void allocator_unref()
+    {
+        BOOST_TEST(count_allocators > 0);
+        if (count_allocators > 0) {
+            --count_allocators;
+            if (count_allocators == 0) {
+                bool no_allocations_left = (count_allocations == 0);
+                bool no_constructions_left = (count_constructions == 0);
+                bool allocated_memory_empty = allocated_memory.empty();
+
+                // Clearing the data before the checks terminate the
+                // tests.
+                count_allocations = 0;
+                count_constructions = 0;
+                allocated_memory.clear();
+
+                BOOST_TEST(no_allocations_left);
+                BOOST_TEST(no_constructions_left);
+                BOOST_TEST(allocated_memory_empty);
+            }
         }
     }
+
+    void track_allocate(void* ptr, std::size_t n, std::size_t size, int tag)
+    {
+        if (n == 0) {
+            BOOST_ERROR("Allocating 0 length array.");
+        } else {
+            ++count_allocations;
+            allocated_memory.insert(std::pair<memory_area const, memory_track>(
+                memory_area(ptr, (char*)ptr + n * size), memory_track(tag)));
+        }
+    }
+
+    void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag,
+        bool check_tag_ = true)
+    {
+        allocated_memory_type::iterator pos =
+            allocated_memory.find(memory_area(ptr, (char*)ptr + n * size));
+        if (pos == allocated_memory.end()) {
+            BOOST_ERROR("Deallocating unknown pointer.");
+        } else {
+            BOOST_TEST(pos->first.start == ptr);
+            BOOST_TEST(pos->first.end == (char*)ptr + n * size);
+            if (check_tag_)
+                BOOST_TEST(pos->second.tag_ == tag);
+            allocated_memory.erase(pos);
+        }
+        BOOST_TEST(count_allocations > 0);
+        if (count_allocations > 0)
+            --count_allocations;
+    }
+
+    void track_construct(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+    {
+        ++count_constructions;
+    }
+
+    void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+    {
+        BOOST_TEST(count_constructions > 0);
+        if (count_constructions > 0)
+            --count_constructions;
+    }
+};
+}
+
+namespace detail {
+// This won't be a problem as I'm only using a single compile unit
+// in each test (this is actually required by the minimal test
+// framework).
+//
+// boostinspect:nounnamed
+namespace {
+test::detail::memory_tracker tracker;
+}
+}
 }
 
 #endif
diff --git a/test/helpers/metafunctions.hpp b/test/helpers/metafunctions.hpp
index 8e36549d..c7e2a26a 100644
--- a/test/helpers/metafunctions.hpp
+++ b/test/helpers/metafunctions.hpp
@@ -9,24 +9,26 @@
 #include <boost/config.hpp>
 #include <boost/type_traits/is_same.hpp>
 
-namespace test
+namespace test {
+template <class Container>
+struct is_set
+    : public boost::is_same<BOOST_DEDUCED_TYPENAME Container::key_type,
+          BOOST_DEDUCED_TYPENAME Container::value_type>
 {
-    template <class Container>
-    struct is_set
-        : public boost::is_same<
-            BOOST_DEDUCED_TYPENAME Container::key_type,
-            BOOST_DEDUCED_TYPENAME Container::value_type> {};
+};
 
-    template <class Container>
-    struct has_unique_keys
-    {
-        static char flip(BOOST_DEDUCED_TYPENAME Container::iterator const&);
-        static long flip(std::pair<BOOST_DEDUCED_TYPENAME Container::iterator, bool> const&);
-        BOOST_STATIC_CONSTANT(bool, value = sizeof(long) == sizeof(
-                flip(((Container*) 0)->insert(*(BOOST_DEDUCED_TYPENAME Container::value_type*) 0))
-            ));
-    };
+template <class Container> struct has_unique_keys
+{
+    static char flip(BOOST_DEDUCED_TYPENAME Container::iterator const&);
+    static long flip(
+        std::pair<BOOST_DEDUCED_TYPENAME Container::iterator, bool> const&);
+    BOOST_STATIC_CONSTANT(bool,
+        value = sizeof(long) ==
+                sizeof(flip(
+                    ((Container*)0)
+                        ->insert(*(
+                            BOOST_DEDUCED_TYPENAME Container::value_type*)0))));
+};
 }
 
 #endif
-
diff --git a/test/helpers/prefix.hpp b/test/helpers/prefix.hpp
index ef879fb7..fe757025 100644
--- a/test/helpers/prefix.hpp
+++ b/test/helpers/prefix.hpp
@@ -6,6 +6,6 @@
 #if defined(_WIN32_WCE)
 // The standard windows mobile headers trigger this warning so I disable it
 // before doing anything else.
-#pragma warning(disable:4201)   // nonstandard extension used :
+#pragma warning(disable : 4201) // nonstandard extension used :
                                 // nameless struct/union
 #endif
diff --git a/test/helpers/random_values.hpp b/test/helpers/random_values.hpp
index 7628514d..65772dba 100644
--- a/test/helpers/random_values.hpp
+++ b/test/helpers/random_values.hpp
@@ -6,111 +6,104 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER
 
+#include "./generators.hpp"
 #include "./list.hpp"
+#include "./metafunctions.hpp"
 #include <algorithm>
 #include <boost/detail/select_type.hpp>
-#include "./generators.hpp"
-#include "./metafunctions.hpp"
 
-namespace test
+namespace test {
+template <class X> struct unordered_generator_set
 {
-    template <class X>
-    struct unordered_generator_set
+    typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+
+    random_generator type_;
+
+    unordered_generator_set(random_generator type) : type_(type) {}
+
+    template <class T> void fill(T& x, std::size_t len)
     {
-        typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+        value_type* value_ptr = 0;
+        len += x.size();
 
-        random_generator type_;
+        for (std::size_t i = 0; i < len; ++i) {
+            value_type value = generate(value_ptr, type_);
 
-        unordered_generator_set(random_generator type)
-            : type_(type) {}
+            std::size_t count =
+                type_ == generate_collisions ? random_value(5) + 1 : 1;
 
-        template <class T>
-        void fill(T& x, std::size_t len) {
-            value_type* value_ptr = 0;
-            len += x.size();
-
-            for (std::size_t i = 0; i < len; ++i) {
-                value_type value = generate(value_ptr, type_);
-
-                std::size_t count = type_ == generate_collisions ?
-                    random_value(5) + 1 : 1;
-
-                for(std::size_t j = 0; j < count; ++j) {
-                    x.push_back(value);
-                }
+            for (std::size_t j = 0; j < count; ++j) {
+                x.push_back(value);
             }
         }
-    };
+    }
+};
 
-    template <class X>
-    struct unordered_generator_map
+template <class X> struct unordered_generator_map
+{
+    typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+    typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
+
+    random_generator type_;
+
+    unordered_generator_map(random_generator type) : type_(type) {}
+
+    template <class T> void fill(T& x, std::size_t len)
     {
-        typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-        typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
+        key_type* key_ptr = 0;
+        mapped_type* mapped_ptr = 0;
 
-        random_generator type_;
+        for (std::size_t i = 0; i < len; ++i) {
+            key_type key = generate(key_ptr, type_);
 
-        unordered_generator_map(random_generator type)
-            : type_(type) {}
+            std::size_t count =
+                type_ == generate_collisions ? random_value(5) + 1 : 1;
 
-        template <class T>
-        void fill(T& x, std::size_t len) {
-            key_type* key_ptr = 0;
-            mapped_type* mapped_ptr = 0;
-
-            for (std::size_t i = 0; i < len; ++i) {
-                key_type key = generate(key_ptr, type_);
-
-                std::size_t count = type_ == generate_collisions ?
-                    random_value(5) + 1 : 1;
-
-                for(std::size_t j = 0; j < count; ++j) {
-                    x.push_back(std::pair<key_type const, mapped_type>(
-                        key, generate(mapped_ptr, type_)));
-                }
+            for (std::size_t j = 0; j < count; ++j) {
+                x.push_back(std::pair<key_type const, mapped_type>(
+                    key, generate(mapped_ptr, type_)));
             }
         }
-    };
+    }
+};
 
-    template <class X>
-    struct unordered_generator_base
-        : public boost::detail::if_true<
-            test::is_set<X>::value
-        >::BOOST_NESTED_TEMPLATE then<
-            test::unordered_generator_set<X>,
-            test::unordered_generator_map<X>
-        >
+template <class X>
+struct unordered_generator_base
+    : public boost::detail::if_true<test::is_set<X>::value>::
+          BOOST_NESTED_TEMPLATE then<test::unordered_generator_set<X>,
+              test::unordered_generator_map<X> >
+{
+};
+
+template <class X>
+struct unordered_generator : public unordered_generator_base<X>::type
+{
+    typedef BOOST_DEDUCED_TYPENAME unordered_generator_base<X>::type base;
+
+    unordered_generator(random_generator const& type = default_generator)
+        : base(type)
     {
-    };
+    }
+};
 
-    template <class X>
-    struct unordered_generator : public unordered_generator_base<X>::type
+template <class X>
+struct random_values : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
+{
+    random_values() {}
+
+    explicit random_values(std::size_t count,
+        test::random_generator const& generator = test::default_generator)
     {
-        typedef BOOST_DEDUCED_TYPENAME unordered_generator_base<X>::type base;
+        fill(count, generator);
+    }
 
-        unordered_generator(random_generator const& type = default_generator)
-            : base(type) {}
-    };
-
-    template <class X>
-    struct random_values
-        : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
+    void fill(std::size_t count,
+        test::random_generator const& generator = test::default_generator)
     {
-        random_values() {}
-
-        explicit random_values(std::size_t count, test::random_generator const& generator =
-            test::default_generator)
-        {
-            fill(count, generator);
-        }
-
-        void fill(std::size_t count, test::random_generator const& generator =
-                test::default_generator)
-        {
-            test::unordered_generator<X> gen(generator);
-            gen.fill(*this, count);
-        }
-    };
+        test::unordered_generator<X> gen(generator);
+        gen.fill(*this, count);
+    }
+};
 }
 
 #endif
diff --git a/test/helpers/strong.hpp b/test/helpers/strong.hpp
index 02fe267a..0fc3d58c 100644
--- a/test/helpers/strong.hpp
+++ b/test/helpers/strong.hpp
@@ -6,37 +6,38 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_STRONG_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_STRONG_HEADER
 
+#include "./equivalent.hpp"
+#include "./exception_test.hpp"
+#include "./list.hpp"
 #include <boost/config.hpp>
 #include <iterator>
-#include "./equivalent.hpp"
-#include "./list.hpp"
-#include "./exception_test.hpp"
 
-namespace test
+namespace test {
+template <class X> class strong
 {
-    template <class X>
-    class strong
-    {
-        typedef test::list<BOOST_DEDUCED_TYPENAME X::value_type> values_type;
-        values_type values_;
-        unsigned int allocations_;
-    public:
-        void store(X const& x, unsigned int allocations = 0) {
-            DISABLE_EXCEPTIONS;
-            values_.clear();
-            values_.insert(x.cbegin(), x.cend());
-            allocations_ = allocations;
-        }
+    typedef test::list<BOOST_DEDUCED_TYPENAME X::value_type> values_type;
+    values_type values_;
+    unsigned int allocations_;
 
-        void test(X const& x, unsigned int allocations = 0) const {
-            if(!(x.size() == values_.size() &&
-                    test::equal(x.cbegin(), x.cend(), values_.begin(),
-                        test::equivalent)))
-                BOOST_ERROR("Strong exception safety failure.");
-            if(allocations != allocations_)
-                BOOST_ERROR("Strong exception failure: extra allocations.");
-        }
-    };
+  public:
+    void store(X const& x, unsigned int allocations = 0)
+    {
+        DISABLE_EXCEPTIONS;
+        values_.clear();
+        values_.insert(x.cbegin(), x.cend());
+        allocations_ = allocations;
+    }
+
+    void test(X const& x, unsigned int allocations = 0) const
+    {
+        if (!(x.size() == values_.size() &&
+                test::equal(
+                    x.cbegin(), x.cend(), values_.begin(), test::equivalent)))
+            BOOST_ERROR("Strong exception safety failure.");
+        if (allocations != allocations_)
+            BOOST_ERROR("Strong exception failure: extra allocations.");
+    }
+};
 }
 
 #endif
diff --git a/test/helpers/test.hpp b/test/helpers/test.hpp
index b9d4c3b5..393658ea 100644
--- a/test/helpers/test.hpp
+++ b/test/helpers/test.hpp
@@ -11,113 +11,115 @@
 #include <boost/preprocessor/stringize.hpp>
 #include <iostream>
 
-#define UNORDERED_AUTO_TEST(x)                                              \
-    struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base {   \
-        BOOST_PP_CAT(x, _type)()                                            \
-            : ::test::registered_test_base(BOOST_PP_STRINGIZE(x))           \
-        {                                                                   \
-            ::test::test_list::add_test(this);                              \
-        }                                                                   \
-        void run();                                                         \
-    };                                                                      \
-    BOOST_PP_CAT(x, _type) x;                                               \
-    void BOOST_PP_CAT(x, _type)::run()                                      \
+#define UNORDERED_AUTO_TEST(x)                                                 \
+    struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base        \
+    {                                                                          \
+        BOOST_PP_CAT(x, _type)                                                 \
+        () : ::test::registered_test_base(BOOST_PP_STRINGIZE(x))               \
+        {                                                                      \
+            ::test::test_list::add_test(this);                                 \
+        }                                                                      \
+        void run();                                                            \
+    };                                                                         \
+    BOOST_PP_CAT(x, _type) x;                                                  \
+    void BOOST_PP_CAT(x, _type)::run()
 
-#define RUN_TESTS() int main(int, char**)                                   \
-    {                                                                       \
-        ::test::write_compiler_info();                                      \
-        ::test::test_list::run_tests();                                     \
-        return boost::report_errors();                                      \
+#define RUN_TESTS()                                                            \
+    int main(int, char**)                                                      \
+    {                                                                          \
+        ::test::write_compiler_info();                                         \
+        ::test::test_list::run_tests();                                        \
+        return boost::report_errors();                                         \
     }
 
 namespace test {
-    struct registered_test_base {
-        registered_test_base* next;
-        char const* name;
-        explicit registered_test_base(char const* n) : name(n) {}
-        virtual void run() = 0;
-        virtual ~registered_test_base() {}
-    };
+struct registered_test_base
+{
+    registered_test_base* next;
+    char const* name;
+    explicit registered_test_base(char const* n) : name(n) {}
+    virtual void run() = 0;
+    virtual ~registered_test_base() {}
+};
 
-    namespace test_list {
-        static inline registered_test_base*& first() {
-            static registered_test_base* ptr = 0;
-            return ptr;
-        }
-
-        static inline registered_test_base*& last() {
-            static registered_test_base* ptr = 0;
-            return ptr;
-        }
-
-        static inline void add_test(registered_test_base* test) {
-            if(last()) {
-                last()->next = test;
-            }
-            else {
-                first() = test;
-            }
-
-            last() = test;
-        }
-
-        static inline void run_tests() {
-            for(registered_test_base* i = first(); i; i = i->next) {
-                std::cout<<"Running "<<i->name<<"\n"<<std::flush;
-                i->run();
-                std::cerr<<std::flush;
-                std::cout<<std::flush;
-            }
-        }
-    }
-
-    inline void write_compiler_info() {
-#if defined(BOOST_GCC_CXX11)
-        char const* cpp11 = "true";
-#else
-        char const* cpp11 = "false";
-#endif
-
-        std::cout
-            << "Compiler: " << BOOST_COMPILER << "\n"
-            << "Library: " << BOOST_STDLIB << "\n"
-            << "C++11: " << cpp11 << "\n"
-            << "\n"
-            << std::flush;
-    }
+namespace test_list {
+static inline registered_test_base*& first()
+{
+    static registered_test_base* ptr = 0;
+    return ptr;
+}
+
+static inline registered_test_base*& last()
+{
+    static registered_test_base* ptr = 0;
+    return ptr;
+}
+
+static inline void add_test(registered_test_base* test)
+{
+    if (last()) {
+        last()->next = test;
+    } else {
+        first() = test;
+    }
+
+    last() = test;
+}
+
+static inline void run_tests()
+{
+    for (registered_test_base* i = first(); i; i = i->next) {
+        std::cout << "Running " << i->name << "\n" << std::flush;
+        i->run();
+        std::cerr << std::flush;
+        std::cout << std::flush;
+    }
+}
+}
+
+inline void write_compiler_info()
+{
+#if defined(BOOST_GCC_CXX11)
+    char const* cpp11 = "true";
+#else
+    char const* cpp11 = "false";
+#endif
+
+    std::cout << "Compiler: " << BOOST_COMPILER << "\n"
+              << "Library: " << BOOST_STDLIB << "\n"
+              << "C++11: " << cpp11 << "\n"
+              << "\n"
+              << std::flush;
+}
 }
 
-#include <boost/preprocessor/seq/for_each_product.hpp>
-#include <boost/preprocessor/seq/fold_left.hpp>
-#include <boost/preprocessor/seq/to_tuple.hpp>
-#include <boost/preprocessor/seq/seq.hpp>
 #include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/fold_left.hpp>
+#include <boost/preprocessor/seq/for_each_product.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/to_tuple.hpp>
 
 // Run test with every combination of the parameters (a sequence of sequences)
-#define UNORDERED_TEST(name, parameters)                                    \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP,                        \
-        ((name))((1)) parameters)                                           \
+#define UNORDERED_TEST(name, parameters)                                       \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name))((1))parameters)
 
-#define UNORDERED_TEST_REPEAT(name, n, parameters)                          \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP,                        \
-        ((name))((n)) parameters)                                           \
+#define UNORDERED_TEST_REPEAT(name, n, parameters)                             \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name))((n))parameters)
 
-#define UNORDERED_TEST_OP(r, product)                                       \
-    UNORDERED_TEST_OP2(                                                     \
-        BOOST_PP_SEQ_ELEM(0, product),                                      \
-        BOOST_PP_SEQ_ELEM(1, product),                                      \
-        BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))                      \
+#define UNORDERED_TEST_OP(r, product)                                          \
+    UNORDERED_TEST_OP2(BOOST_PP_SEQ_ELEM(0, product),                          \
+        BOOST_PP_SEQ_ELEM(1, product),                                         \
+        BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))
 
-#define UNORDERED_TEST_OP2(name, n, params)                                 \
-    UNORDERED_AUTO_TEST(                                                    \
-        BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params))       \
-    {                                                                       \
-        for (int i = 0; i < n; ++i)                                         \
-            name BOOST_PP_SEQ_TO_TUPLE(params);                             \
-    }                                                                       \
-
-#define UNORDERED_TEST_OP_JOIN(s, state, elem)                              \
-    BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))                              \
+#define UNORDERED_TEST_OP2(name, n, params)                                    \
+    UNORDERED_AUTO_TEST(                                                       \
+        BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params))          \
+    {                                                                          \
+        for (int i = 0; i < n; ++i)                                            \
+            name BOOST_PP_SEQ_TO_TUPLE(params);                                \
+    }
 
+#define UNORDERED_TEST_OP_JOIN(s, state, elem)                                 \
+    BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))
 
 #endif
diff --git a/test/helpers/tracker.hpp b/test/helpers/tracker.hpp
index ab2470c0..0ea17a25 100644
--- a/test/helpers/tracker.hpp
+++ b/test/helpers/tracker.hpp
@@ -9,159 +9,139 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_TRACKER_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_TRACKER_HEADER
 
-#include <set>
-#include <map>
-#include <iterator>
-#include <algorithm>
 #include "../objects/fwd.hpp"
-#include "./metafunctions.hpp"
-#include "./helpers.hpp"
 #include "./equivalent.hpp"
+#include "./helpers.hpp"
 #include "./list.hpp"
+#include "./metafunctions.hpp"
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <set>
 
-namespace test
+namespace test {
+template <typename X> struct equals_to_compare
 {
-    template <typename X>
-    struct equals_to_compare
-    {
-        typedef std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type>
-            type;
-    };
+    typedef std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> type;
+};
 
-    template <>
-    struct equals_to_compare<test::equal_to>
-    {
-        typedef test::less type;
-    };
+template <> struct equals_to_compare<test::equal_to>
+{
+    typedef test::less type;
+};
 
-    template <class X1, class X2>
-    void compare_range(X1 const& x1, X2 const& x2)
+template <class X1, class X2> void compare_range(X1 const& x1, X2 const& x2)
+{
+    typedef test::list<BOOST_DEDUCED_TYPENAME X1::value_type> value_list;
+    value_list values1(x1.begin(), x1.end());
+    value_list values2(x2.begin(), x2.end());
+    values1.sort();
+    values2.sort();
+    BOOST_TEST(values1.size() == values2.size() &&
+               test::equal(values1.begin(), values1.end(), values2.begin(),
+                   test::equivalent));
+}
+
+template <class X1, class X2, class T>
+void compare_pairs(X1 const& x1, X2 const& x2, T*)
+{
+    test::list<T> values1(x1.first, x1.second);
+    test::list<T> values2(x2.first, x2.second);
+    values1.sort();
+    values2.sort();
+    BOOST_TEST(values1.size() == values2.size() &&
+               test::equal(values1.begin(), values1.end(), values2.begin(),
+                   test::equivalent));
+}
+
+template <typename X, bool is_set = test::is_set<X>::value,
+    bool has_unique_keys = test::has_unique_keys<X>::value>
+struct ordered_base;
+
+template <typename X> struct ordered_base<X, true, true>
+{
+    typedef std::set<BOOST_DEDUCED_TYPENAME X::value_type,
+        BOOST_DEDUCED_TYPENAME
+            equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
+        type;
+};
+
+template <typename X> struct ordered_base<X, true, false>
+{
+    typedef std::multiset<BOOST_DEDUCED_TYPENAME X::value_type,
+        BOOST_DEDUCED_TYPENAME
+            equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
+        type;
+};
+
+template <typename X> struct ordered_base<X, false, true>
+{
+    typedef std::map<BOOST_DEDUCED_TYPENAME X::key_type,
+        BOOST_DEDUCED_TYPENAME X::mapped_type,
+        BOOST_DEDUCED_TYPENAME
+            equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
+        type;
+};
+
+template <typename X> struct ordered_base<X, false, false>
+{
+    typedef std::multimap<BOOST_DEDUCED_TYPENAME X::key_type,
+        BOOST_DEDUCED_TYPENAME X::mapped_type,
+        BOOST_DEDUCED_TYPENAME
+            equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
+        type;
+};
+
+template <class X> class ordered : public ordered_base<X>::type
+{
+    typedef BOOST_DEDUCED_TYPENAME ordered_base<X>::type base;
+
+  public:
+    typedef BOOST_DEDUCED_TYPENAME base::key_compare key_compare;
+
+    ordered() : base() {}
+
+    explicit ordered(key_compare const& kc) : base(kc) {}
+
+    void compare(X const& x) { compare_range(x, *this); }
+
+    void compare_key(
+        X const& x, BOOST_DEDUCED_TYPENAME X::value_type const& val)
     {
-        typedef test::list<BOOST_DEDUCED_TYPENAME X1::value_type> value_list;
-        value_list values1(x1.begin(), x1.end());
-        value_list values2(x2.begin(), x2.end());
-        values1.sort();
-        values2.sort();
-        BOOST_TEST(values1.size() == values2.size() &&
-                test::equal(values1.begin(), values1.end(), values2.begin(),
-                    test::equivalent));
+        compare_pairs(x.equal_range(get_key<X>(val)),
+            this->equal_range(get_key<X>(val)),
+            (BOOST_DEDUCED_TYPENAME X::value_type*)0);
     }
 
-    template <class X1, class X2, class T>
-    void compare_pairs(X1 const& x1, X2 const& x2, T*)
+    template <class It> void insert_range(It b, It e)
     {
-        test::list<T> values1(x1.first, x1.second);
-        test::list<T> values2(x2.first, x2.second);
-        values1.sort();
-        values2.sort();
-        BOOST_TEST(values1.size() == values2.size() &&
-                test::equal(values1.begin(), values1.end(),
-                    values2.begin(), test::equivalent));
-    }
-
-    template <typename X,
-             bool is_set = test::is_set<X>::value,
-             bool has_unique_keys = test::has_unique_keys<X>::value>
-    struct ordered_base;
-
-    template <typename X>
-    struct ordered_base<X, true, true>
-    {
-        typedef std::set<
-            BOOST_DEDUCED_TYPENAME X::value_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
-
-    template <typename X>
-    struct ordered_base<X, true, false>
-    {
-        typedef std::multiset<
-            BOOST_DEDUCED_TYPENAME X::value_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
-
-    template <typename X>
-    struct ordered_base<X, false, true>
-    {
-        typedef std::map<
-            BOOST_DEDUCED_TYPENAME X::key_type,
-            BOOST_DEDUCED_TYPENAME X::mapped_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
-
-    template <typename X>
-    struct ordered_base<X, false, false>
-    {
-        typedef std::multimap<
-            BOOST_DEDUCED_TYPENAME X::key_type,
-            BOOST_DEDUCED_TYPENAME X::mapped_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
-
-    template <class X>
-    class ordered : public ordered_base<X>::type
-    {
-        typedef BOOST_DEDUCED_TYPENAME ordered_base<X>::type base;
-    public:
-        typedef BOOST_DEDUCED_TYPENAME base::key_compare key_compare;
-
-        ordered()
-            : base()
-        {}
-
-        explicit ordered(key_compare const& kc)
-            : base(kc)
-        {}
-
-        void compare(X const& x)
-        {
-            compare_range(x, *this);
+        while (b != e) {
+            this->insert(*b);
+            ++b;
         }
-
-        void compare_key(X const& x,
-            BOOST_DEDUCED_TYPENAME X::value_type const& val)
-        {
-            compare_pairs(
-                x.equal_range(get_key<X>(val)),
-                this->equal_range(get_key<X>(val)),
-                (BOOST_DEDUCED_TYPENAME X::value_type*) 0);
-        }
-
-        template <class It>
-        void insert_range(It b, It e) {
-            while(b != e) {
-                this->insert(*b);
-                ++b;
-            }
-        }
-    };
-
-    template <class Equals>
-    BOOST_DEDUCED_TYPENAME
-        equals_to_compare<Equals>::type create_compare(Equals const&)
-    {
-        BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type x;
-        return x;
     }
+};
 
-    template <class X>
-    ordered<X> create_ordered(X const& container)
-    {
-        return ordered<X>(create_compare(container.key_eq()));
-    }
+template <class Equals>
+BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type create_compare(
+    Equals const&)
+{
+    BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type x;
+    return x;
+}
 
-    template <class X1, class X2>
-    void check_container(X1 const& container, X2 const& values)
-    {
-        ordered<X1> tracker = create_ordered(container);
-        tracker.insert_range(values.begin(), values.end());
-        tracker.compare(container);
-    }
+template <class X> ordered<X> create_ordered(X const& container)
+{
+    return ordered<X>(create_compare(container.key_eq()));
+}
+
+template <class X1, class X2>
+void check_container(X1 const& container, X2 const& values)
+{
+    ordered<X1> tracker = create_ordered(container);
+    tracker.insert_range(values.begin(), values.end());
+    tracker.compare(container);
+}
 }
 
 #endif
-
diff --git a/test/objects/cxx11_allocator.hpp b/test/objects/cxx11_allocator.hpp
index 8ace50c5..4694438c 100644
--- a/test/objects/cxx11_allocator.hpp
+++ b/test/objects/cxx11_allocator.hpp
@@ -13,309 +13,332 @@
 #include "../helpers/fwd.hpp"
 #include "../helpers/memory.hpp"
 
-namespace test
+namespace test {
+struct allocator_false
 {
-    struct allocator_false
+    enum
     {
-        enum {
-            is_select_on_copy = 0,
-            is_propagate_on_swap = 0,
-            is_propagate_on_assign = 0,
-            is_propagate_on_move = 0,
-            cxx11_construct = 0
+        is_select_on_copy = 0,
+        is_propagate_on_swap = 0,
+        is_propagate_on_assign = 0,
+        is_propagate_on_move = 0,
+        cxx11_construct = 0
+    };
+};
+
+struct allocator_flags_all
+{
+    enum
+    {
+        is_select_on_copy = 1,
+        is_propagate_on_swap = 1,
+        is_propagate_on_assign = 1,
+        is_propagate_on_move = 1,
+        cxx11_construct = 1
+    };
+};
+
+struct select_copy : allocator_false
+{
+    enum
+    {
+        is_select_on_copy = 1
+    };
+};
+struct propagate_swap : allocator_false
+{
+    enum
+    {
+        is_propagate_on_swap = 1
+    };
+};
+struct propagate_assign : allocator_false
+{
+    enum
+    {
+        is_propagate_on_assign = 1
+    };
+};
+struct propagate_move : allocator_false
+{
+    enum
+    {
+        is_propagate_on_move = 1
+    };
+};
+
+struct no_select_copy : allocator_flags_all
+{
+    enum
+    {
+        is_select_on_copy = 0
+    };
+};
+struct no_propagate_swap : allocator_flags_all
+{
+    enum
+    {
+        is_propagate_on_swap = 0
+    };
+};
+struct no_propagate_assign : allocator_flags_all
+{
+    enum
+    {
+        is_propagate_on_assign = 0
+    };
+};
+struct no_propagate_move : allocator_flags_all
+{
+    enum
+    {
+        is_propagate_on_move = 0
+    };
+};
+
+template <typename Flag> struct swap_allocator_base
+{
+    struct propagate_on_container_swap
+    {
+        enum
+        {
+            value = Flag::is_propagate_on_swap
         };
     };
+};
 
-    struct allocator_flags_all
+template <typename Flag> struct assign_allocator_base
+{
+    struct propagate_on_container_copy_assignment
     {
-        enum {
-            is_select_on_copy = 1,
-            is_propagate_on_swap = 1,
-            is_propagate_on_assign = 1,
-            is_propagate_on_move = 1,
-            cxx11_construct = 1
+        enum
+        {
+            value = Flag::is_propagate_on_assign
         };
     };
-    
-    struct select_copy : allocator_false
-    { enum { is_select_on_copy = 1 }; };
-    struct propagate_swap : allocator_false
-    { enum { is_propagate_on_swap = 1 }; };
-    struct propagate_assign : allocator_false
-    { enum { is_propagate_on_assign = 1 }; };
-    struct propagate_move : allocator_false
-    { enum { is_propagate_on_move = 1 }; };
+};
 
-    struct no_select_copy : allocator_flags_all
-    { enum { is_select_on_copy = 0 }; };
-    struct no_propagate_swap : allocator_flags_all
-    { enum { is_propagate_on_swap = 0 }; };
-    struct no_propagate_assign : allocator_flags_all
-    { enum { is_propagate_on_assign = 0 }; };
-    struct no_propagate_move : allocator_flags_all
-    { enum { is_propagate_on_move = 0 }; };
-    
-    template <typename Flag>
-    struct swap_allocator_base
+template <typename Flag> struct move_allocator_base
+{
+    struct propagate_on_container_move_assignment
     {
-        struct propagate_on_container_swap {
-            enum { value = Flag::is_propagate_on_swap }; };
+        enum
+        {
+            value = Flag::is_propagate_on_move
+        };
     };
+};
 
-    template <typename Flag>
-    struct assign_allocator_base
-    {
-        struct propagate_on_container_copy_assignment {
-            enum { value = Flag::is_propagate_on_assign }; };
-    };
+namespace {
+// boostinspect:nounnamed
+bool force_equal_allocator_value = false;
+}
 
-    template <typename Flag>
-    struct move_allocator_base
-    {
-        struct propagate_on_container_move_assignment {
-            enum { value = Flag::is_propagate_on_move }; };
-    };
+struct force_equal_allocator
+{
+    bool old_value_;
 
-    namespace
+    explicit force_equal_allocator(bool value)
+        : old_value_(force_equal_allocator_value)
     {
-        // boostinspect:nounnamed
-        bool force_equal_allocator_value = false;
+        force_equal_allocator_value = value;
     }
 
-    struct force_equal_allocator
+    ~force_equal_allocator() { force_equal_allocator_value = old_value_; }
+};
+
+template <typename T> struct cxx11_allocator_base
+{
+    int tag_;
+    int selected_;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    explicit cxx11_allocator_base(int t) : tag_(t), selected_(0)
     {
-        bool old_value_;
-    
-        explicit force_equal_allocator(bool value)
-            : old_value_(force_equal_allocator_value)
-        { force_equal_allocator_value = value; }
-        
-        ~force_equal_allocator()
-        { force_equal_allocator_value = old_value_; }
-    };
+        detail::tracker.allocator_ref();
+    }
 
-    template <typename T>
-    struct cxx11_allocator_base
+    template <typename Y>
+    cxx11_allocator_base(cxx11_allocator_base<Y> const& x)
+        : tag_(x.tag_), selected_(x.selected_)
     {
-        int tag_;
-        int selected_;
+        detail::tracker.allocator_ref();
+    }
 
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef T* pointer;
-        typedef T const* const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
+    cxx11_allocator_base(cxx11_allocator_base const& x)
+        : tag_(x.tag_), selected_(x.selected_)
+    {
+        detail::tracker.allocator_ref();
+    }
 
-        explicit cxx11_allocator_base(int t)
-            : tag_(t), selected_(0)
-        {
-            detail::tracker.allocator_ref();
-        }
-        
-        template <typename Y> cxx11_allocator_base(
-                cxx11_allocator_base<Y> const& x)
-            : tag_(x.tag_), selected_(x.selected_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    ~cxx11_allocator_base() { detail::tracker.allocator_unref(); }
 
-        cxx11_allocator_base(cxx11_allocator_base const& x)
-            : tag_(x.tag_), selected_(x.selected_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    pointer address(reference r) { return pointer(&r); }
 
-        ~cxx11_allocator_base()
-        {
-            detail::tracker.allocator_unref();
-        }
+    const_pointer address(const_reference r) { return const_pointer(&r); }
 
-        pointer address(reference r)
-        {
-            return pointer(&r);
-        }
+    pointer allocate(size_type n)
+    {
+        pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        const_pointer address(const_reference r)
-        {
-            return const_pointer(&r);
-        }
+    pointer allocate(size_type n, void const*)
+    {
+        pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        pointer allocate(size_type n) {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
+    void deallocate(pointer p, size_type n)
+    {
+        // Only checking tags when propagating swap.
+        // Note that tags will be tested
+        // properly in the normal allocator.
+        detail::tracker.track_deallocate(
+            (void*)p, n, sizeof(T), tag_, !force_equal_allocator_value);
+        ::operator delete((void*)p);
+    }
 
-        pointer allocate(size_type n, void const*)
-        {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            // Only checking tags when propagating swap.
-            // Note that tags will be tested
-            // properly in the normal allocator.
-            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_,
-                 !force_equal_allocator_value);
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(t);
-        }
+    void construct(T* p, T const& t)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(t);
+    }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<typename... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(boost::forward<Args>(args)...);
-        }
+    template <typename... Args>
+    void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) {
-            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-        }
-
-        size_type max_size() const {
-            return (std::numeric_limits<size_type>::max)();
-        }
-    };
-
-    template <typename T, typename Flags = propagate_swap,
-        typename Enable = void>
-    struct cxx11_allocator;
-
-    template <typename T, typename Flags>
-    struct cxx11_allocator<
-        T, Flags,
-        typename boost::disable_if_c<Flags::is_select_on_copy>::type
-    > : public cxx11_allocator_base<T>,
-        public swap_allocator_base<Flags>,
-        public assign_allocator_base<Flags>,
-        public move_allocator_base<Flags>,
-        Flags
+    void destroy(T* p)
     {
+        detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+    }
+
+    size_type max_size() const
+    {
+        return (std::numeric_limits<size_type>::max)();
+    }
+};
+
+template <typename T, typename Flags = propagate_swap, typename Enable = void>
+struct cxx11_allocator;
+
+template <typename T, typename Flags>
+struct cxx11_allocator<T, Flags,
+    typename boost::disable_if_c<Flags::is_select_on_copy>::type>
+    : public cxx11_allocator_base<T>,
+      public swap_allocator_base<Flags>,
+      public assign_allocator_base<Flags>,
+      public move_allocator_base<Flags>,
+      Flags
+{
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
-        template <typename U> struct rebind {
-            typedef cxx11_allocator<U, Flags> other;
-        };
+    template <typename U> struct rebind
+    {
+        typedef cxx11_allocator<U, Flags> other;
+    };
 #endif
 
-        explicit cxx11_allocator(int t = 0)
-            : cxx11_allocator_base<T>(t)
-        {
-        }
-        
-        template <typename Y> cxx11_allocator(
-                cxx11_allocator<Y, Flags> const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
+    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}
 
-        cxx11_allocator(cxx11_allocator const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        // When not propagating swap, allocators are always equal
-        // to avoid undefined behaviour.
-        bool operator==(cxx11_allocator const& x) const
-        {
-            return force_equal_allocator_value || (this->tag_ == x.tag_);
-        }
-
-        bool operator!=(cxx11_allocator const& x) const
-        {
-            return !(*this == x);
-        }
-    };
-
-    template <typename T, typename Flags>
-    struct cxx11_allocator<
-        T, Flags,
-        typename boost::enable_if_c<Flags::is_select_on_copy>::type
-    > : public cxx11_allocator_base<T>,
-        public swap_allocator_base<Flags>,
-        public assign_allocator_base<Flags>,
-        public move_allocator_base<Flags>,
-        Flags
+    template <typename Y>
+    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
+        : cxx11_allocator_base<T>(x)
     {
-        cxx11_allocator select_on_container_copy_construction() const
-        {
-            cxx11_allocator tmp(*this);
-            ++tmp.selected_;
-            return tmp;
-        }
+    }
+
+    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}
+
+    // When not propagating swap, allocators are always equal
+    // to avoid undefined behaviour.
+    bool operator==(cxx11_allocator const& x) const
+    {
+        return force_equal_allocator_value || (this->tag_ == x.tag_);
+    }
+
+    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
+};
+
+template <typename T, typename Flags>
+struct cxx11_allocator<T, Flags,
+    typename boost::enable_if_c<Flags::is_select_on_copy>::type>
+    : public cxx11_allocator_base<T>,
+      public swap_allocator_base<Flags>,
+      public assign_allocator_base<Flags>,
+      public move_allocator_base<Flags>,
+      Flags
+{
+    cxx11_allocator select_on_container_copy_construction() const
+    {
+        cxx11_allocator tmp(*this);
+        ++tmp.selected_;
+        return tmp;
+    }
 
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
-        template <typename U> struct rebind {
-            typedef cxx11_allocator<U, Flags> other;
-        };
+    template <typename U> struct rebind
+    {
+        typedef cxx11_allocator<U, Flags> other;
+    };
 #endif
 
-        explicit cxx11_allocator(int t = 0)
-            : cxx11_allocator_base<T>(t)
-        {
-        }
-        
-        template <typename Y> cxx11_allocator(
-                cxx11_allocator<Y, Flags> const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
+    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}
 
-        cxx11_allocator(cxx11_allocator const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        // When not propagating swap, allocators are always equal
-        // to avoid undefined behaviour.
-        bool operator==(cxx11_allocator const& x) const
-        {
-            return force_equal_allocator_value || (this->tag_ == x.tag_);
-        }
-
-        bool operator!=(cxx11_allocator const& x) const
-        {
-            return !(*this == x);
-        }
-    };
-
-    template <typename T, typename Flags>
-    bool equivalent_impl(
-            cxx11_allocator<T, Flags> const& x,
-            cxx11_allocator<T, Flags> const& y,
-            test::derived_type)
+    template <typename Y>
+    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
+        : cxx11_allocator_base<T>(x)
     {
-        return x.tag_ == y.tag_;
     }
 
-    // Function to check how many times an allocator has been selected,
-    // return 0 for other allocators.
+    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}
 
-    struct convert_from_anything
+    // When not propagating swap, allocators are always equal
+    // to avoid undefined behaviour.
+    bool operator==(cxx11_allocator const& x) const
     {
-        template <typename T>
-        convert_from_anything(T const&) {}
-    };
-
-    inline int selected_count(convert_from_anything)
-    {
-        return 0;
+        return force_equal_allocator_value || (this->tag_ == x.tag_);
     }
 
-    template <typename T, typename Flags>
-    int selected_count(cxx11_allocator<T, Flags> const& x)
-    {
-        return x.selected_;
-    }
+    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
+};
+
+template <typename T, typename Flags>
+bool equivalent_impl(cxx11_allocator<T, Flags> const& x,
+    cxx11_allocator<T, Flags> const& y, test::derived_type)
+{
+    return x.tag_ == y.tag_;
+}
+
+// Function to check how many times an allocator has been selected,
+// return 0 for other allocators.
+
+struct convert_from_anything
+{
+    template <typename T> convert_from_anything(T const&) {}
+};
+
+inline int selected_count(convert_from_anything) { return 0; }
+
+template <typename T, typename Flags>
+int selected_count(cxx11_allocator<T, Flags> const& x)
+{
+    return x.selected_;
+}
 }
 
 #endif
diff --git a/test/objects/exception.hpp b/test/objects/exception.hpp
index 2cd2ce11..da11cf56 100644
--- a/test/objects/exception.hpp
+++ b/test/objects/exception.hpp
@@ -8,634 +8,718 @@
 
 #include "../helpers/exception_test.hpp"
 
+#include "../helpers/count.hpp"
+#include "../helpers/fwd.hpp"
+#include "../helpers/memory.hpp"
+#include <boost/limits.hpp>
 #include <cstddef>
 #include <iostream>
-#include <boost/limits.hpp>
 #include <new>
-#include "../helpers/fwd.hpp"
-#include "../helpers/count.hpp"
-#include "../helpers/memory.hpp"
 
-namespace test
+namespace test {
+namespace exception {
+class object;
+class hash;
+class equal_to;
+template <class T> class allocator;
+object generate(object const*, random_generator);
+std::pair<object, object> generate(
+    std::pair<object, object> const*, random_generator);
+
+struct true_type
 {
-namespace exception
+    enum
+    {
+        value = true
+    };
+};
+
+struct false_type
 {
-    class object;
-    class hash;
-    class equal_to;
-    template <class T> class allocator;
-    object generate(object const*, random_generator);
-    std::pair<object, object> generate(std::pair<object, object> const*, random_generator);
-
-    struct true_type
+    enum
     {
-        enum { value = true };
+        value = false
+    };
+};
+
+class object : private counted_object
+{
+  public:
+    int tag1_, tag2_;
+
+    explicit object() : tag1_(0), tag2_(0)
+    {
+        UNORDERED_SCOPE(object::object())
+        {
+            UNORDERED_EPOINT("Mock object default constructor.");
+        }
+    }
+
+    explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
+    {
+        UNORDERED_SCOPE(object::object(int))
+        {
+            UNORDERED_EPOINT("Mock object constructor by value.");
+        }
+    }
+
+    object(object const& x) : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+    {
+        UNORDERED_SCOPE(object::object(object))
+        {
+            UNORDERED_EPOINT("Mock object copy constructor.");
+        }
+    }
+
+    ~object()
+    {
+        tag1_ = -1;
+        tag2_ = -1;
+    }
+
+    object& operator=(object const& x)
+    {
+        UNORDERED_SCOPE(object::operator=(object))
+        {
+            tag1_ = x.tag1_;
+            UNORDERED_EPOINT("Mock object assign operator 1.");
+            tag2_ = x.tag2_;
+            // UNORDERED_EPOINT("Mock object assign operator 2.");
+        }
+        return *this;
+    }
+
+    friend bool operator==(object const& x1, object const& x2)
+    {
+        UNORDERED_SCOPE(operator==(object, object))
+        {
+            UNORDERED_EPOINT("Mock object equality operator.");
+        }
+
+        return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+    }
+
+    friend bool operator!=(object const& x1, object const& x2)
+    {
+        UNORDERED_SCOPE(operator!=(object, object))
+        {
+            UNORDERED_EPOINT("Mock object inequality operator.");
+        }
+
+        return !(x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_);
+    }
+
+    // None of the last few functions are used by the unordered associative
+    // containers - so there aren't any exception points.
+    friend bool operator<(object const& x1, object const& x2)
+    {
+        return x1.tag1_ < x2.tag1_ ||
+               (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+    }
+
+    friend object generate(object const*, random_generator g)
+    {
+        int* x = 0;
+        return object(::test::generate(x, g), ::test::generate(x, g));
+    }
+
+    friend std::pair<object, object> generate(
+        std::pair<object, object> const*, random_generator g)
+    {
+        int* x = 0;
+        return std::make_pair(
+            object(::test::generate(x, g), ::test::generate(x, g)),
+            object(::test::generate(x, g), ::test::generate(x, g)));
+    }
+
+    friend std::ostream& operator<<(std::ostream& out, object const& o)
+    {
+        return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+};
+
+class hash
+{
+    int tag_;
+
+  public:
+    hash(int t = 0) : tag_(t)
+    {
+        UNORDERED_SCOPE(hash::object())
+        {
+            UNORDERED_EPOINT("Mock hash default constructor.");
+        }
+    }
+
+    hash(hash const& x) : tag_(x.tag_)
+    {
+        UNORDERED_SCOPE(hash::hash(hash))
+        {
+            UNORDERED_EPOINT("Mock hash copy constructor.");
+        }
+    }
+
+    hash& operator=(hash const& x)
+    {
+        UNORDERED_SCOPE(hash::operator=(hash))
+        {
+            UNORDERED_EPOINT("Mock hash assign operator 1.");
+            tag_ = x.tag_;
+            UNORDERED_EPOINT("Mock hash assign operator 2.");
+        }
+        return *this;
+    }
+
+    std::size_t operator()(object const& x) const
+    {
+        UNORDERED_SCOPE(hash::operator()(object))
+        {
+            UNORDERED_EPOINT("Mock hash function.");
+        }
+
+        return hash_impl(x);
+    }
+
+    std::size_t operator()(std::pair<object, object> const& x) const
+    {
+        UNORDERED_SCOPE(hash::operator()(std::pair<object, object>))
+        {
+            UNORDERED_EPOINT("Mock hash pair function.");
+        }
+
+        return hash_impl(x.first) * 193ul + hash_impl(x.second) * 97ul + 29ul;
+    }
+
+    std::size_t hash_impl(object const& x) const
+    {
+        int result;
+        switch (tag_) {
+        case 1:
+            result = x.tag1_;
+            break;
+        case 2:
+            result = x.tag2_;
+            break;
+        default:
+            result = x.tag1_ + x.tag2_;
+        }
+        return static_cast<std::size_t>(result);
+    }
+
+    friend bool operator==(hash const& x1, hash const& x2)
+    {
+        UNORDERED_SCOPE(operator==(hash, hash))
+        {
+            UNORDERED_EPOINT("Mock hash equality function.");
+        }
+        return x1.tag_ == x2.tag_;
+    }
+
+    friend bool operator!=(hash const& x1, hash const& x2)
+    {
+        UNORDERED_SCOPE(hash::operator!=(hash, hash))
+        {
+            UNORDERED_EPOINT("Mock hash inequality function.");
+        }
+        return x1.tag_ != x2.tag_;
+    }
+};
+
+class equal_to
+{
+    int tag_;
+
+  public:
+    equal_to(int t = 0) : tag_(t)
+    {
+        UNORDERED_SCOPE(equal_to::equal_to())
+        {
+            UNORDERED_EPOINT("Mock equal_to default constructor.");
+        }
+    }
+
+    equal_to(equal_to const& x) : tag_(x.tag_)
+    {
+        UNORDERED_SCOPE(equal_to::equal_to(equal_to))
+        {
+            UNORDERED_EPOINT("Mock equal_to copy constructor.");
+        }
+    }
+
+    equal_to& operator=(equal_to const& x)
+    {
+        UNORDERED_SCOPE(equal_to::operator=(equal_to))
+        {
+            UNORDERED_EPOINT("Mock equal_to assign operator 1.");
+            tag_ = x.tag_;
+            UNORDERED_EPOINT("Mock equal_to assign operator 2.");
+        }
+        return *this;
+    }
+
+    bool operator()(object const& x1, object const& x2) const
+    {
+        UNORDERED_SCOPE(equal_to::operator()(object, object))
+        {
+            UNORDERED_EPOINT("Mock equal_to function.");
+        }
+
+        return equal_impl(x1, x2);
+    }
+
+    bool operator()(std::pair<object, object> const& x1,
+        std::pair<object, object> const& x2) const
+    {
+        UNORDERED_SCOPE(equal_to::operator()(
+            std::pair<object, object>, std::pair<object, object>))
+        {
+            UNORDERED_EPOINT("Mock equal_to function.");
+        }
+
+        return equal_impl(x1.first, x2.first) &&
+               equal_impl(x1.second, x2.second);
+    }
+
+    bool equal_impl(object const& x1, object const& x2) const
+    {
+        switch (tag_) {
+        case 1:
+            return x1.tag1_ == x2.tag1_;
+        case 2:
+            return x1.tag2_ == x2.tag2_;
+        default:
+            return x1 == x2;
+        }
+    }
+
+    friend bool operator==(equal_to const& x1, equal_to const& x2)
+    {
+        UNORDERED_SCOPE(operator==(equal_to, equal_to))
+        {
+            UNORDERED_EPOINT("Mock equal_to equality function.");
+        }
+        return x1.tag_ == x2.tag_;
+    }
+
+    friend bool operator!=(equal_to const& x1, equal_to const& x2)
+    {
+        UNORDERED_SCOPE(operator!=(equal_to, equal_to))
+        {
+            UNORDERED_EPOINT("Mock equal_to inequality function.");
+        }
+        return x1.tag_ != x2.tag_;
+    }
+};
+
+template <class T> class allocator
+{
+  public:
+    int tag_;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+        typedef allocator<U> other;
     };
 
-    struct false_type
+    explicit allocator(int t = 0) : tag_(t)
     {
-        enum { value = false };
-    };
+        UNORDERED_SCOPE(allocator::allocator())
+        {
+            UNORDERED_EPOINT("Mock allocator default constructor.");
+        }
+        test::detail::tracker.allocator_ref();
+    }
 
-    class object : private counted_object
+    template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
     {
-    public:
-        int tag1_, tag2_;
-
-        explicit object() : tag1_(0), tag2_(0)
+        UNORDERED_SCOPE(allocator::allocator())
         {
-            UNORDERED_SCOPE(object::object()) {
-                UNORDERED_EPOINT("Mock object default constructor.");
-            }
+            UNORDERED_EPOINT("Mock allocator template copy constructor.");
         }
+        test::detail::tracker.allocator_ref();
+    }
 
-        explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
-        {
-            UNORDERED_SCOPE(object::object(int)) {
-                UNORDERED_EPOINT("Mock object constructor by value.");
-            }
-        }
-
-        object(object const& x)
-             : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
-        {
-            UNORDERED_SCOPE(object::object(object)) {
-                UNORDERED_EPOINT("Mock object copy constructor.");
-            }
-        }
-
-        ~object() {
-            tag1_ = -1;
-            tag2_ = -1;
-        }
-
-        object& operator=(object const& x)
-        {
-            UNORDERED_SCOPE(object::operator=(object)) {
-                tag1_ = x.tag1_;
-                UNORDERED_EPOINT("Mock object assign operator 1.");
-                tag2_ = x.tag2_;
-                //UNORDERED_EPOINT("Mock object assign operator 2.");
-            }
-            return *this;
-        }
-
-        friend bool operator==(object const& x1, object const& x2) {
-            UNORDERED_SCOPE(operator==(object, object)) {
-                UNORDERED_EPOINT("Mock object equality operator.");
-            }
-
-            return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
-        }
-
-        friend bool operator!=(object const& x1, object const& x2) {
-            UNORDERED_SCOPE(operator!=(object, object)) {
-                UNORDERED_EPOINT("Mock object inequality operator.");
-            }
-
-            return !(x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_);
-        }
-
-        // None of the last few functions are used by the unordered associative
-        // containers - so there aren't any exception points.
-        friend bool operator<(object const& x1, object const& x2) {
-            return x1.tag1_ < x2.tag1_ ||
-                (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
-        }
-
-        friend object generate(object const*, random_generator g) {
-            int* x = 0;
-            return object(::test::generate(x, g), ::test::generate(x, g));
-        }
-
-        friend std::pair<object, object> generate(std::pair<object, object> const*, random_generator g) {
-            int* x = 0;
-            return std::make_pair(
-                object(::test::generate(x, g), ::test::generate(x, g)),
-                object(::test::generate(x, g), ::test::generate(x, g)));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, object const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
-    class hash
+    allocator(allocator const& x) : tag_(x.tag_)
     {
-        int tag_;
-    public:
-        hash(int t = 0) : tag_(t)
+        UNORDERED_SCOPE(allocator::allocator())
         {
-            UNORDERED_SCOPE(hash::object()) {
-                UNORDERED_EPOINT("Mock hash default constructor.");
-            }
+            UNORDERED_EPOINT("Mock allocator copy constructor.");
         }
+        test::detail::tracker.allocator_ref();
+    }
 
-        hash(hash const& x)
-            : tag_(x.tag_)
-        {
-            UNORDERED_SCOPE(hash::hash(hash)) {
-                UNORDERED_EPOINT("Mock hash copy constructor.");
-            }
-        }
+    ~allocator() { test::detail::tracker.allocator_unref(); }
 
-        hash& operator=(hash const& x)
-        {
-            UNORDERED_SCOPE(hash::operator=(hash)) {
-                UNORDERED_EPOINT("Mock hash assign operator 1.");
-                tag_ = x.tag_;
-                UNORDERED_EPOINT("Mock hash assign operator 2.");
-            }
-            return *this;
-        }
-
-        std::size_t operator()(object const& x) const {
-            UNORDERED_SCOPE(hash::operator()(object)) {
-                UNORDERED_EPOINT("Mock hash function.");
-            }
-
-            return hash_impl(x);
-        }
-
-        std::size_t operator()(std::pair<object, object> const& x) const {
-            UNORDERED_SCOPE(hash::operator()(std::pair<object, object>)) {
-                UNORDERED_EPOINT("Mock hash pair function.");
-            }
-
-            return hash_impl(x.first) * 193ul + hash_impl(x.second) * 97ul + 29ul;
-        }
-
-        std::size_t hash_impl(object const& x) const {
-            int result;
-            switch(tag_) {
-            case 1:
-                result = x.tag1_;
-                break;
-            case 2:
-                result = x.tag2_;
-                break;
-            default:
-                result = x.tag1_ + x.tag2_; 
-            }
-            return static_cast<std::size_t>(result);
-        }
-
-        friend bool operator==(hash const& x1, hash const& x2) {
-            UNORDERED_SCOPE(operator==(hash, hash)) {
-                UNORDERED_EPOINT("Mock hash equality function.");
-            }
-            return x1.tag_ == x2.tag_;
-        }
-
-        friend bool operator!=(hash const& x1, hash const& x2) {
-            UNORDERED_SCOPE(hash::operator!=(hash, hash)) {
-                UNORDERED_EPOINT("Mock hash inequality function.");
-            }
-            return x1.tag_ != x2.tag_;
-        }
-    };
-
-    class equal_to
+    allocator& operator=(allocator const& x)
     {
-        int tag_;
-    public:
-        equal_to(int t = 0) : tag_(t)
+        UNORDERED_SCOPE(allocator::allocator())
         {
-            UNORDERED_SCOPE(equal_to::equal_to()) {
-                UNORDERED_EPOINT("Mock equal_to default constructor.");
-            }
+            UNORDERED_EPOINT("Mock allocator assignment operator.");
+            tag_ = x.tag_;
         }
+        return *this;
+    }
 
-        equal_to(equal_to const& x)
-            : tag_(x.tag_)
-        {
-            UNORDERED_SCOPE(equal_to::equal_to(equal_to)) {
-                UNORDERED_EPOINT("Mock equal_to copy constructor.");
-            }
-        }
+    // If address throws, then it can't be used in erase or the
+    // destructor, which is very limiting. I need to check up on
+    // this.
 
-        equal_to& operator=(equal_to const& x)
-        {
-            UNORDERED_SCOPE(equal_to::operator=(equal_to)) {
-                UNORDERED_EPOINT("Mock equal_to assign operator 1.");
-                tag_ = x.tag_;
-                UNORDERED_EPOINT("Mock equal_to assign operator 2.");
-            }
-            return *this;
-        }
-
-        bool operator()(object const& x1, object const& x2) const {
-            UNORDERED_SCOPE(equal_to::operator()(object, object)) {
-                UNORDERED_EPOINT("Mock equal_to function.");
-            }
-
-            return equal_impl(x1, x2);
-        }
-
-        bool operator()(std::pair<object, object> const& x1, std::pair<object, object> const& x2) const {
-            UNORDERED_SCOPE(equal_to::operator()(std::pair<object, object>, std::pair<object, object>)) {
-                UNORDERED_EPOINT("Mock equal_to function.");
-            }
-
-            return equal_impl(x1.first, x2.first) && equal_impl(x1.second, x2.second);
-        }
-
-        bool equal_impl(object const& x1, object const& x2) const {
-            switch(tag_) {
-            case 1:
-                return x1.tag1_ == x2.tag1_;
-            case 2:
-                return x1.tag2_ == x2.tag2_;
-            default:
-                return x1 == x2; 
-            }
-        }
-
-        friend bool operator==(equal_to const& x1, equal_to const& x2) {
-            UNORDERED_SCOPE(operator==(equal_to, equal_to)) {
-                UNORDERED_EPOINT("Mock equal_to equality function.");
-            }
-            return x1.tag_ == x2.tag_;
-        }
-
-        friend bool operator!=(equal_to const& x1, equal_to const& x2) {
-            UNORDERED_SCOPE(operator!=(equal_to, equal_to)) {
-                UNORDERED_EPOINT("Mock equal_to inequality function.");
-            }
-            return x1.tag_ != x2.tag_;
-        }
-    };
-
-    template <class T>
-    class allocator
+    pointer address(reference r)
     {
-    public:
-        int tag_;
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef T* pointer;
-        typedef T const* const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
+        // UNORDERED_SCOPE(allocator::address(reference)) {
+        //    UNORDERED_EPOINT("Mock allocator address function.");
+        //}
+        return pointer(&r);
+    }
 
-        template <class U> struct rebind { typedef allocator<U> other; };
+    const_pointer address(const_reference r)
+    {
+        // UNORDERED_SCOPE(allocator::address(const_reference)) {
+        //    UNORDERED_EPOINT("Mock allocator const address function.");
+        //}
+        return const_pointer(&r);
+    }
 
-        explicit allocator(int t = 0) : tag_(t)
+    pointer allocate(size_type n)
+    {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator::allocate(size_type))
         {
-            UNORDERED_SCOPE(allocator::allocator()) {
-                UNORDERED_EPOINT("Mock allocator default constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
+            UNORDERED_EPOINT("Mock allocator allocate function.");
 
-        template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
+            using namespace std;
+            ptr = (T*)malloc(n * sizeof(T));
+            if (!ptr)
+                throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
+
+    pointer allocate(size_type n, void const*)
+    {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer))
         {
-            UNORDERED_SCOPE(allocator::allocator()) {
-                UNORDERED_EPOINT("Mock allocator template copy constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
+            UNORDERED_EPOINT("Mock allocator allocate function.");
 
-        allocator(allocator const& x) : tag_(x.tag_)
+            using namespace std;
+            ptr = (T*)malloc(n * sizeof(T));
+            if (!ptr)
+                throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
+
+    void deallocate(pointer p, size_type n)
+    {
+        //::operator delete((void*) p);
+        if (p) {
+            test::detail::tracker.track_deallocate(
+                (void*)p, n, sizeof(T), tag_);
+            using namespace std;
+            free(p);
+        }
+    }
+
+    void construct(pointer p, T const& t)
+    {
+        UNORDERED_SCOPE(allocator::construct(T*, T))
         {
-            UNORDERED_SCOPE(allocator::allocator()) {
-                UNORDERED_EPOINT("Mock allocator copy constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        ~allocator() {
-            test::detail::tracker.allocator_unref();
-        }
-
-        allocator& operator=(allocator const& x) {
-            UNORDERED_SCOPE(allocator::allocator()) {
-                UNORDERED_EPOINT("Mock allocator assignment operator.");
-                tag_ = x.tag_;
-            }
-            return *this;
-        }
-
-        // If address throws, then it can't be used in erase or the
-        // destructor, which is very limiting. I need to check up on
-        // this.
-
-        pointer address(reference r) {
-            //UNORDERED_SCOPE(allocator::address(reference)) {
-            //    UNORDERED_EPOINT("Mock allocator address function.");
-            //}
-            return pointer(&r);
-        }
-
-        const_pointer address(const_reference r)  {
-            //UNORDERED_SCOPE(allocator::address(const_reference)) {
-            //    UNORDERED_EPOINT("Mock allocator const address function.");
-            //}
-            return const_pointer(&r);
-        }
-
-        pointer allocate(size_type n) {
-            T* ptr = 0;
-            UNORDERED_SCOPE(allocator::allocate(size_type)) {
-                UNORDERED_EPOINT("Mock allocator allocate function.");
-
-                using namespace std;
-                ptr = (T*) malloc(n * sizeof(T));
-                if(!ptr) throw std::bad_alloc();
-            }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return pointer(ptr);
-
-            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        pointer allocate(size_type n, void const*)
-        {
-            T* ptr = 0;
-            UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer)) {
-                UNORDERED_EPOINT("Mock allocator allocate function.");
-
-                using namespace std;
-                ptr = (T*) malloc(n * sizeof(T));
-                if(!ptr) throw std::bad_alloc();
-            }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return pointer(ptr);
-
-            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            //::operator delete((void*) p);
-            if(p) {
-                test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
-                using namespace std;
-                free(p);
-            }
-        }
-
-        void construct(pointer p, T const& t) {
-            UNORDERED_SCOPE(allocator::construct(T*, T)) {
-                UNORDERED_EPOINT("Mock allocator construct function.");
-                new(p) T(t);
-            }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            UNORDERED_EPOINT("Mock allocator construct function.");
+            new (p) T(t);
         }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+    }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...)) {
-                UNORDERED_EPOINT("Mock allocator construct function.");
-                new(p) T(boost::forward<Args>(args)...);
-            }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...))
+        {
+            UNORDERED_EPOINT("Mock allocator construct function.");
+            new (p) T(boost::forward<Args>(args)...);
         }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+    }
 #endif
 
-        void destroy(T* p) {
-            test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-        }
+    void destroy(T* p)
+    {
+        test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+    }
 
-        size_type max_size() const {
-            UNORDERED_SCOPE(allocator::construct(pointer, T)) {
-                UNORDERED_EPOINT("Mock allocator max_size function.");
-            }
-            return (std::numeric_limits<std::size_t>::max)();
+    size_type max_size() const
+    {
+        UNORDERED_SCOPE(allocator::construct(pointer, T))
+        {
+            UNORDERED_EPOINT("Mock allocator max_size function.");
         }
+        return (std::numeric_limits<std::size_t>::max)();
+    }
 
-        typedef true_type propagate_on_container_copy_assignment;
-        typedef true_type propagate_on_container_move_assignment;
-        typedef true_type propagate_on_container_swap;
+    typedef true_type propagate_on_container_copy_assignment;
+    typedef true_type propagate_on_container_move_assignment;
+    typedef true_type propagate_on_container_swap;
+};
+
+template <class T> void swap(allocator<T>& x, allocator<T>& y)
+{
+    std::swap(x.tag_, y.tag_);
+}
+
+// It's pretty much impossible to write a compliant swap when these
+// two can throw. So they don't.
+
+template <class T>
+inline bool operator==(allocator<T> const& x, allocator<T> const& y)
+{
+    // UNORDERED_SCOPE(operator==(allocator, allocator)) {
+    //    UNORDERED_EPOINT("Mock allocator equality operator.");
+    //}
+    return x.tag_ == y.tag_;
+}
+
+template <class T>
+inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
+{
+    // UNORDERED_SCOPE(operator!=(allocator, allocator)) {
+    //    UNORDERED_EPOINT("Mock allocator inequality operator.");
+    //}
+    return x.tag_ != y.tag_;
+}
+
+template <class T> class allocator2
+{
+  public:
+    int tag_;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+        typedef allocator2<U> other;
     };
 
-    template <class T>
-    void swap(allocator<T>& x, allocator<T>& y)
+    explicit allocator2(int t = 0) : tag_(t)
     {
-        std::swap(x.tag_, y.tag_);
+        UNORDERED_SCOPE(allocator2::allocator2())
+        {
+            UNORDERED_EPOINT("Mock allocator2 default constructor.");
+        }
+        test::detail::tracker.allocator_ref();
     }
 
-    // It's pretty much impossible to write a compliant swap when these
-    // two can throw. So they don't.
-
-    template <class T>
-    inline bool operator==(allocator<T> const& x, allocator<T> const& y)
+    allocator2(allocator<T> const& x) : tag_(x.tag_)
     {
-        //UNORDERED_SCOPE(operator==(allocator, allocator)) {
-        //    UNORDERED_EPOINT("Mock allocator equality operator.");
+        UNORDERED_SCOPE(allocator2::allocator2())
+        {
+            UNORDERED_EPOINT("Mock allocator2 constructor from allocator.");
+        }
+        test::detail::tracker.allocator_ref();
+    }
+
+    template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+    {
+        UNORDERED_SCOPE(allocator2::allocator2())
+        {
+            UNORDERED_EPOINT("Mock allocator2 template copy constructor.");
+        }
+        test::detail::tracker.allocator_ref();
+    }
+
+    allocator2(allocator2 const& x) : tag_(x.tag_)
+    {
+        UNORDERED_SCOPE(allocator2::allocator2())
+        {
+            UNORDERED_EPOINT("Mock allocator2 copy constructor.");
+        }
+        test::detail::tracker.allocator_ref();
+    }
+
+    ~allocator2() { test::detail::tracker.allocator_unref(); }
+
+    allocator2& operator=(allocator2 const& x)
+    {
+        UNORDERED_SCOPE(allocator2::allocator2())
+        {
+            UNORDERED_EPOINT("Mock allocator2 assignment operator.");
+            tag_ = x.tag_;
+        }
+        return *this;
+    }
+
+    // If address throws, then it can't be used in erase or the
+    // destructor, which is very limiting. I need to check up on
+    // this.
+
+    pointer address(reference r)
+    {
+        // UNORDERED_SCOPE(allocator2::address(reference)) {
+        //    UNORDERED_EPOINT("Mock allocator2 address function.");
         //}
-        return x.tag_ == y.tag_;
+        return pointer(&r);
     }
 
-    template <class T>
-    inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
+    const_pointer address(const_reference r)
     {
-        //UNORDERED_SCOPE(operator!=(allocator, allocator)) {
-        //    UNORDERED_EPOINT("Mock allocator inequality operator.");
+        // UNORDERED_SCOPE(allocator2::address(const_reference)) {
+        //    UNORDERED_EPOINT("Mock allocator2 const address function.");
         //}
-        return x.tag_ != y.tag_;
+        return const_pointer(&r);
     }
 
-    template <class T>
-    class allocator2
+    pointer allocate(size_type n)
     {
-    public:
-        int tag_;
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef T* pointer;
-        typedef T const* const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
-
-        template <class U> struct rebind { typedef allocator2<U> other; };
-
-        explicit allocator2(int t = 0) : tag_(t)
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator2::allocate(size_type))
         {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 default constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
+            UNORDERED_EPOINT("Mock allocator2 allocate function.");
 
-        allocator2(allocator<T> const& x) : tag_(x.tag_)
+            using namespace std;
+            ptr = (T*)malloc(n * sizeof(T));
+            if (!ptr)
+                throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
+
+    pointer allocate(size_type n, void const*)
+    {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer))
         {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 constructor from allocator.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
+            UNORDERED_EPOINT("Mock allocator2 allocate function.");
 
-        template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+            using namespace std;
+            ptr = (T*)malloc(n * sizeof(T));
+            if (!ptr)
+                throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
+
+    void deallocate(pointer p, size_type n)
+    {
+        //::operator delete((void*) p);
+        if (p) {
+            test::detail::tracker.track_deallocate(
+                (void*)p, n, sizeof(T), tag_);
+            using namespace std;
+            free(p);
+        }
+    }
+
+    void construct(pointer p, T const& t)
+    {
+        UNORDERED_SCOPE(allocator2::construct(T*, T))
         {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 template copy constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        allocator2(allocator2 const& x) : tag_(x.tag_)
-        {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 copy constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        ~allocator2() {
-            test::detail::tracker.allocator_unref();
-        }
-
-        allocator2& operator=(allocator2 const& x) {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 assignment operator.");
-                tag_ = x.tag_;
-            }
-            return *this;
-        }
-
-        // If address throws, then it can't be used in erase or the
-        // destructor, which is very limiting. I need to check up on
-        // this.
-
-        pointer address(reference r) {
-            //UNORDERED_SCOPE(allocator2::address(reference)) {
-            //    UNORDERED_EPOINT("Mock allocator2 address function.");
-            //}
-            return pointer(&r);
-        }
-
-        const_pointer address(const_reference r)  {
-            //UNORDERED_SCOPE(allocator2::address(const_reference)) {
-            //    UNORDERED_EPOINT("Mock allocator2 const address function.");
-            //}
-            return const_pointer(&r);
-        }
-
-        pointer allocate(size_type n) {
-            T* ptr = 0;
-            UNORDERED_SCOPE(allocator2::allocate(size_type)) {
-                UNORDERED_EPOINT("Mock allocator2 allocate function.");
-
-                using namespace std;
-                ptr = (T*) malloc(n * sizeof(T));
-                if(!ptr) throw std::bad_alloc();
-            }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return pointer(ptr);
-
-            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        pointer allocate(size_type n, void const*)
-        {
-            T* ptr = 0;
-            UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer)) {
-                UNORDERED_EPOINT("Mock allocator2 allocate function.");
-
-                using namespace std;
-                ptr = (T*) malloc(n * sizeof(T));
-                if(!ptr) throw std::bad_alloc();
-            }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return pointer(ptr);
-
-            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            //::operator delete((void*) p);
-            if(p) {
-                test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
-                using namespace std;
-                free(p);
-            }
-        }
-
-        void construct(pointer p, T const& t) {
-            UNORDERED_SCOPE(allocator2::construct(T*, T)) {
-                UNORDERED_EPOINT("Mock allocator2 construct function.");
-                new(p) T(t);
-            }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            UNORDERED_EPOINT("Mock allocator2 construct function.");
+            new (p) T(t);
         }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+    }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            UNORDERED_SCOPE(allocator2::construct(pointer, BOOST_FWD_REF(Args)...)) {
-                UNORDERED_EPOINT("Mock allocator2 construct function.");
-                new(p) T(boost::forward<Args>(args)...);
-            }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        UNORDERED_SCOPE(allocator2::construct(pointer, BOOST_FWD_REF(Args)...))
+        {
+            UNORDERED_EPOINT("Mock allocator2 construct function.");
+            new (p) T(boost::forward<Args>(args)...);
         }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+    }
 #endif
 
-        void destroy(T* p) {
-            test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
+    void destroy(T* p)
+    {
+        test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+    }
+
+    size_type max_size() const
+    {
+        UNORDERED_SCOPE(allocator2::construct(pointer, T))
+        {
+            UNORDERED_EPOINT("Mock allocator2 max_size function.");
         }
-
-        size_type max_size() const {
-            UNORDERED_SCOPE(allocator2::construct(pointer, T)) {
-                UNORDERED_EPOINT("Mock allocator2 max_size function.");
-            }
-            return (std::numeric_limits<std::size_t>::max)();
-        }
-
-        typedef false_type propagate_on_container_copy_assignment;
-        typedef false_type propagate_on_container_move_assignment;
-        typedef false_type propagate_on_container_swap;
-    };
-
-    template <class T>
-    void swap(allocator2<T>& x, allocator2<T>& y)
-    {
-        std::swap(x.tag_, y.tag_);
+        return (std::numeric_limits<std::size_t>::max)();
     }
 
-    // It's pretty much impossible to write a compliant swap when these
-    // two can throw. So they don't.
+    typedef false_type propagate_on_container_copy_assignment;
+    typedef false_type propagate_on_container_move_assignment;
+    typedef false_type propagate_on_container_swap;
+};
 
-    template <class T>
-    inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
-    {
-        //UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
-        //    UNORDERED_EPOINT("Mock allocator2 equality operator.");
-        //}
-        return x.tag_ == y.tag_;
-    }
+template <class T> void swap(allocator2<T>& x, allocator2<T>& y)
+{
+    std::swap(x.tag_, y.tag_);
+}
 
-    template <class T>
-    inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
-    {
-        //UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
-        //    UNORDERED_EPOINT("Mock allocator2 inequality operator.");
-        //}
-        return x.tag_ != y.tag_;
-    }
+// It's pretty much impossible to write a compliant swap when these
+// two can throw. So they don't.
+
+template <class T>
+inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
+{
+    // UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
+    //    UNORDERED_EPOINT("Mock allocator2 equality operator.");
+    //}
+    return x.tag_ == y.tag_;
+}
+
+template <class T>
+inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
+{
+    // UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
+    //    UNORDERED_EPOINT("Mock allocator2 inequality operator.");
+    //}
+    return x.tag_ != y.tag_;
+}
 }
 }
 
 // Workaround for ADL deficient compilers
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-namespace test
+namespace test {
+test::exception::object generate(
+    test::exception::object const* x, random_generator g)
 {
-    test::exception::object generate(test::exception::object const* x,
-        random_generator g) {
-        return test::exception::generate(x, g);
-    }
+    return test::exception::generate(x, g);
+}
 
-    std::pair<test::exception::object, test::exception::object> generate(std::pair<test::exception::object, test::exception::object> const* x,
-        random_generator g) {
-        return test::exception::generate(x, g);
-    }
+std::pair<test::exception::object, test::exception::object> generate(
+    std::pair<test::exception::object, test::exception::object> const* x,
+    random_generator g)
+{
+    return test::exception::generate(x, g);
+}
 }
 #endif
 
 #endif
-
diff --git a/test/objects/fwd.hpp b/test/objects/fwd.hpp
index 46e434cb..dda08892 100644
--- a/test/objects/fwd.hpp
+++ b/test/objects/fwd.hpp
@@ -6,13 +6,12 @@
 #if !defined(BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER)
 #define BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER
 
-namespace test
-{
-    class object;
-    class hash;
-    class less;
-    class equal_to;
-    template <class T> class allocator;
+namespace test {
+class object;
+class hash;
+class less;
+class equal_to;
+template <class T> class allocator;
 }
 
 #endif
diff --git a/test/objects/minimal.hpp b/test/objects/minimal.hpp
index d8e8a7eb..818560a6 100644
--- a/test/objects/minimal.hpp
+++ b/test/objects/minimal.hpp
@@ -10,13 +10,13 @@
 #if !defined(BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER)
 #define BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER
 
-#include <cstddef>
 #include <boost/move/move.hpp>
+#include <cstddef>
 #include <utility>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
+#pragma warning(disable : 4100) // unreferenced formal parameter
 #endif
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1500)
@@ -25,480 +25,494 @@
 #define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 0
 #endif
 
-namespace test
+namespace test {
+namespace minimal {
+class destructible;
+class copy_constructible;
+class copy_constructible_equality_comparable;
+class default_assignable;
+class assignable;
+
+struct ampersand_operator_used
 {
-namespace minimal
+    ampersand_operator_used() { BOOST_TEST(false); }
+};
+
+template <class T> class hash;
+template <class T> class equal_to;
+template <class T> class ptr;
+template <class T> class const_ptr;
+template <class T> class allocator;
+template <class T> class cxx11_allocator;
+
+struct constructor_param
 {
-    class destructible;
-    class copy_constructible;
-    class copy_constructible_equality_comparable;
-    class default_assignable;
-    class assignable;
+    operator int() const { return 0; }
+};
 
-    struct ampersand_operator_used {
-        ampersand_operator_used() { BOOST_TEST(false); }
-    };
+class destructible
+{
+  public:
+    destructible(constructor_param const&) {}
+    ~destructible() {}
+    void dummy_member() const {}
+  private:
+    destructible(destructible const&);
+    destructible& operator=(destructible const&);
+};
 
-    template <class T> class hash;
-    template <class T> class equal_to;
-    template <class T> class ptr;
-    template <class T> class const_ptr;
-    template <class T> class allocator;
-    template <class T> class cxx11_allocator;
+class copy_constructible
+{
+  public:
+    copy_constructible(constructor_param const&) {}
+    copy_constructible(copy_constructible const&) {}
+    ~copy_constructible() {}
+    void dummy_member() const {}
+  private:
+    copy_constructible& operator=(copy_constructible const&);
+    copy_constructible() {}
+};
 
-    struct constructor_param
+class copy_constructible_equality_comparable
+{
+  public:
+    copy_constructible_equality_comparable(constructor_param const&) {}
+
+    copy_constructible_equality_comparable(
+        copy_constructible_equality_comparable const&)
     {
-        operator int() const { return 0; }
-    };
-
-    class destructible
-    {
-    public:
-        destructible(constructor_param const&) {}
-        ~destructible() {}
-        void dummy_member() const {}
-    private:
-        destructible(destructible const&);
-        destructible& operator=(destructible const&);
-    };
-
-    class copy_constructible
-    {
-    public:
-        copy_constructible(constructor_param const&) {}
-        copy_constructible(copy_constructible const&) {}
-        ~copy_constructible() {}
-        void dummy_member() const {}
-    private:
-        copy_constructible& operator=(copy_constructible const&);
-        copy_constructible() {}
-    };
-
-    class copy_constructible_equality_comparable
-    {
-    public:
-        copy_constructible_equality_comparable(constructor_param const&) {}
-
-        copy_constructible_equality_comparable(
-            copy_constructible_equality_comparable const&)
-        {
-        }
-
-        ~copy_constructible_equality_comparable()
-        {
-        }
-
-        void dummy_member() const {}
-    private:
-        copy_constructible_equality_comparable& operator=(
-            copy_constructible_equality_comparable const&);
-        copy_constructible_equality_comparable() {}
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    bool operator==(
-        copy_constructible_equality_comparable,
-        copy_constructible_equality_comparable)
-    {
-        return true;
     }
 
-    bool operator!=(
-        copy_constructible_equality_comparable,
-        copy_constructible_equality_comparable)
+    ~copy_constructible_equality_comparable() {}
+
+    void dummy_member() const {}
+  private:
+    copy_constructible_equality_comparable& operator=(
+        copy_constructible_equality_comparable const&);
+    copy_constructible_equality_comparable() {}
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+    ampersand_operator_used operator&() const
     {
-        return false;
+        return ampersand_operator_used();
     }
+#endif
+};
 
-    class default_assignable
-    {
-    public:
-        default_assignable(constructor_param const&) {}
+bool operator==(copy_constructible_equality_comparable,
+    copy_constructible_equality_comparable)
+{
+    return true;
+}
 
-        default_assignable()
-        {
-        }
+bool operator!=(copy_constructible_equality_comparable,
+    copy_constructible_equality_comparable)
+{
+    return false;
+}
 
-        default_assignable(default_assignable const&)
-        {
-        }
+class default_assignable
+{
+  public:
+    default_assignable(constructor_param const&) {}
 
-        default_assignable& operator=(default_assignable const&)
-        {
-            return *this;
-        }
+    default_assignable() {}
 
-        ~default_assignable()
-        {
-        }
+    default_assignable(default_assignable const&) {}
 
-        void dummy_member() const {}
+    default_assignable& operator=(default_assignable const&) { return *this; }
+
+    ~default_assignable() {}
+
+    void dummy_member() const {}
 
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    class assignable
+    ampersand_operator_used operator&() const
     {
-    public:
-        assignable(constructor_param const&) {}
-        assignable(assignable const&) {}
-        assignable& operator=(assignable const&) { return *this; }
-        ~assignable() {}
-        void dummy_member() const {}
-    private:
-        assignable() {}
+        return ampersand_operator_used();
+    }
+#endif
+};
+
+class assignable
+{
+  public:
+    assignable(constructor_param const&) {}
+    assignable(assignable const&) {}
+    assignable& operator=(assignable const&) { return *this; }
+    ~assignable() {}
+    void dummy_member() const {}
+  private:
+    assignable() {}
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    struct movable_init {};
-
-    class movable1
+    ampersand_operator_used operator&() const
     {
-        BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+        return ampersand_operator_used();
+    }
+#endif
+};
 
-    public:
-        movable1(constructor_param const&) {}
-        movable1() {}
-        explicit movable1(movable_init) {}
-        movable1(BOOST_RV_REF(movable1)) {}
-        movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
-        ~movable1() {}
-        void dummy_member() const {}
-    };
+struct movable_init
+{
+};
+
+class movable1
+{
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+
+  public:
+    movable1(constructor_param const&) {}
+    movable1() {}
+    explicit movable1(movable_init) {}
+    movable1(BOOST_RV_REF(movable1)) {}
+    movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
+    ~movable1() {}
+    void dummy_member() const {}
+};
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    class movable2
-    {
-    public:
-        movable2(constructor_param const&) {}
-        explicit movable2(movable_init) {}
-        movable2(movable2&&) {}
-        ~movable2() {}
-        movable2& operator=(movable2&&) { return *this; }
-        void dummy_member() const {}
-    private:
-        movable2() {}
-        movable2(movable2 const&);
-        movable2& operator=(movable2 const&);
-    };
+class movable2
+{
+  public:
+    movable2(constructor_param const&) {}
+    explicit movable2(movable_init) {}
+    movable2(movable2&&) {}
+    ~movable2() {}
+    movable2& operator=(movable2&&) { return *this; }
+    void dummy_member() const {}
+  private:
+    movable2() {}
+    movable2(movable2 const&);
+    movable2& operator=(movable2 const&);
+};
 #else
-    typedef movable1 movable2;
+typedef movable1 movable2;
 #endif
 
-    template <class T>
-    class hash
-    {
-    public:
-        hash(constructor_param const&) {}
-        hash() {}
-        hash(hash const&) {}
-        hash& operator=(hash const&) { return *this; }
-        ~hash() {}
+template <class T> class hash
+{
+  public:
+    hash(constructor_param const&) {}
+    hash() {}
+    hash(hash const&) {}
+    hash& operator=(hash const&) { return *this; }
+    ~hash() {}
 
-        std::size_t operator()(T const&) const { return 0; }
+    std::size_t operator()(T const&) const { return 0; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    template <class T>
-    class equal_to
+    ampersand_operator_used operator&() const
     {
-    public:
-        equal_to(constructor_param const&) {}
-        equal_to() {}
-        equal_to(equal_to const&) {}
-        equal_to& operator=(equal_to const&) { return *this; }
-        ~equal_to() {}
+        return ampersand_operator_used();
+    }
+#endif
+};
 
-        bool operator()(T const&, T const&) const { return true; }
+template <class T> class equal_to
+{
+  public:
+    equal_to(constructor_param const&) {}
+    equal_to() {}
+    equal_to(equal_to const&) {}
+    equal_to& operator=(equal_to const&) { return *this; }
+    ~equal_to() {}
+
+    bool operator()(T const&, T const&) const { return true; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    template <class T> class ptr;
-    template <class T> class const_ptr;
-
-    struct void_ptr
+    ampersand_operator_used operator&() const
     {
+        return ampersand_operator_used();
+    }
+#endif
+};
+
+template <class T> class ptr;
+template <class T> class const_ptr;
+
+struct void_ptr
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class ptr;
-    private:
+    template <typename T> friend class ptr;
+
+  private:
 #endif
 
-        void* ptr_;
+    void* ptr_;
 
-    public:
-        void_ptr() : ptr_(0) {}
+  public:
+    void_ptr() : ptr_(0) {}
 
-        template <typename T>
-        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
 
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
 
-        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
+    bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+};
 
-    class void_const_ptr
-    {
+class void_const_ptr
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class const_ptr;
-    private:
+    template <typename T> friend class const_ptr;
+
+  private:
 #endif
 
-        void* ptr_;
+    void* ptr_;
 
-    public:
-        void_const_ptr() : ptr_(0) {}
+  public:
+    void_const_ptr() : ptr_(0) {}
 
-        template <typename T>
-        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
-
-    template <class T>
-    class ptr
+    template <typename T>
+    explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
     {
-        friend class allocator<T>;
-        friend class const_ptr<T>;
-        friend struct void_ptr;
+    }
 
-        T* ptr_;
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
 
-        ptr(T* x) : ptr_(x) {}
-    public:
-        ptr() : ptr_(0) {}
-        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
+    bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+};
 
-        T& operator*() const { return *ptr_; }
-        T* operator->() const { return ptr_; }
-        ptr& operator++() { ++ptr_; return *this; }
-        ptr operator++(int) { ptr tmp(*this); ++ptr_; return tmp; }
-        ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
-        friend ptr operator+(std::ptrdiff_t s, ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-        
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
+template <class T> class ptr
+{
+    friend class allocator<T>;
+    friend class const_ptr<T>;
+    friend struct void_ptr;
 
-        bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+    T* ptr_;
+
+    ptr(T* x) : ptr_(x) {}
+  public:
+    ptr() : ptr_(0) {}
+    explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+    T& operator*() const { return *ptr_; }
+    T* operator->() const { return ptr_; }
+    ptr& operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
+    ptr operator++(int)
+    {
+        ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+    }
+    ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+    friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+    T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    template <class T>
-    class const_ptr
+    ampersand_operator_used operator&() const
     {
-        friend class allocator<T>;
-        friend struct const_void_ptr;
+        return ampersand_operator_used();
+    }
+#endif
+};
 
-        T const* ptr_;
+template <class T> class const_ptr
+{
+    friend class allocator<T>;
+    friend struct const_void_ptr;
 
-        const_ptr(T const* ptr) : ptr_(ptr) {}
-    public:
-        const_ptr() : ptr_(0) {}
-        const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
+    T const* ptr_;
 
-        T const& operator*() const { return *ptr_; }
-        T const* operator->() const { return ptr_; }
-        const_ptr& operator++() { ++ptr_; return *this; }
-        const_ptr operator++(int) { const_ptr tmp(*this); ++ptr_; return tmp; }
-        const_ptr operator+(std::ptrdiff_t s) const
-            { return const_ptr(ptr_ + s); }
-        friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T const& operator[](int s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-        operator bool() const { return !!ptr_; }
+    const_ptr(T const* ptr) : ptr_(ptr) {}
+  public:
+    const_ptr() : ptr_(0) {}
+    const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
 
-        bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+    T const& operator*() const { return *ptr_; }
+    T const* operator->() const { return ptr_; }
+    const_ptr& operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
+    const_ptr operator++(int)
+    {
+        const_ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+    }
+    const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
+    friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+    {
+        return ptr<T>(s + p.ptr_);
+    }
+    T const& operator[](int s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
+    ampersand_operator_used operator&() const
+    {
+        return ampersand_operator_used();
+    }
 #endif
+};
+
+template <class T> class allocator
+{
+  public:
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef void_ptr void_pointer;
+    typedef void_const_ptr const_void_pointer;
+    typedef ptr<T> pointer;
+    typedef const_ptr<T> const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+        typedef allocator<U> other;
     };
 
-    template <class T>
-    class allocator
+    allocator() {}
+    template <class Y> allocator(allocator<Y> const&) {}
+    allocator(allocator const&) {}
+    ~allocator() {}
+
+    pointer address(reference r) { return pointer(&r); }
+    const_pointer address(const_reference r) { return const_pointer(&r); }
+
+    pointer allocate(size_type n)
     {
-    public:
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef void_ptr void_pointer;
-        typedef void_const_ptr const_void_pointer;
-        typedef ptr<T> pointer;
-        typedef const_ptr<T> const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
+        return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
 
-        template <class U> struct rebind { typedef allocator<U> other; };
+    template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+    {
+        return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
 
-        allocator() {}
-        template <class Y> allocator(allocator<Y> const&) {}
-        allocator(allocator const&) {}
-        ~allocator() {}
+    void deallocate(pointer p, size_type) { ::operator delete((void*)p.ptr_); }
 
-        pointer address(reference r) { return pointer(&r); }
-        const_pointer address(const_reference r) { return const_pointer(&r); }
-
-        pointer allocate(size_type n) {
-            return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        template <class Y>
-        pointer allocate(size_type n, const_ptr<Y>)
-        {
-            return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        void deallocate(pointer p, size_type)
-        {
-            ::operator delete((void*) p.ptr_);
-        }
-
-        void construct(T* p, T const& t) { new((void*)p) T(t); }
+    void construct(T* p, T const& t) { new ((void*)p) T(t); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            new((void*)p) T(boost::forward<Args>(args)...);
-        }
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) { p->~T(); }
+    void destroy(T* p) { p->~T(); }
 
-        size_type max_size() const { return 1000; }
+    size_type max_size() const { return 1000; }
 
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
-        BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    public: allocator& operator=(allocator const&) { return *this;}
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) ||                             \
+    BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+  public:
+    allocator& operator=(allocator const&) { return *this; }
 #else
-    private: allocator& operator=(allocator const&);
+  private:
+    allocator& operator=(allocator const&);
 #endif
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
+    ampersand_operator_used operator&() const
+    {
+        return ampersand_operator_used();
+    }
 #endif
-    };
+};
 
-    template <class T>
-    inline bool operator==(allocator<T> const&, allocator<T> const&)
+template <class T>
+inline bool operator==(allocator<T> const&, allocator<T> const&)
+{
+    return true;
+}
+
+template <class T>
+inline bool operator!=(allocator<T> const&, allocator<T> const&)
+{
+    return false;
+}
+
+template <class T> void swap(allocator<T>&, allocator<T>&) {}
+
+// C++11 allocator
+//
+// Not a fully minimal C++11 allocator, just what I support. Hopefully will
+// cut down further in the future.
+
+template <class T> class cxx11_allocator
+{
+  public:
+    typedef T value_type;
+    // template <class U> struct rebind { typedef cxx11_allocator<U> other; };
+
+    cxx11_allocator() {}
+    template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
+    cxx11_allocator(cxx11_allocator const&) {}
+    ~cxx11_allocator() {}
+
+    T* address(T& r) { return &r; }
+    T const* address(T const& r) { return &r; }
+
+    T* allocate(std::size_t n)
     {
-        return true;
+        return static_cast<T*>(::operator new(n * sizeof(T)));
     }
 
-    template <class T>
-    inline bool operator!=(allocator<T> const&, allocator<T> const&)
+    template <class Y> T* allocate(std::size_t n, const_ptr<Y>)
     {
-        return false;
+        return static_cast<T*>(::operator new(n * sizeof(T)));
     }
 
-    template <class T>
-    void swap(allocator<T>&, allocator<T>&)
-    {
-    }
+    void deallocate(T* p, std::size_t) { ::operator delete((void*)p); }
 
-    // C++11 allocator
-    //
-    // Not a fully minimal C++11 allocator, just what I support. Hopefully will
-    // cut down further in the future.
-
-    template <class T>
-    class cxx11_allocator
-    {
-    public:
-        typedef T value_type;
-        //template <class U> struct rebind { typedef cxx11_allocator<U> other; };
-
-        cxx11_allocator() {}
-        template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
-        cxx11_allocator(cxx11_allocator const&) {}
-        ~cxx11_allocator() {}
-
-        T* address(T& r) { return &r; }
-        T const* address(T const& r) { return &r; }
-
-        T* allocate(std::size_t n) {
-            return static_cast<T*>(::operator new(n * sizeof(T)));
-        }
-
-        template <class Y>
-        T* allocate(std::size_t n, const_ptr<Y>) {
-            return static_cast<T*>(::operator new(n * sizeof(T)));
-        }
-
-        void deallocate(T* p, std::size_t) {
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) { new((void*)p) T(t); }
+    void construct(T* p, T const& t) { new ((void*)p) T(t); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            new((void*)p) T(boost::forward<Args>(args)...);
-        }
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) { p->~T(); }
+    void destroy(T* p) { p->~T(); }
 
-        std::size_t max_size() const { return 1000u; }
-    };
+    std::size_t max_size() const { return 1000u; }
+};
 
-    template <class T>
-    inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-    {
-        return true;
-    }
+template <class T>
+inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+{
+    return true;
+}
 
-    template <class T>
-    inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-    {
-        return false;
-    }
+template <class T>
+inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+{
+    return false;
+}
 
-    template <class T>
-    void swap(cxx11_allocator<T>&, cxx11_allocator<T>&)
-    {
-    }
+template <class T> void swap(cxx11_allocator<T>&, cxx11_allocator<T>&) {}
 }
 }
 
@@ -508,18 +522,17 @@ namespace boost {
 namespace test {
 namespace minimal {
 #endif
-    std::size_t hash_value(
-        test::minimal::copy_constructible_equality_comparable)
-    {
-        return 1;
-    }
+std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
+{
+    return 1;
+}
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-}}
+}
+}
 #else
 }
 #endif
 
-
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif
diff --git a/test/objects/test.hpp b/test/objects/test.hpp
index 2fe4b1f3..ab346806 100644
--- a/test/objects/test.hpp
+++ b/test/objects/test.hpp
@@ -6,657 +6,675 @@
 #if !defined(BOOST_UNORDERED_TEST_OBJECTS_HEADER)
 #define BOOST_UNORDERED_TEST_OBJECTS_HEADER
 
+#include "../helpers/count.hpp"
+#include "../helpers/fwd.hpp"
+#include "../helpers/memory.hpp"
 #include <boost/config.hpp>
 #include <boost/limits.hpp>
 #include <cstddef>
-#include "../helpers/fwd.hpp"
-#include "../helpers/count.hpp"
-#include "../helpers/memory.hpp"
 
-namespace test
+namespace test {
+// Note that the default hash function will work for any equal_to (but not
+// very well).
+class object;
+class movable;
+class implicitly_convertible;
+class hash;
+class less;
+class equal_to;
+template <class T> class allocator1;
+template <class T> class allocator2;
+object generate(object const*, random_generator);
+movable generate(movable const*, random_generator);
+implicitly_convertible generate(
+    implicitly_convertible const*, random_generator);
+
+inline void ignore_variable(void const*) {}
+
+class object : private counted_object
 {
-    // Note that the default hash function will work for any equal_to (but not
-    // very well).
-    class object;
-    class movable;
-    class implicitly_convertible;
-    class hash;
-    class less;
-    class equal_to;
-    template <class T> class allocator1;
-    template <class T> class allocator2;
-    object generate(object const*, random_generator);
-    movable generate(movable const*, random_generator);
-    implicitly_convertible generate(implicitly_convertible const*, random_generator);
+    friend class hash;
+    friend class equal_to;
+    friend class less;
+    int tag1_, tag2_;
 
-    inline void ignore_variable(void const*) {}
+  public:
+    explicit object(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
 
-    class object : private counted_object
+    ~object()
     {
-        friend class hash;
-        friend class equal_to;
-        friend class less;
-        int tag1_, tag2_;
-    public:
-        explicit object(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
-
-        ~object() {
-            tag1_ = -1;
-            tag2_ = -1;
-        }
-
-        friend bool operator==(object const& x1, object const& x2) {
-            return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
-        }
-
-        friend bool operator!=(object const& x1, object const& x2) {
-            return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
-        }
-
-        friend bool operator<(object const& x1, object const& x2) {
-            return x1.tag1_ < x2.tag1_ ||
-                (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
-        }
-
-        friend object generate(object const*, random_generator g) {
-            int* x = 0;
-            return object(generate(x, g), generate(x, g));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, object const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
-    class movable : private counted_object
-    {
-        friend class hash;
-        friend class equal_to;
-        friend class less;
-        int tag1_, tag2_;
-        
-        BOOST_COPYABLE_AND_MOVABLE(movable)
-    public:
-        explicit movable(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
-        
-        movable(movable const& x) :
-            counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
-        {
-            BOOST_TEST(x.tag1_ != -1);
-        }
-        
-        movable(BOOST_RV_REF(movable) x) :
-            counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
-        {
-            BOOST_TEST(x.tag1_ != -1);
-            x.tag1_ = -1;
-            x.tag2_ = -1;
-        }
-
-        movable& operator=(BOOST_COPY_ASSIGN_REF(movable) x) // Copy assignment
-        {
-            BOOST_TEST(x.tag1_ != -1);
-            tag1_ = x.tag1_;
-            tag2_ = x.tag2_;
-            return *this;
-        }
-
-        movable& operator=(BOOST_RV_REF(movable) x) //Move assignment
-        {
-            BOOST_TEST(x.tag1_ != -1);
-            tag1_ = x.tag1_;
-            tag2_ = x.tag2_;
-            x.tag1_ = -1;
-            x.tag2_ = -1;
-            return *this;
-        }
-
-        ~movable() {
-            tag1_ = -1;
-            tag2_ = -1;
-        }
-
-        friend bool operator==(movable const& x1, movable const& x2) {
-            BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
-            return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
-        }
-
-        friend bool operator!=(movable const& x1, movable const& x2) {
-            BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
-            return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
-        }
-
-        friend bool operator<(movable const& x1, movable const& x2) {
-            BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
-            return x1.tag1_ < x2.tag1_ ||
-                (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
-        }
-
-        friend movable generate(movable const*, random_generator g) {
-            int* x = 0;
-            return movable(generate(x, g), generate(x, g));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, movable const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
-    class implicitly_convertible : private counted_object
-    {
-        int tag1_, tag2_;
-    public:
-
-        explicit implicitly_convertible(int t1 = 0, int t2 = 0)
-            : tag1_(t1), tag2_(t2)
-            {}
-
-        operator object() const
-        {
-            return object(tag1_, tag2_);
-        }
-
-        operator movable() const
-        {
-            return movable(tag1_, tag2_);
-        }
-
-        friend implicitly_convertible generate(implicitly_convertible const*, random_generator g) {
-            int* x = 0;
-            return implicitly_convertible(generate(x, g), generate(x, g));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, implicitly_convertible const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
-    // Note: This is a deliberately bad hash function.
-    class hash
-    {
-        int type_;
-    public:
-        explicit hash(int t = 0) : type_(t) {}
-
-        std::size_t operator()(object const& x) const {
-            int result;
-            switch(type_) {
-            case 1:
-                result = x.tag1_;
-                break;
-            case 2:
-                result = x.tag2_;
-                break;
-            default:
-                result = x.tag1_ + x.tag2_; 
-            }
-            return static_cast<std::size_t>(result);
-        }
-
-        std::size_t operator()(movable const& x) const {
-            int result;
-            switch(type_) {
-            case 1:
-                result = x.tag1_;
-                break;
-            case 2:
-                result = x.tag2_;
-                break;
-            default:
-                result = x.tag1_ + x.tag2_; 
-            }
-            return static_cast<std::size_t>(result);
-        }
-
-        std::size_t operator()(int x) const {
-            int result;
-            switch(type_) {
-            case 1:
-                result = x;
-                break;
-            case 2:
-                result = x * 7;
-                break;
-            default:
-                result = x * 256; 
-            }
-            return static_cast<std::size_t>(result);
-        }
-
-        friend bool operator==(hash const& x1, hash const& x2) {
-            return x1.type_ == x2.type_;
-        }
-
-        friend bool operator!=(hash const& x1, hash const& x2) {
-            return x1.type_ != x2.type_;
-        }
-    };
-    
-    std::size_t hash_value(test::object const& x) {
-        return hash()(x);
+        tag1_ = -1;
+        tag2_ = -1;
     }
 
-    std::size_t hash_value(test::movable const& x) {
-        return hash()(x);
+    friend bool operator==(object const& x1, object const& x2)
+    {
+        return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
     }
 
-    class less
+    friend bool operator!=(object const& x1, object const& x2)
     {
-        int type_;
-    public:
-        explicit less(int t = 0) : type_(t) {}
+        return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
+    }
 
-        bool operator()(object const& x1, object const& x2) const {
-            switch(type_) {
-            case 1:
-                return x1.tag1_ < x2.tag1_;
-            case 2:
-                return x1.tag2_ < x2.tag2_;
-            default:
-                return x1 < x2;
-            }
+    friend bool operator<(object const& x1, object const& x2)
+    {
+        return x1.tag1_ < x2.tag1_ ||
+               (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+    }
+
+    friend object generate(object const*, random_generator g)
+    {
+        int* x = 0;
+        return object(generate(x, g), generate(x, g));
+    }
+
+    friend std::ostream& operator<<(std::ostream& out, object const& o)
+    {
+        return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+};
+
+class movable : private counted_object
+{
+    friend class hash;
+    friend class equal_to;
+    friend class less;
+    int tag1_, tag2_;
+
+    BOOST_COPYABLE_AND_MOVABLE(movable)
+  public:
+    explicit movable(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
+
+    movable(movable const& x)
+        : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+    {
+        BOOST_TEST(x.tag1_ != -1);
+    }
+
+    movable(BOOST_RV_REF(movable) x)
+        : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+    {
+        BOOST_TEST(x.tag1_ != -1);
+        x.tag1_ = -1;
+        x.tag2_ = -1;
+    }
+
+    movable& operator=(BOOST_COPY_ASSIGN_REF(movable) x) // Copy assignment
+    {
+        BOOST_TEST(x.tag1_ != -1);
+        tag1_ = x.tag1_;
+        tag2_ = x.tag2_;
+        return *this;
+    }
+
+    movable& operator=(BOOST_RV_REF(movable) x) // Move assignment
+    {
+        BOOST_TEST(x.tag1_ != -1);
+        tag1_ = x.tag1_;
+        tag2_ = x.tag2_;
+        x.tag1_ = -1;
+        x.tag2_ = -1;
+        return *this;
+    }
+
+    ~movable()
+    {
+        tag1_ = -1;
+        tag2_ = -1;
+    }
+
+    friend bool operator==(movable const& x1, movable const& x2)
+    {
+        BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+        return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+    }
+
+    friend bool operator!=(movable const& x1, movable const& x2)
+    {
+        BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+        return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
+    }
+
+    friend bool operator<(movable const& x1, movable const& x2)
+    {
+        BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+        return x1.tag1_ < x2.tag1_ ||
+               (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+    }
+
+    friend movable generate(movable const*, random_generator g)
+    {
+        int* x = 0;
+        return movable(generate(x, g), generate(x, g));
+    }
+
+    friend std::ostream& operator<<(std::ostream& out, movable const& o)
+    {
+        return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+};
+
+class implicitly_convertible : private counted_object
+{
+    int tag1_, tag2_;
+
+  public:
+    explicit implicitly_convertible(int t1 = 0, int t2 = 0)
+        : tag1_(t1), tag2_(t2)
+    {
+    }
+
+    operator object() const { return object(tag1_, tag2_); }
+
+    operator movable() const { return movable(tag1_, tag2_); }
+
+    friend implicitly_convertible generate(
+        implicitly_convertible const*, random_generator g)
+    {
+        int* x = 0;
+        return implicitly_convertible(generate(x, g), generate(x, g));
+    }
+
+    friend std::ostream& operator<<(
+        std::ostream& out, implicitly_convertible const& o)
+    {
+        return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+};
+
+// Note: This is a deliberately bad hash function.
+class hash
+{
+    int type_;
+
+  public:
+    explicit hash(int t = 0) : type_(t) {}
+
+    std::size_t operator()(object const& x) const
+    {
+        int result;
+        switch (type_) {
+        case 1:
+            result = x.tag1_;
+            break;
+        case 2:
+            result = x.tag2_;
+            break;
+        default:
+            result = x.tag1_ + x.tag2_;
         }
+        return static_cast<std::size_t>(result);
+    }
 
-        bool operator()(movable const& x1, movable const& x2) const {
-            switch(type_) {
-            case 1:
-                return x1.tag1_ < x2.tag1_;
-            case 2:
-                return x1.tag2_ < x2.tag2_;
-            default:
-                return x1 < x2;
-            }
+    std::size_t operator()(movable const& x) const
+    {
+        int result;
+        switch (type_) {
+        case 1:
+            result = x.tag1_;
+            break;
+        case 2:
+            result = x.tag2_;
+            break;
+        default:
+            result = x.tag1_ + x.tag2_;
         }
+        return static_cast<std::size_t>(result);
+    }
 
-        std::size_t operator()(int x1, int x2) const {
+    std::size_t operator()(int x) const
+    {
+        int result;
+        switch (type_) {
+        case 1:
+            result = x;
+            break;
+        case 2:
+            result = x * 7;
+            break;
+        default:
+            result = x * 256;
+        }
+        return static_cast<std::size_t>(result);
+    }
+
+    friend bool operator==(hash const& x1, hash const& x2)
+    {
+        return x1.type_ == x2.type_;
+    }
+
+    friend bool operator!=(hash const& x1, hash const& x2)
+    {
+        return x1.type_ != x2.type_;
+    }
+};
+
+std::size_t hash_value(test::object const& x) { return hash()(x); }
+
+std::size_t hash_value(test::movable const& x) { return hash()(x); }
+
+class less
+{
+    int type_;
+
+  public:
+    explicit less(int t = 0) : type_(t) {}
+
+    bool operator()(object const& x1, object const& x2) const
+    {
+        switch (type_) {
+        case 1:
+            return x1.tag1_ < x2.tag1_;
+        case 2:
+            return x1.tag2_ < x2.tag2_;
+        default:
             return x1 < x2;
         }
+    }
 
-        friend bool operator==(less const& x1, less const& x2) {
-            return x1.type_ == x2.type_;
-        }
-    };
-
-    class equal_to
+    bool operator()(movable const& x1, movable const& x2) const
     {
-        int type_;
-    public:
-        explicit equal_to(int t = 0) : type_(t) {}
-
-        bool operator()(object const& x1, object const& x2) const {
-            switch(type_) {
-            case 1:
-                return x1.tag1_ == x2.tag1_;
-            case 2:
-                return x1.tag2_ == x2.tag2_;
-            default:
-                return x1 == x2;
-            }
+        switch (type_) {
+        case 1:
+            return x1.tag1_ < x2.tag1_;
+        case 2:
+            return x1.tag2_ < x2.tag2_;
+        default:
+            return x1 < x2;
         }
+    }
 
-        bool operator()(movable const& x1, movable const& x2) const {
-            switch(type_) {
-            case 1:
-                return x1.tag1_ == x2.tag1_;
-            case 2:
-                return x1.tag2_ == x2.tag2_;
-            default:
-                return x1 == x2;
-            }
-        }
+    std::size_t operator()(int x1, int x2) const { return x1 < x2; }
 
-        std::size_t operator()(int x1, int x2) const {
+    friend bool operator==(less const& x1, less const& x2)
+    {
+        return x1.type_ == x2.type_;
+    }
+};
+
+class equal_to
+{
+    int type_;
+
+  public:
+    explicit equal_to(int t = 0) : type_(t) {}
+
+    bool operator()(object const& x1, object const& x2) const
+    {
+        switch (type_) {
+        case 1:
+            return x1.tag1_ == x2.tag1_;
+        case 2:
+            return x1.tag2_ == x2.tag2_;
+        default:
             return x1 == x2;
         }
+    }
 
-        friend bool operator==(equal_to const& x1, equal_to const& x2) {
-            return x1.type_ == x2.type_;
+    bool operator()(movable const& x1, movable const& x2) const
+    {
+        switch (type_) {
+        case 1:
+            return x1.tag1_ == x2.tag1_;
+        case 2:
+            return x1.tag2_ == x2.tag2_;
+        default:
+            return x1 == x2;
         }
+    }
 
-        friend bool operator!=(equal_to const& x1, equal_to const& x2) {
-            return x1.type_ != x2.type_;
-        }
+    std::size_t operator()(int x1, int x2) const { return x1 == x2; }
 
-        friend less create_compare(equal_to x) {
-            return less(x.type_);
-        }
+    friend bool operator==(equal_to const& x1, equal_to const& x2)
+    {
+        return x1.type_ == x2.type_;
+    }
+
+    friend bool operator!=(equal_to const& x1, equal_to const& x2)
+    {
+        return x1.type_ != x2.type_;
+    }
+
+    friend less create_compare(equal_to x) { return less(x.type_); }
+};
+
+// allocator1 only has the old fashioned 'construct' method and has
+// a few less typedefs. allocator2 uses a custom pointer class.
+
+template <class T> class allocator1
+{
+  public:
+    int tag_;
+
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+        typedef allocator1<U> other;
     };
 
-    // allocator1 only has the old fashioned 'construct' method and has
-    // a few less typedefs. allocator2 uses a custom pointer class.
-
-    template <class T>
-    class allocator1
+    explicit allocator1(int t = 0) : tag_(t)
     {
-    public:
-        int tag_;
+        detail::tracker.allocator_ref();
+    }
 
-        typedef T value_type;
+    template <class Y> allocator1(allocator1<Y> const& x) : tag_(x.tag_)
+    {
+        detail::tracker.allocator_ref();
+    }
 
-        template <class U> struct rebind { typedef allocator1<U> other; };
+    allocator1(allocator1 const& x) : tag_(x.tag_)
+    {
+        detail::tracker.allocator_ref();
+    }
 
-        explicit allocator1(int t = 0) : tag_(t)
-        {
-            detail::tracker.allocator_ref();
-        }
+    ~allocator1() { detail::tracker.allocator_unref(); }
 
-        template <class Y> allocator1(allocator1<Y> const& x)
-            : tag_(x.tag_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    T* allocate(std::size_t n)
+    {
+        T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        allocator1(allocator1 const& x)
-            : tag_(x.tag_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    T* allocate(std::size_t n, void const*)
+    {
+        T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        ~allocator1()
-        {
-            detail::tracker.allocator_unref();
-        }
+    void deallocate(T* p, std::size_t n)
+    {
+        detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+        ::operator delete((void*)p);
+    }
 
-        T* allocate(std::size_t n) {
-            T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
+    void construct(T* p, T const& t)
+    {
+        // Don't count constructions here as it isn't always called.
+        // detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+        new (p) T(t);
+    }
 
-        T* allocate(std::size_t n, void const*)
-        {
-            T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
+    void destroy(T* p)
+    {
+        // detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
+        p->~T();
 
-        void deallocate(T* p, std::size_t n)
-        {
-            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
-            ::operator delete((void*) p);
-        }
+        // Work around MSVC buggy unused parameter warning.
+        ignore_variable(&p);
+    }
 
-        void construct(T* p, T const& t) {
-            // Don't count constructions here as it isn't always called.
-            //detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(t);
-        }
+    bool operator==(allocator1 const& x) const { return tag_ == x.tag_; }
 
-        void destroy(T* p) {
-            //detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
+    bool operator!=(allocator1 const& x) const { return tag_ != x.tag_; }
 
-            // Work around MSVC buggy unused parameter warning.
-            ignore_variable(&p);
-        }
-
-        bool operator==(allocator1 const& x) const
-        {
-            return tag_ == x.tag_;
-        }
-
-        bool operator!=(allocator1 const& x) const
-        {
-            return tag_ != x.tag_;
-        }
-
-        enum {
-            is_select_on_copy = false,
-            is_propagate_on_swap = false,
-            is_propagate_on_assign = false,
-            is_propagate_on_move = false
-        };
+    enum
+    {
+        is_select_on_copy = false,
+        is_propagate_on_swap = false,
+        is_propagate_on_assign = false,
+        is_propagate_on_move = false
     };
+};
 
-    template <class T> class ptr;
-    template <class T> class const_ptr;
+template <class T> class ptr;
+template <class T> class const_ptr;
 
-    struct void_ptr
-    {
+struct void_ptr
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class ptr;
-    private:
+    template <typename T> friend class ptr;
+
+  private:
 #endif
 
-        void* ptr_;
+    void* ptr_;
 
-    public:
-        void_ptr() : ptr_(0) {}
+  public:
+    void_ptr() : ptr_(0) {}
 
-        template <typename T>
-        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
 
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
 
-        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
+    bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+};
 
-    class void_const_ptr
-    {
+class void_const_ptr
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class const_ptr;
-    private:
+    template <typename T> friend class const_ptr;
+
+  private:
 #endif
 
-        void* ptr_;
+    void* ptr_;
 
-    public:
-        void_const_ptr() : ptr_(0) {}
+  public:
+    void_const_ptr() : ptr_(0) {}
 
-        template <typename T>
-        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
+    template <typename T>
+    explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
+    {
+    }
 
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
 
-        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+};
+
+template <class T> class ptr
+{
+    friend class allocator2<T>;
+    friend class const_ptr<T>;
+    friend struct void_ptr;
+
+    T* ptr_;
+
+    ptr(T* x) : ptr_(x) {}
+  public:
+    ptr() : ptr_(0) {}
+    explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+    T& operator*() const { return *ptr_; }
+    T* operator->() const { return ptr_; }
+    ptr& operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
+    ptr operator++(int)
+    {
+        ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+    }
+    ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+    friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+    T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+};
+
+template <class T> class const_ptr
+{
+    friend class allocator2<T>;
+    friend struct const_void_ptr;
+
+    T const* ptr_;
+
+    const_ptr(T const* ptr) : ptr_(ptr) {}
+  public:
+    const_ptr() : ptr_(0) {}
+    const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
+
+    T const& operator*() const { return *ptr_; }
+    T const* operator->() const { return ptr_; }
+    const_ptr& operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
+    const_ptr operator++(int)
+    {
+        const_ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+    }
+    const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
+    friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+    {
+        return ptr<T>(s + p.ptr_);
+    }
+    T const& operator[](int s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+};
+
+template <class T> class allocator2
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+  public:
+#else
+    template <class> friend class allocator2;
+#endif
+    int tag_;
+
+  public:
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef void_ptr void_pointer;
+    typedef void_const_ptr const_void_pointer;
+    typedef ptr<T> pointer;
+    typedef const_ptr<T> const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+        typedef allocator2<U> other;
     };
 
-    template <class T>
-    class ptr
+    explicit allocator2(int t = 0) : tag_(t)
     {
-        friend class allocator2<T>;
-        friend class const_ptr<T>;
-        friend struct void_ptr;
+        detail::tracker.allocator_ref();
+    }
 
-        T* ptr_;
-
-        ptr(T* x) : ptr_(x) {}
-    public:
-        ptr() : ptr_(0) {}
-        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
-
-        T& operator*() const { return *ptr_; }
-        T* operator->() const { return ptr_; }
-        ptr& operator++() { ++ptr_; return *this; }
-        ptr operator++(int) { ptr tmp(*this); ++ptr_; return tmp; }
-        ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
-        friend ptr operator+(std::ptrdiff_t s, ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
-    };
-
-    template <class T>
-    class const_ptr
+    template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
     {
-        friend class allocator2<T>;
-        friend struct const_void_ptr;
+        detail::tracker.allocator_ref();
+    }
 
-        T const* ptr_;
-
-        const_ptr(T const* ptr) : ptr_(ptr) {}
-    public:
-        const_ptr() : ptr_(0) {}
-        const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
-
-        T const& operator*() const { return *ptr_; }
-        T const* operator->() const { return ptr_; }
-        const_ptr& operator++() { ++ptr_; return *this; }
-        const_ptr operator++(int) { const_ptr tmp(*this); ++ptr_; return tmp; }
-        const_ptr operator+(std::ptrdiff_t s) const
-            { return const_ptr(ptr_ + s); }
-        friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T const& operator[](int s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
-    };
-
-    template <class T>
-    class allocator2
+    allocator2(allocator2 const& x) : tag_(x.tag_)
     {
-# ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-    public:
-# else
-        template <class> friend class allocator2;
-# endif
-        int tag_;
-    public:
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef void_ptr void_pointer;
-        typedef void_const_ptr const_void_pointer;
-        typedef ptr<T> pointer;
-        typedef const_ptr<T> const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
+        detail::tracker.allocator_ref();
+    }
 
-        template <class U> struct rebind { typedef allocator2<U> other; };
+    ~allocator2() { detail::tracker.allocator_unref(); }
 
-        explicit allocator2(int t = 0) : tag_(t)
-        {
-            detail::tracker.allocator_ref();
-        }
-        
-        template <class Y> allocator2(allocator2<Y> const& x)
-            : tag_(x.tag_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    pointer address(reference r) { return pointer(&r); }
 
-        allocator2(allocator2 const& x)
-            : tag_(x.tag_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    const_pointer address(const_reference r) { return const_pointer(&r); }
 
-        ~allocator2()
-        {
-            detail::tracker.allocator_unref();
-        }
+    pointer allocate(size_type n)
+    {
+        pointer p(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)p.ptr_, n, sizeof(T), tag_);
+        return p;
+    }
 
-        pointer address(reference r)
-        {
-            return pointer(&r);
-        }
+    pointer allocate(size_type n, void const*)
+    {
+        pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        const_pointer address(const_reference r)
-        {
-            return const_pointer(&r);
-        }
+    void deallocate(pointer p, size_type n)
+    {
+        detail::tracker.track_deallocate((void*)p.ptr_, n, sizeof(T), tag_);
+        ::operator delete((void*)p.ptr_);
+    }
 
-        pointer allocate(size_type n) {
-            pointer p(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) p.ptr_, n, sizeof(T), tag_);
-            return p;
-        }
-
-        pointer allocate(size_type n, void const*)
-        {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            detail::tracker.track_deallocate((void*) p.ptr_, n, sizeof(T), tag_);
-            ::operator delete((void*) p.ptr_);
-        }
-
-        void construct(T* p, T const& t) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(t);
-        }
+    void construct(T* p, T const& t)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(t);
+    }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(boost::forward<Args>(args)...);
-        }
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) {
-            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-        }
+    void destroy(T* p)
+    {
+        detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+    }
 
-        size_type max_size() const {
-            return (std::numeric_limits<size_type>::max)();
-        }
+    size_type max_size() const
+    {
+        return (std::numeric_limits<size_type>::max)();
+    }
 
-        bool operator==(allocator2 const& x) const
-        {
-            return tag_ == x.tag_;
-        }
+    bool operator==(allocator2 const& x) const { return tag_ == x.tag_; }
 
-        bool operator!=(allocator2 const& x) const
-        {
-            return tag_ != x.tag_;
-        }
+    bool operator!=(allocator2 const& x) const { return tag_ != x.tag_; }
 
-        enum {
-            is_select_on_copy = false,
-            is_propagate_on_swap = false,
-            is_propagate_on_assign = false,
-            is_propagate_on_move = false
-        };
+    enum
+    {
+        is_select_on_copy = false,
+        is_propagate_on_swap = false,
+        is_propagate_on_assign = false,
+        is_propagate_on_move = false
     };
+};
 
-    template <class T>
-    bool equivalent_impl(allocator1<T> const& x, allocator1<T> const& y,
-        test::derived_type)
-    {
-        return x == y;
-    }
+template <class T>
+bool equivalent_impl(
+    allocator1<T> const& x, allocator1<T> const& y, test::derived_type)
+{
+    return x == y;
+}
 
-    template <class T>
-    bool equivalent_impl(allocator2<T> const& x, allocator2<T> const& y,
-        test::derived_type)
-    {
-        return x == y;
-    }
+template <class T>
+bool equivalent_impl(
+    allocator2<T> const& x, allocator2<T> const& y, test::derived_type)
+{
+    return x == y;
+}
 }
 
 #endif
diff --git a/test/unordered/allocator_traits.cpp b/test/unordered/allocator_traits.cpp
index d36d85b7..dac415c4 100644
--- a/test/unordered/allocator_traits.cpp
+++ b/test/unordered/allocator_traits.cpp
@@ -3,71 +3,93 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/unordered/detail/implementation.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/unordered/detail/implementation.hpp>
 
 // Boilerplate
 
-#define ALLOCATOR_METHODS(name)                                             \
-    template <typename U> struct rebind {                                   \
-        typedef name<U> other;                                              \
-    };                                                                      \
-                                                                            \
-    name() {}                                                               \
-    template <typename Y> name(name<Y> const&) {}                           \
-    T* address(T& r) { return &r;}                                          \
-    T const* address(T const& r) { return &r; }                             \
-    T* allocate(std::size_t n)                                              \
-    { return static_cast<T*>(::operator new(n * sizeof(T))); }              \
-    T* allocate(std::size_t n, void const*)                                 \
-    { return static_cast<T*>(::operator new(n * sizeof(T))); }              \
-    void deallocate(T* p, std::size_t) { ::operator delete((void*) p); }    \
-    void construct(T* p, T const& t) { new(p) T(t); }                       \
-    void destroy(T* p) { p->~T(); }                                         \
-    std::size_t max_size() const                                            \
-    { return (std::numeric_limits<std::size_t>::max)(); }                   \
-    bool operator==(name<T> const&) { return true; }                        \
-    bool operator!=(name<T> const&) { return false; }                       \
+#define ALLOCATOR_METHODS(name)                                                \
+    template <typename U> struct rebind                                        \
+    {                                                                          \
+        typedef name<U> other;                                                 \
+    };                                                                         \
+                                                                               \
+    name() {}                                                                  \
+    template <typename Y> name(name<Y> const&) {}                              \
+    T* address(T& r) { return &r; }                                            \
+    T const* address(T const& r) { return &r; }                                \
+    T* allocate(std::size_t n)                                                 \
+    {                                                                          \
+        return static_cast<T*>(::operator new(n * sizeof(T)));                 \
+    }                                                                          \
+    T* allocate(std::size_t n, void const*)                                    \
+    {                                                                          \
+        return static_cast<T*>(::operator new(n * sizeof(T)));                 \
+    }                                                                          \
+    void deallocate(T* p, std::size_t) { ::operator delete((void*)p); }        \
+    void construct(T* p, T const& t) { new (p) T(t); }                         \
+    void destroy(T* p) { p->~T(); }                                            \
+    std::size_t max_size() const                                               \
+    {                                                                          \
+        return (std::numeric_limits<std::size_t>::max)();                      \
+    }                                                                          \
+    bool operator==(name<T> const&) { return true; }                           \
+    bool operator!=(name<T> const&) { return false; }                          \
 /**/
 
-#define ALLOCATOR_METHODS_TYPEDEFS(name)                                    \
-    template <typename U> struct rebind {                                   \
-        typedef name<U> other;                                              \
-    };                                                                      \
-                                                                            \
-    name() {}                                                               \
-    template <typename Y> name(name<Y> const&) {}                           \
-    pointer address(T& r) { return &r;}                                     \
-    const_pointer address(T const& r) { return &r; }                        \
-    pointer allocate(std::size_t n)                                         \
-    { return pointer(::operator new(n * sizeof(T))); }                      \
-    pointer allocate(std::size_t n, void const*)                            \
-    { return pointer(::operator new(n * sizeof(T))); }                      \
-    void deallocate(pointer p, std::size_t)                                 \
-    { ::operator delete((void*) p); }                                       \
-    void construct(T* p, T const& t) { new(p) T(t); }                       \
-    void destroy(T* p) { p->~T(); }                                         \
-    size_type max_size() const                                              \
-    { return (std::numeric_limits<size_type>::max)(); }                     \
-    bool operator==(name<T> const&) { return true; }                        \
-    bool operator!=(name<T> const&) { return false; }                       \
+#define ALLOCATOR_METHODS_TYPEDEFS(name)                                       \
+    template <typename U> struct rebind                                        \
+    {                                                                          \
+        typedef name<U> other;                                                 \
+    };                                                                         \
+                                                                               \
+    name() {}                                                                  \
+    template <typename Y> name(name<Y> const&) {}                              \
+    pointer address(T& r) { return &r; }                                       \
+    const_pointer address(T const& r) { return &r; }                           \
+    pointer allocate(std::size_t n)                                            \
+    {                                                                          \
+        return pointer(::operator new(n * sizeof(T)));                         \
+    }                                                                          \
+    pointer allocate(std::size_t n, void const*)                               \
+    {                                                                          \
+        return pointer(::operator new(n * sizeof(T)));                         \
+    }                                                                          \
+    void deallocate(pointer p, std::size_t) { ::operator delete((void*)p); }   \
+    void construct(T* p, T const& t) { new (p) T(t); }                         \
+    void destroy(T* p) { p->~T(); }                                            \
+    size_type max_size() const                                                 \
+    {                                                                          \
+        return (std::numeric_limits<size_type>::max)();                        \
+    }                                                                          \
+    bool operator==(name<T> const&) { return true; }                           \
+    bool operator!=(name<T> const&) { return false; }                          \
 /**/
 
-struct yes_type { enum { value = true }; };
-struct no_type { enum { value = false }; };
+struct yes_type
+{
+    enum
+    {
+        value = true
+    };
+};
+struct no_type
+{
+    enum
+    {
+        value = false
+    };
+};
 
 // For tracking calls...
 
 static int selected;
-void reset() {
-    selected = 0;
-}
+void reset() { selected = 0; }
 
-template <typename Allocator>
-int call_select()
+template <typename Allocator> int call_select()
 {
     typedef boost::unordered::detail::allocator_traits<Allocator> traits;
     Allocator a;
@@ -79,8 +101,7 @@ int call_select()
 
 // Empty allocator test
 
-template <typename T>
-struct empty_allocator
+template <typename T> struct empty_allocator
 {
     typedef T value_type;
     ALLOCATOR_METHODS(empty_allocator)
@@ -94,11 +115,14 @@ void test_empty_allocator()
     BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
         std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::size_type, std::size_t>::value));
 #endif
-    BOOST_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, int const*>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::const_pointer, int const*>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
     BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
@@ -108,17 +132,17 @@ void test_empty_allocator()
 
 // allocator 1
 
-template <typename T>
-struct allocator1
+template <typename T> struct allocator1
 {
     typedef T value_type;
     ALLOCATOR_METHODS(allocator1)
-    
+
     typedef yes_type propagate_on_container_copy_assignment;
     typedef yes_type propagate_on_container_move_assignment;
     typedef yes_type propagate_on_container_swap;
-    
-    allocator1<T> select_on_container_copy_construction() const {
+
+    allocator1<T> select_on_container_copy_construction() const
+    {
         ++selected;
         return allocator1<T>();
     }
@@ -132,11 +156,14 @@ void test_allocator1()
     BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
         std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::size_type, std::size_t>::value));
 #endif
-    BOOST_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, int const*>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::const_pointer, int const*>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
     BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
     BOOST_TEST(traits::propagate_on_container_move_assignment::value);
@@ -146,25 +173,24 @@ void test_allocator1()
 
 // allocator 2
 
-template <typename Alloc>
-struct allocator2_base
+template <typename Alloc> struct allocator2_base
 {
-    Alloc select_on_container_copy_construction() const {
+    Alloc select_on_container_copy_construction() const
+    {
         ++selected;
         return Alloc();
     }
 };
 
-template <typename T>
-struct allocator2 : allocator2_base<allocator2<T> >
+template <typename T> struct allocator2 : allocator2_base<allocator2<T> >
 {
     typedef T value_type;
     typedef T* pointer;
     typedef T const* const_pointer;
     typedef std::size_t size_type;
-    
+
     ALLOCATOR_METHODS(allocator2)
-    
+
     typedef no_type propagate_on_container_copy_assignment;
     typedef no_type propagate_on_container_move_assignment;
     typedef no_type propagate_on_container_swap;
@@ -174,10 +200,13 @@ void test_allocator2()
 {
     typedef allocator2<int> allocator;
     typedef boost::unordered::detail::allocator_traits<allocator> traits;
-    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::size_type, std::size_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, int const*>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::const_pointer, int const*>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
     BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
@@ -187,31 +216,27 @@ void test_allocator2()
 
 // allocator 3
 
-template <typename T>
-struct ptr
+template <typename T> struct ptr
 {
     T* value_;
-    
-    ptr(void* v) : value_((T*) v) {}
+
+    ptr(void* v) : value_((T*)v) {}
     T& operator*() const { return *value_; }
 };
 
-template <>
-struct ptr<void>
+template <> struct ptr<void>
 {
     void* value_;
     ptr(void* v) : value_(v) {}
 };
 
-template <>
-struct ptr<const void>
+template <> struct ptr<const void>
 {
     void const* value_;
     ptr(void const* v) : value_(v) {}
 };
 
-template <typename T>
-struct allocator3
+template <typename T> struct allocator3
 {
     typedef T value_type;
     typedef ptr<T> pointer;
@@ -219,11 +244,12 @@ struct allocator3
     typedef unsigned short size_type;
 
     ALLOCATOR_METHODS_TYPEDEFS(allocator3)
-    
+
     typedef yes_type propagate_on_container_copy_assignment;
     typedef no_type propagate_on_container_move_assignment;
 
-    allocator3<T> select_on_container_copy_construction() const {
+    allocator3<T> select_on_container_copy_construction() const
+    {
         ++selected;
         return allocator3<T>();
     }
@@ -233,10 +259,13 @@ void test_allocator3()
 {
     typedef allocator3<int> allocator;
     typedef boost::unordered::detail::allocator_traits<allocator> traits;
-    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, unsigned short>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::size_type, unsigned short>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, ptr<int> >::value));
-    BOOST_STATIC_ASSERT((boost::is_same<traits::const_pointer, ptr<int const> >::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<traits::const_pointer, ptr<int const> >::value));
     BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
     BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
diff --git a/test/unordered/assign_tests.cpp b/test/unordered/assign_tests.cpp
index 8dc6786e..f0e3aaae 100644
--- a/test/unordered/assign_tests.cpp
+++ b/test/unordered/assign_tests.cpp
@@ -20,20 +20,19 @@
 #include <iostream>
 
 #if defined(BOOST_MSVC)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 #endif
 
 namespace assign_tests {
 
 test::seed_t initialize_seed(96785);
 
-template <class T>
-void assign_tests1(T*, test::random_generator generator)
+template <class T> void assign_tests1(T*, test::random_generator generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
 
-    std::cerr<<"assign_tests1.1\n";
+    std::cerr << "assign_tests1.1\n";
     {
         test::check_instances check_;
 
@@ -44,7 +43,7 @@ void assign_tests1(T*, test::random_generator generator)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
     }
 
-    std::cerr<<"assign_tests1.2\n";
+    std::cerr << "assign_tests1.2\n";
     {
         test::check_instances check_;
 
@@ -69,8 +68,7 @@ void assign_tests1(T*, test::random_generator generator)
     }
 }
 
-template <class T>
-void assign_tests2(T*, test::random_generator generator)
+template <class T> void assign_tests2(T*, test::random_generator generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
@@ -78,10 +76,10 @@ void assign_tests2(T*, test::random_generator generator)
     BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
     BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-    
+
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
-    std::cerr<<"assign_tests2.0 - empty container\n";
+    std::cerr << "assign_tests2.0 - empty container\n";
     {
         test::check_instances check_;
 
@@ -95,7 +93,7 @@ void assign_tests2(T*, test::random_generator generator)
         test::check_container(x1, x2);
     }
 
-    std::cerr<<"assign_tests2.1\n";
+    std::cerr << "assign_tests2.1\n";
     {
         test::check_instances check_;
 
@@ -112,7 +110,7 @@ void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr<<"assign_tests2.1a\n";
+    std::cerr << "assign_tests2.1a\n";
     {
         test::check_instances check_;
 
@@ -130,7 +128,7 @@ void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr<<"assign_tests2.2\n";
+    std::cerr << "assign_tests2.2\n";
     {
         test::check_instances check_;
 
@@ -143,8 +141,7 @@ void assign_tests2(T*, test::random_generator generator)
         if (allocator_type::is_propagate_on_assign) {
             BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
             BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        }
-        else {
+        } else {
             BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
             BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
         }
@@ -153,7 +150,7 @@ void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr<<"assign_tests2.3\n";
+    std::cerr << "assign_tests2.3\n";
     {
         test::check_instances check_;
 
@@ -166,8 +163,7 @@ void assign_tests2(T*, test::random_generator generator)
         if (allocator_type::is_propagate_on_assign) {
             BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
             BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        }
-        else {
+        } else {
             BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
             BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
         }
@@ -176,7 +172,7 @@ void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr<<"assign_tests2.4\n";
+    std::cerr << "assign_tests2.4\n";
     {
         test::check_instances check_;
 
@@ -189,8 +185,7 @@ void assign_tests2(T*, test::random_generator generator)
         if (allocator_type::is_propagate_on_assign) {
             BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
             BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        }
-        else {
+        } else {
             BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
             BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
         }
@@ -200,63 +195,51 @@ void assign_tests2(T*, test::random_generator generator)
     }
 }
 
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_set_prop_assign;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_multiset_prop_assign;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_map_prop_assign;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_multimap_prop_assign;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_set_no_prop_assign;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_multiset_no_prop_assign;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_map_no_prop_assign;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_multimap_no_prop_assign;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
-template <typename T>
-bool is_propagate(T*)
+template <typename T> bool is_propagate(T*)
 {
     return T::allocator_type::is_propagate_on_assign;
 }
@@ -268,27 +251,27 @@ UNORDERED_AUTO_TEST(check_traits)
     BOOST_TEST(!is_propagate(test_set_no_prop_assign));
 }
 
-UNORDERED_TEST(assign_tests1, (
-        (test_map_std_alloc)
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(test_multimap_prop_assign)
-        (test_set_no_prop_assign)(test_multiset_no_prop_assign)(test_map_no_prop_assign)(test_multimap_no_prop_assign)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(assign_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+        test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(
+        test_multimap_prop_assign)(test_set_no_prop_assign)(
+        test_multiset_no_prop_assign)(test_map_no_prop_assign)(
+        test_multimap_no_prop_assign))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(assign_tests2, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(test_multimap_prop_assign)
-        (test_set_no_prop_assign)(test_multiset_no_prop_assign)(test_map_no_prop_assign)(test_multimap_no_prop_assign)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(
+    assign_tests2, ((test_set)(test_multiset)(test_map)(test_multimap)(
+                       test_set_prop_assign)(test_multiset_prop_assign)(
+                       test_map_prop_assign)(test_multimap_prop_assign)(
+                       test_set_no_prop_assign)(test_multiset_no_prop_assign)(
+                       test_map_no_prop_assign)(test_multimap_no_prop_assign))(
+                       (default_generator)(generate_collisions)(limited_range)))
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(assign_default_initializer_list) {
-    std::cerr<<"Initializer List Tests\n";
+UNORDERED_AUTO_TEST(assign_default_initializer_list)
+{
+    std::cerr << "Initializer List Tests\n";
     std::initializer_list<std::pair<int const, int> > init;
     boost::unordered_map<int, int> x1;
     x1[25] = 3;
@@ -303,18 +286,17 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list) {
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 UNORDERED_AUTO_TEST(assign_initializer_list)
 {
-    std::cerr<<"Initializer List Tests\n";
+    std::cerr << "Initializer List Tests\n";
 
     boost::unordered_set<int> x;
     x.insert(10);
     x.insert(20);
-    x = { 1, 2, -10 };
+    x = {1, 2, -10};
     BOOST_TEST(x.find(10) == x.end());
     BOOST_TEST(x.find(-10) != x.end());
 }
 
 #endif
-
 }
 
 RUN_TESTS()
diff --git a/test/unordered/at_tests.cpp b/test/unordered/at_tests.cpp
index 824b6e88..11c0aa75 100644
--- a/test/unordered/at_tests.cpp
+++ b/test/unordered/at_tests.cpp
@@ -14,7 +14,8 @@
 
 namespace at_tests {
 
-UNORDERED_AUTO_TEST(at_tests) {
+UNORDERED_AUTO_TEST(at_tests)
+{
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
 
     boost::unordered_map<std::string, int> x;
@@ -34,13 +35,11 @@ UNORDERED_AUTO_TEST(at_tests) {
     try {
         x.at("three");
         BOOST_ERROR("Should have thrown.");
-    }
-    catch(std::out_of_range) {
+    } catch (std::out_of_range) {
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
 }
-
 }
 
 RUN_TESTS()
diff --git a/test/unordered/bucket_tests.cpp b/test/unordered/bucket_tests.cpp
index d879ad41..280c013e 100644
--- a/test/unordered/bucket_tests.cpp
+++ b/test/unordered/bucket_tests.cpp
@@ -17,16 +17,15 @@
 #include "../helpers/helpers.hpp"
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
-#pragma warning(disable:4267) // conversion from 'size_t' to 'unsigned int',
-                              // possible loss of data.
+#pragma warning(disable : 4267) // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data.
 #endif
 
 namespace bucket_tests {
 
 test::seed_t initialize_seed(54635);
 
-template <class X>
-void tests(X*, test::random_generator generator)
+template <class X> void tests(X*, test::random_generator generator)
 {
     test::check_instances check_;
 
@@ -38,66 +37,59 @@ void tests(X*, test::random_generator generator)
 
     BOOST_TEST(x.bucket_count() <= x.max_bucket_count());
     if (!(x.bucket_count() <= x.max_bucket_count())) {
-       std::cerr<<x.bucket_count()<<"<="<<x.max_bucket_count()<<"\n";
+        std::cerr << x.bucket_count() << "<=" << x.max_bucket_count() << "\n";
     }
 
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
-            it = v.begin(), end = v.end(); it != end; ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
+             it = v.begin(),
+             end = v.end();
+         it != end; ++it) {
         size_type bucket = x.bucket(test::get_key<X>(*it));
 
         BOOST_TEST(bucket < x.bucket_count());
-        if(bucket < x.bucket_count()) {
+        if (bucket < x.bucket_count()) {
             // lit? lend?? I need a new naming scheme.
             const_local_iterator lit = x.begin(bucket), lend = x.end(bucket);
-            while(lit != lend
-                && test::get_key<X>(*it) != test::get_key<X>(*lit))
-            {
+            while (lit != lend &&
+                   test::get_key<X>(*it) != test::get_key<X>(*lit)) {
                 ++lit;
             }
             BOOST_TEST(lit != lend);
         }
     }
 
-    for(size_type i = 0; i < x.bucket_count(); ++i) {
-        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
-                std::distance(x.begin(i), x.end(i))));
-        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
-                std::distance(x.cbegin(i), x.cend(i))));
+    for (size_type i = 0; i < x.bucket_count(); ++i) {
+        BOOST_TEST(x.bucket_size(i) ==
+                   static_cast<size_type>(std::distance(x.begin(i), x.end(i))));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
+                                           x.cbegin(i), x.cend(i))));
         X const& x_ref = x;
-        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
-                std::distance(x_ref.begin(i), x_ref.end(i))));
-        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(
-                std::distance(x_ref.cbegin(i), x_ref.cend(i))));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
+                                           x_ref.begin(i), x_ref.end(i))));
+        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
+                                           x_ref.cbegin(i), x_ref.cend(i))));
     }
 }
 
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    std::allocator<test::object> >* test_multimap_std_alloc;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
-UNORDERED_TEST(tests,
-    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
+UNORDERED_TEST(tests, ((test_multimap_std_alloc)(test_set)(test_multiset)(
+                          test_map)(test_multimap))((default_generator)(
+                          generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/compile_map.cpp b/test/unordered/compile_map.cpp
index 6b33d8ae..b149ad24 100644
--- a/test/unordered/compile_map.cpp
+++ b/test/unordered/compile_map.cpp
@@ -19,29 +19,18 @@
 
 // Explicit instantiation to catch compile-time errors
 
-template class boost::unordered_map<
-    int,
-    int,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<std::pair<int const, int> > >;
-template class boost::unordered_multimap<
-    int const,
-    int const,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<std::pair<int const, int> > >;
+template class boost::unordered_map<int, int, boost::hash<int>,
+    std::equal_to<int>, test::minimal::allocator<std::pair<int const, int> > >;
+template class boost::unordered_multimap<int const, int const, boost::hash<int>,
+    std::equal_to<int>, test::minimal::allocator<std::pair<int const, int> > >;
 
-template class boost::unordered_map<
-    test::minimal::assignable const,
+template class boost::unordered_map<test::minimal::assignable const,
     test::minimal::default_assignable const,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
-template class boost::unordered_multimap<
-    test::minimal::assignable,
-    test::minimal::assignable,
-    test::minimal::hash<test::minimal::assignable>,
+template class boost::unordered_multimap<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
 
@@ -50,68 +39,70 @@ UNORDERED_AUTO_TEST(test0)
     test::minimal::constructor_param x;
 
     typedef std::pair<test::minimal::assignable const,
-            test::minimal::assignable> value_type;
+        test::minimal::assignable>
+        value_type;
     value_type value(x, x);
 
-    std::cout<<"Test unordered_map.\n";
+    std::cout << "Test unordered_map.\n";
 
     boost::unordered_map<int, int> int_map;
 
-    boost::unordered_map<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_map2;
+    boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> > >
+        int_map2;
 
-    boost::unordered_map<
-        test::minimal::assignable,
-        test::minimal::assignable,
+    boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<value_type> > map;
+        test::minimal::allocator<value_type> >
+        map;
 
     container_test(int_map, std::pair<int const, int>(0, 0));
     container_test(int_map2, std::pair<int const, int>(0, 0));
     container_test(map, value);
 
-    std::cout<<"Test unordered_multimap.\n";
+    std::cout << "Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> int_multimap;
 
-    boost::unordered_multimap<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_multimap2;
+    boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> > >
+        int_multimap2;
 
-    boost::unordered_multimap<
-        test::minimal::assignable,
+    boost::unordered_multimap<test::minimal::assignable,
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<value_type> > multimap;
+        test::minimal::allocator<value_type> >
+        multimap;
 
     container_test(int_multimap, std::pair<int const, int>(0, 0));
     container_test(int_multimap2, std::pair<int const, int>(0, 0));
     container_test(multimap, value);
 }
 
-UNORDERED_AUTO_TEST(equality_tests) {
+UNORDERED_AUTO_TEST(equality_tests)
+{
     typedef std::pair<
-            test::minimal::copy_constructible_equality_comparable const,
-            test::minimal::copy_constructible_equality_comparable> value_type;
+        test::minimal::copy_constructible_equality_comparable const,
+        test::minimal::copy_constructible_equality_comparable>
+        value_type;
 
     boost::unordered_map<int, int> int_map;
 
-    boost::unordered_map<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_map2;
+    boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> > >
+        int_map2;
 
     boost::unordered_map<
         test::minimal::copy_constructible_equality_comparable,
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::allocator<value_type> > map;
+        test::minimal::hash<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::allocator<value_type> >
+        map;
 
     equality_test(int_map);
     equality_test(int_map2);
@@ -119,37 +110,39 @@ UNORDERED_AUTO_TEST(equality_tests) {
 
     boost::unordered_multimap<int, int> int_multimap;
 
-    boost::unordered_multimap<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_multimap2;
+    boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> > >
+        int_multimap2;
 
     boost::unordered_multimap<
         test::minimal::copy_constructible_equality_comparable,
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::allocator<value_type> > multimap;
+        test::minimal::hash<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::allocator<value_type> >
+        multimap;
 
     equality_test(int_multimap);
     equality_test(int_multimap2);
     equality_test(multimap);
 }
 
-UNORDERED_AUTO_TEST(test1) {
+UNORDERED_AUTO_TEST(test1)
+{
     boost::hash<int> hash;
     std::equal_to<int> equal_to;
     int value = 0;
     std::pair<int const, int> map_value(0, 0);
 
-    std::cout<<"Test unordered_map.\n";
+    std::cout << "Test unordered_map.\n";
 
     boost::unordered_map<int, int> map;
 
-    boost::unordered_map<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > map2;
+    boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> > >
+        map2;
 
     unordered_unique_test(map, map_value);
     unordered_map_test(map, value, value);
@@ -161,14 +154,13 @@ UNORDERED_AUTO_TEST(test1) {
     unordered_copyable_test(map2, value, map_value, hash, equal_to);
     unordered_map_functions(map2, value, value);
 
-    std::cout<<"Test unordered_multimap.\n";
+    std::cout << "Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> multimap;
 
-    boost::unordered_multimap<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > multimap2;
+    boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<std::pair<int const, int> > >
+        multimap2;
 
     unordered_equivalent_test(multimap, map_value);
     unordered_map_test(multimap, value, value);
@@ -189,42 +181,42 @@ UNORDERED_AUTO_TEST(test2)
     test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
     typedef std::pair<test::minimal::assignable const,
-            test::minimal::assignable> map_value_type;
+        test::minimal::assignable>
+        map_value_type;
     map_value_type map_value(assignable, assignable);
 
-    std::cout<<"Test unordered_map.\n";
+    std::cout << "Test unordered_map.\n";
 
-    boost::unordered_map<
-        test::minimal::assignable,
-        test::minimal::assignable,
+    boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> > map;
+        test::minimal::allocator<map_value_type> >
+        map;
 
     unordered_unique_test(map, map_value);
     unordered_map_test(map, assignable, assignable);
     unordered_copyable_test(map, assignable, map_value, hash, equal_to);
     unordered_map_member_test(map, map_value);
 
-    boost::unordered_map<
-        test::minimal::assignable,
+    boost::unordered_map<test::minimal::assignable,
         test::minimal::default_assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> > map2;
+        test::minimal::allocator<map_value_type> >
+        map2;
 
     test::minimal::default_assignable default_assignable;
 
     unordered_map_functions(map2, assignable, default_assignable);
 
-    std::cout<<"Test unordered_multimap.\n";
+    std::cout << "Test unordered_multimap.\n";
 
-    boost::unordered_multimap<
-        test::minimal::assignable,
+    boost::unordered_multimap<test::minimal::assignable,
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> > multimap;
+        test::minimal::allocator<map_value_type> >
+        multimap;
 
     unordered_equivalent_test(multimap, map_value);
     unordered_map_test(multimap, assignable, assignable);
diff --git a/test/unordered/compile_set.cpp b/test/unordered/compile_set.cpp
index ed5363d6..60f0f80f 100644
--- a/test/unordered/compile_set.cpp
+++ b/test/unordered/compile_set.cpp
@@ -19,24 +19,16 @@
 
 // Explicit instantiation to catch compile-time errors
 
-template class boost::unordered_set<
-    int,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<int> >;
-template class boost::unordered_multiset<
-    int const,
-    boost::hash<int>,
-    std::equal_to<int>,
+template class boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::allocator<int> >;
+template class boost::unordered_multiset<int const, boost::hash<int>,
+    std::equal_to<int>, test::minimal::allocator<int> >;
 
-template class boost::unordered_set<
-    test::minimal::assignable const,
+template class boost::unordered_set<test::minimal::assignable const,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
-template class boost::unordered_multiset<
-    test::minimal::assignable,
+template class boost::unordered_multiset<test::minimal::assignable,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
@@ -47,60 +39,61 @@ UNORDERED_AUTO_TEST(test0)
 
     test::minimal::assignable assignable(x);
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout << "Test unordered_set.\n";
 
     boost::unordered_set<int> int_set;
 
-    boost::unordered_set<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_set2;
+    boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int> >
+        int_set2;
 
-    boost::unordered_set<
-        test::minimal::assignable,
+    boost::unordered_set<test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> > set;
+        test::minimal::allocator<test::minimal::assignable> >
+        set;
 
     container_test(int_set, 0);
     container_test(int_set2, 0);
     container_test(set, assignable);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout << "Test unordered_multiset.\n";
 
     boost::unordered_multiset<int> int_multiset;
 
-    boost::unordered_multiset<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_multiset2;
+    boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int> >
+        int_multiset2;
 
-    boost::unordered_multiset<
-        test::minimal::assignable,
+    boost::unordered_multiset<test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> > multiset;
+        test::minimal::allocator<test::minimal::assignable> >
+        multiset;
 
     container_test(int_multiset, 0);
     container_test(int_multiset2, 0);
     container_test(multiset, assignable);
 }
 
-UNORDERED_AUTO_TEST(equality_tests) {
+UNORDERED_AUTO_TEST(equality_tests)
+{
     typedef test::minimal::copy_constructible_equality_comparable value_type;
 
     boost::unordered_set<int> int_set;
 
-    boost::unordered_set<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_set2;
+    boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int> >
+        int_set2;
 
     boost::unordered_set<
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::allocator<value_type> > set;
+        test::minimal::hash<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::allocator<value_type> >
+        set;
 
     equality_test(int_set);
     equality_test(int_set2);
@@ -108,16 +101,18 @@ UNORDERED_AUTO_TEST(equality_tests) {
 
     boost::unordered_multiset<int> int_multiset;
 
-    boost::unordered_multiset<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_multiset2;
+    boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int> >
+        int_multiset2;
 
     boost::unordered_multiset<
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::allocator<value_type> > multiset;
+        test::minimal::hash<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<
+            test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::allocator<value_type> >
+        multiset;
 
     equality_test(int_multiset);
     equality_test(int_multiset2);
@@ -130,14 +125,13 @@ UNORDERED_AUTO_TEST(test1)
     std::equal_to<int> equal_to;
     int value = 0;
 
-    std::cout<<"Test unordered_set." << std::endl;
+    std::cout << "Test unordered_set." << std::endl;
 
     boost::unordered_set<int> set;
-    
-    boost::unordered_set<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > set2;
+
+    boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int> >
+        set2;
 
     unordered_unique_test(set, value);
     unordered_set_test(set, value);
@@ -147,14 +141,13 @@ UNORDERED_AUTO_TEST(test1)
     unordered_set_test(set2, value);
     unordered_copyable_test(set2, value, value, hash, equal_to);
 
-    std::cout<<"Test unordered_multiset." << std::endl;
+    std::cout << "Test unordered_multiset." << std::endl;
 
     boost::unordered_multiset<int> multiset;
-    
-    boost::unordered_multiset<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > multiset2;
+
+    boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int> >
+        multiset2;
 
     unordered_equivalent_test(multiset, value);
     unordered_set_test(multiset, value);
@@ -168,32 +161,32 @@ UNORDERED_AUTO_TEST(test1)
 UNORDERED_AUTO_TEST(test2)
 {
     test::minimal::constructor_param x;
- 
+
     test::minimal::assignable assignable(x);
     test::minimal::copy_constructible copy_constructible(x);
     test::minimal::hash<test::minimal::assignable> hash(x);
     test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout << "Test unordered_set.\n";
 
-    boost::unordered_set<
-        test::minimal::assignable,
+    boost::unordered_set<test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> > set;
+        test::minimal::allocator<test::minimal::assignable> >
+        set;
 
     unordered_unique_test(set, assignable);
     unordered_set_test(set, assignable);
     unordered_copyable_test(set, assignable, assignable, hash, equal_to);
     unordered_set_member_test(set, assignable);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout << "Test unordered_multiset.\n";
 
-    boost::unordered_multiset<
-        test::minimal::assignable,
+    boost::unordered_multiset<test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> > multiset;
+        test::minimal::allocator<test::minimal::assignable> >
+        multiset;
 
     unordered_equivalent_test(multiset, assignable);
     unordered_set_test(multiset, assignable);
@@ -209,27 +202,27 @@ UNORDERED_AUTO_TEST(movable1_tests)
     test::minimal::hash<test::minimal::movable1> hash(x);
     test::minimal::equal_to<test::minimal::movable1> equal_to(x);
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout << "Test unordered_set.\n";
 
-    boost::unordered_set<
-        test::minimal::movable1,
+    boost::unordered_set<test::minimal::movable1,
         test::minimal::hash<test::minimal::movable1>,
         test::minimal::equal_to<test::minimal::movable1>,
-        test::minimal::allocator<test::minimal::movable1> > set;
+        test::minimal::allocator<test::minimal::movable1> >
+        set;
 
-    //unordered_unique_test(set, movable1);
+    // unordered_unique_test(set, movable1);
     unordered_set_test(set, movable1);
     unordered_movable_test(set, movable1, movable1, hash, equal_to);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout << "Test unordered_multiset.\n";
 
-    boost::unordered_multiset<
-        test::minimal::movable1,
+    boost::unordered_multiset<test::minimal::movable1,
         test::minimal::hash<test::minimal::movable1>,
         test::minimal::equal_to<test::minimal::movable1>,
-        test::minimal::allocator<test::minimal::movable1> > multiset;
+        test::minimal::allocator<test::minimal::movable1> >
+        multiset;
 
-    //unordered_equivalent_test(multiset, movable1);
+    // unordered_equivalent_test(multiset, movable1);
     unordered_set_test(multiset, movable1);
     unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
 }
@@ -242,27 +235,27 @@ UNORDERED_AUTO_TEST(movable2_tests)
     test::minimal::hash<test::minimal::movable2> hash(x);
     test::minimal::equal_to<test::minimal::movable2> equal_to(x);
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout << "Test unordered_set.\n";
 
-    boost::unordered_set<
-        test::minimal::movable2,
+    boost::unordered_set<test::minimal::movable2,
         test::minimal::hash<test::minimal::movable2>,
         test::minimal::equal_to<test::minimal::movable2>,
-        test::minimal::allocator<test::minimal::movable2> > set;
+        test::minimal::allocator<test::minimal::movable2> >
+        set;
 
-    //unordered_unique_test(set, movable2);
+    // unordered_unique_test(set, movable2);
     unordered_set_test(set, movable2);
     unordered_movable_test(set, movable2, movable2, hash, equal_to);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout << "Test unordered_multiset.\n";
 
-    boost::unordered_multiset<
-        test::minimal::movable2,
+    boost::unordered_multiset<test::minimal::movable2,
         test::minimal::hash<test::minimal::movable2>,
         test::minimal::equal_to<test::minimal::movable2>,
-        test::minimal::allocator<test::minimal::movable2> > multiset;
+        test::minimal::allocator<test::minimal::movable2> >
+        multiset;
 
-    //unordered_equivalent_test(multiset, movable2);
+    // unordered_equivalent_test(multiset, movable2);
     unordered_set_test(multiset, movable2);
     unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
 }
@@ -275,21 +268,21 @@ UNORDERED_AUTO_TEST(destructible_tests)
     test::minimal::hash<test::minimal::destructible> hash(x);
     test::minimal::equal_to<test::minimal::destructible> equal_to(x);
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout << "Test unordered_set.\n";
 
-    boost::unordered_set<
-        test::minimal::destructible,
+    boost::unordered_set<test::minimal::destructible,
         test::minimal::hash<test::minimal::destructible>,
-        test::minimal::equal_to<test::minimal::destructible> > set;
+        test::minimal::equal_to<test::minimal::destructible> >
+        set;
 
     unordered_destructible_test(set);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout << "Test unordered_multiset.\n";
 
-    boost::unordered_multiset<
-        test::minimal::destructible,
+    boost::unordered_multiset<test::minimal::destructible,
         test::minimal::hash<test::minimal::destructible>,
-        test::minimal::equal_to<test::minimal::destructible> > multiset;
+        test::minimal::equal_to<test::minimal::destructible> >
+        multiset;
 
     unordered_destructible_test(multiset);
 }
diff --git a/test/unordered/compile_tests.hpp b/test/unordered/compile_tests.hpp
index 12581763..6c59860d 100644
--- a/test/unordered/compile_tests.hpp
+++ b/test/unordered/compile_tests.hpp
@@ -5,9 +5,9 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
-#pragma warning(disable:4610) // class can never be instantiated
-#pragma warning(disable:4510) // default constructor could not be generated
+#pragma warning(disable : 4100) // unreferenced formal parameter
+#pragma warning(disable : 4610) // class can never be instantiated
+#pragma warning(disable : 4510) // default constructor could not be generated
 #endif
 
 #include <boost/concept_check.hpp>
@@ -16,13 +16,13 @@
 #pragma warning(pop)
 #endif
 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_convertible.hpp>
+#include "../helpers/check_return_type.hpp"
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <boost/utility/swap.hpp>
-#include "../helpers/check_return_type.hpp"
 
 typedef long double comparison_type;
 
@@ -30,23 +30,21 @@ template <class T> void sink(T const&) {}
 template <class T> T rvalue(T const& v) { return v; }
 template <class T> T rvalue_default() { return T(); }
 
-template <class X, class T>
-void container_test(X& r, T const&)
+template <class X, class T> void container_test(X& r, T const&)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
     typedef BOOST_DEDUCED_TYPENAME X::difference_type difference_type;
     typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
 
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_value<iterator>::type iterator_value_type;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_value<const_iterator>::type const_iterator_value_type;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_difference<iterator>::type iterator_difference_type;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_difference<const_iterator>::type
-            const_iterator_difference_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<iterator>::type
+        iterator_value_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<const_iterator>::type
+        const_iterator_value_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type
+        iterator_difference_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+        const_iterator>::type const_iterator_difference_type;
 
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::reference reference;
@@ -66,7 +64,8 @@ void container_test(X& r, T const&)
 
     boost::function_requires<boost::InputIteratorConcept<iterator> >();
     BOOST_STATIC_ASSERT((boost::is_same<T, iterator_value_type>::value));
-    BOOST_STATIC_ASSERT((boost::is_convertible<iterator, const_iterator>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_convertible<iterator, const_iterator>::value));
 
     // const_iterator
 
@@ -77,10 +76,10 @@ void container_test(X& r, T const&)
 
     BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
     BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_integer);
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<difference_type, iterator_difference_type>::value));
     BOOST_STATIC_ASSERT((boost::is_same<difference_type,
-                iterator_difference_type>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
-                const_iterator_difference_type>::value));
+        const_iterator_difference_type>::value));
 
     // size_type
 
@@ -89,21 +88,19 @@ void container_test(X& r, T const&)
 
     // size_type can represent any non-negative value type of difference_type
     // I'm not sure about either of these tests...
-    size_type max_diff = static_cast<size_type>(
-            (std::numeric_limits<difference_type>::max)());
+    size_type max_diff =
+        static_cast<size_type>((std::numeric_limits<difference_type>::max)());
     difference_type converted_diff(static_cast<difference_type>(max_diff));
-    BOOST_TEST((std::numeric_limits<difference_type>::max)()
-            == converted_diff);
+    BOOST_TEST((std::numeric_limits<difference_type>::max)() == converted_diff);
 
     BOOST_TEST(
-        static_cast<comparison_type>(
-            (std::numeric_limits<size_type>::max)()) >
+        static_cast<comparison_type>((std::numeric_limits<size_type>::max)()) >
         static_cast<comparison_type>(
             (std::numeric_limits<difference_type>::max)()));
 
-    // Constructors
+// Constructors
 
-    // I don't test the runtime post-conditions here.
+// I don't test the runtime post-conditions here.
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     // It isn't specified in the container requirements that the no argument
@@ -117,7 +114,7 @@ void container_test(X& r, T const&)
     BOOST_TEST(u.size() == 0);
     BOOST_TEST(X().size() == 0);
 
-    X a,b;
+    X a, b;
     X a_const;
 
     sink(X(a));
@@ -142,7 +139,7 @@ void container_test(X& r, T const&)
     X c2(a_const, m);
     sink(X(rvalue(a_const), m));
     X c3(rvalue(a_const), m);
-    
+
     // Avoid unused variable warnings:
 
     sink(u);
@@ -155,8 +152,7 @@ void container_test(X& r, T const&)
     sink(c3);
 }
 
-template <class X>
-void unordered_destructible_test(X&)
+template <class X> void unordered_destructible_test(X&)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
@@ -167,9 +163,9 @@ void unordered_destructible_test(X&)
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     X x2(rvalue_default<X>());
     X x3 = rvalue_default<X>();
-    // This can only be done if propagate_on_container_move_assignment::value
-    // is true.
-    // x2 = rvalue_default<X>();
+// This can only be done if propagate_on_container_move_assignment::value
+// is true.
+// x2 = rvalue_default<X>();
 #endif
 
     X* ptr = new X();
@@ -177,7 +173,7 @@ void unordered_destructible_test(X&)
     (&a1)->~X();
     ::operator delete((void*)(&a1));
 
-    X a,b;
+    X a, b;
     X const a_const;
     test::check_return_type<iterator>::equals(a.begin());
     test::check_return_type<const_iterator>::equals(a_const.begin());
@@ -190,7 +186,7 @@ void unordered_destructible_test(X&)
 
     a.swap(b);
     boost::swap(a, b);
- 
+
     test::check_return_type<size_type>::equals(a.size());
     test::check_return_type<size_type>::equals(a.max_size());
     test::check_return_type<bool>::convertible(a.empty());
@@ -201,8 +197,7 @@ void unordered_destructible_test(X&)
     test::check_return_type<allocator_type>::equals(a_const.get_allocator());
 }
 
-template <class X, class Key>
-void unordered_set_test(X&, Key const&)
+template <class X, class Key> void unordered_set_test(X&, Key const&)
 {
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
@@ -215,21 +210,23 @@ void unordered_set_test(X&, Key const&)
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
     typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<iterator>::type iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_iterator>::type
-            const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_local_iterator>::type
-            const_local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
+        iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
+        const_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
+        local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<
+        const_local_iterator>::type const_local_iterator_pointer;
 
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, local_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_local_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<value_type const*, iterator_pointer>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<value_type const*, const_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<value_type const*, local_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<value_type const*,
+        const_local_iterator_pointer>::value));
 }
 
 template <class X, class Key, class T>
@@ -238,8 +235,8 @@ void unordered_map_test(X& r, Key const& k, T const& v)
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
 
-    BOOST_STATIC_ASSERT((
-        boost::is_same<value_type, std::pair<key_type const, T> >::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<value_type, std::pair<key_type const, T> >::value));
 
     // iterator pointer / const_pointer_type
 
@@ -247,21 +244,22 @@ void unordered_map_test(X& r, Key const& k, T const& v)
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
     typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<iterator>::type iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_iterator>::type
-            const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_local_iterator>::type
-            const_local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
+        iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
+        const_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
+        local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<
+        const_local_iterator>::type const_local_iterator_pointer;
 
     BOOST_STATIC_ASSERT((boost::is_same<value_type*, iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type*, local_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_local_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<value_type const*, const_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<value_type*, local_iterator_pointer>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<value_type const*,
+        const_local_iterator_pointer>::value));
 
     // Calling functions
 
@@ -274,12 +272,11 @@ void unordered_map_test(X& r, Key const& k, T const& v)
     r.emplace(k_lvalue, v_lvalue);
     r.emplace(rvalue(k), rvalue(v));
 
-    r.emplace(boost::unordered::piecewise_construct,
-            boost::make_tuple(k), boost::make_tuple(v));
+    r.emplace(boost::unordered::piecewise_construct, boost::make_tuple(k),
+        boost::make_tuple(v));
 }
 
-template <class X>
-void equality_test(X& r)
+template <class X> void equality_test(X& r)
 {
     X const a = r, b = r;
 
@@ -289,16 +286,14 @@ void equality_test(X& r)
     test::check_return_type<bool>::equals(boost::operator!=(a, b));
 }
 
-template <class X, class T>
-void unordered_unique_test(X& r, T const& t)
+template <class X, class T> void unordered_unique_test(X& r, T const& t)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
     test::check_return_type<std::pair<iterator, bool> >::equals(r.emplace(t));
 }
 
-template <class X, class T>
-void unordered_equivalent_test(X& r, T const& t)
+template <class X, class T> void unordered_equivalent_test(X& r, T const& t)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     test::check_return_type<iterator>::equals(r.insert(t));
@@ -334,61 +329,45 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
     typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
 
     typedef BOOST_DEDUCED_TYPENAME
-        boost::BOOST_ITERATOR_CATEGORY<iterator>::type
-        iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_difference<iterator>::type
+        boost::BOOST_ITERATOR_CATEGORY<iterator>::type iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type
         iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<iterator>::type
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
         iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_reference<iterator>::type
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<iterator>::type
         iterator_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::BOOST_ITERATOR_CATEGORY<local_iterator>::type
-        local_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_difference<local_iterator>::type
-        local_iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<local_iterator>::type
+    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
+        local_iterator>::type local_iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+        local_iterator>::type local_iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
         local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_reference<local_iterator>::type
-        local_iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
+        local_iterator>::type local_iterator_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::BOOST_ITERATOR_CATEGORY<const_iterator>::type
-        const_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_difference<const_iterator>::type
-        const_iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_iterator>::type
+    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
+        const_iterator>::type const_iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+        const_iterator>::type const_iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
         const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_reference<const_iterator>::type
-        const_iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
+        const_iterator>::type const_iterator_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::BOOST_ITERATOR_CATEGORY<const_local_iterator>::type
-        const_local_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_difference<const_local_iterator>::type
-        const_local_iterator_difference;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_local_iterator>::type
-        const_local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_reference<const_local_iterator>::type
-        const_local_iterator_reference;
+    typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
+        const_local_iterator>::type const_local_iterator_category;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+        const_local_iterator>::type const_local_iterator_difference;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<
+        const_local_iterator>::type const_local_iterator_pointer;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
+        const_local_iterator>::type const_local_iterator_reference;
     typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
     BOOST_STATIC_ASSERT((boost::is_same<Key, key_type>::value));
-    //boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
-    //boost::function_requires<boost::AssignableConcept<key_type> >();
+    // boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
+    // boost::function_requires<boost::AssignableConcept<key_type> >();
 
     BOOST_STATIC_ASSERT((boost::is_same<Hash, hasher>::value));
     test::check_return_type<std::size_t>::equals(hf(k));
@@ -397,14 +376,14 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
     test::check_return_type<bool>::convertible(eq(k, k));
 
     boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_category,
-        iterator_category>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_difference,
-        iterator_difference>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_pointer,
-        iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_reference,
-        iterator_reference>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<local_iterator_category, iterator_category>::value));
+    BOOST_STATIC_ASSERT((
+        boost::is_same<local_iterator_difference, iterator_difference>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<local_iterator_pointer, iterator_pointer>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<local_iterator_reference, iterator_reference>::value));
 
     boost::function_requires<
         boost::InputIteratorConcept<const_local_iterator> >();
@@ -456,9 +435,9 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
     test::check_return_type<const_iterator>::equals(b.find(k));
     test::check_return_type<size_type>::equals(b.count(k));
     test::check_return_type<std::pair<iterator, iterator> >::equals(
-            a.equal_range(k));
+        a.equal_range(k));
     test::check_return_type<std::pair<const_iterator, const_iterator> >::equals(
-            b.equal_range(k));
+        b.equal_range(k));
     test::check_return_type<size_type>::equals(b.bucket_count());
     test::check_return_type<size_type>::equals(b.max_bucket_count());
     test::check_return_type<size_type>::equals(b.bucket(k));
@@ -476,9 +455,9 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
 
     test::check_return_type<float>::equals(b.load_factor());
     test::check_return_type<float>::equals(b.max_load_factor());
-    a.max_load_factor((float) 2.0);
+    a.max_load_factor((float)2.0);
     a.rehash(100);
-    
+
     // Avoid unused variable warnings:
 
     sink(a);
@@ -525,10 +504,10 @@ void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
     X(i, j, 10, m);
     X a7a(i, j, 10, m);
 
-    // Not specified for some reason (maybe ambiguity with another constructor?)
-    //X(i, j, m);
-    //X a8a(i, j, m);
-    //sink(a8a);
+// Not specified for some reason (maybe ambiguity with another constructor?)
+// X(i, j, m);
+// X a8a(i, j, m);
+// sink(a8a);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     std::size_t min_buckets = 10;
@@ -536,7 +515,7 @@ void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
     X({t}, min_buckets);
     X({t}, min_buckets, hf);
     X({t}, min_buckets, hf, eq);
-    //X({t}, m);
+    // X({t}, m);
     X({t}, min_buckets, m);
     X({t}, min_buckets, hf, m);
     X({t}, min_buckets, hf, eq, m);
@@ -559,12 +538,12 @@ void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     std::initializer_list<T> list = {t};
     a.insert(list);
-    a.insert({t,t,t});
+    a.insert({t, t, t});
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1900)
     a.insert({});
     a.insert({t});
-    a.insert({t,t});
+    a.insert({t, t});
 #endif
 #endif
 
@@ -606,7 +585,7 @@ void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
     X a;
     allocator_type m = a.get_allocator();
 
-    test::minimal::constructor_param* i = 0; 
+    test::minimal::constructor_param* i = 0;
     test::minimal::constructor_param* j = 0;
 
     // Constructors
@@ -628,9 +607,9 @@ void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
     X a7a(i, j, 10, m);
 
     // Not specified for some reason (maybe ambiguity with another constructor?)
-    //X(i, j, m);
-    //X a8a(i, j, m);
-    //sink(a8a);
+    // X(i, j, m);
+    // X a8a(i, j, m);
+    // sink(a8a);
 
     const_iterator q = a.cbegin();
 
@@ -644,10 +623,9 @@ void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
     a.insert(boost::move(v2));
     T v3(v);
     test::check_return_type<iterator>::equals(
-            a.emplace_hint(q, boost::move(v3)));
+        a.emplace_hint(q, boost::move(v3)));
     T v4(v);
-    test::check_return_type<iterator>::equals(
-            a.insert(q, boost::move(v4)));
+    test::check_return_type<iterator>::equals(a.insert(q, boost::move(v4)));
 
     a.insert(i, j);
 
@@ -670,8 +648,7 @@ void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
     sink(a10);
 }
 
-template <class X, class T>
-void unordered_set_member_test(X& x, T& t)
+template <class X, class T> void unordered_set_member_test(X& x, T& t)
 {
     X x1(x);
     x1.insert(t);
@@ -679,8 +656,7 @@ void unordered_set_member_test(X& x, T& t)
     x1.cbegin()->dummy_member();
 }
 
-template <class X, class T>
-void unordered_map_member_test(X& x, T& t)
+template <class X, class T> void unordered_map_member_test(X& x, T& t)
 {
     X x1(x);
     x1.insert(t);
diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp
index 6ad3f273..25901353 100644
--- a/test/unordered/constructor_tests.cpp
+++ b/test/unordered/constructor_tests.cpp
@@ -22,14 +22,13 @@ namespace constructor_tests {
 
 test::seed_t initialize_seed(356730);
 
-template <class T>
-void constructor_tests1(T*, test::random_generator generator)
+template <class T> void constructor_tests1(T*, test::random_generator generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
     BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
-    std::cerr<<"Construct 1\n";
+    std::cerr << "Construct 1\n";
     {
         test::check_instances check_;
 
@@ -41,7 +40,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 2\n";
+    std::cerr << "Construct 2\n";
     {
         test::check_instances check_;
 
@@ -54,7 +53,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 3\n";
+    std::cerr << "Construct 3\n";
     {
         test::check_instances check_;
 
@@ -67,7 +66,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 4\n";
+    std::cerr << "Construct 4\n";
     {
         test::check_instances check_;
 
@@ -79,7 +78,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 5\n";
+    std::cerr << "Construct 5\n";
     {
         test::check_instances check_;
 
@@ -93,7 +92,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 6\n";
+    std::cerr << "Construct 6\n";
     {
         test::check_instances check_;
 
@@ -107,7 +106,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 7\n";
+    std::cerr << "Construct 7\n";
     {
         test::check_instances check_;
 
@@ -121,7 +120,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 8\n";
+    std::cerr << "Construct 8\n";
     {
         test::check_instances check_;
 
@@ -134,7 +133,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 9\n";
+    std::cerr << "Construct 9\n";
     {
         test::check_instances check_;
 
@@ -146,7 +145,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 10\n";
+    std::cerr << "Construct 10\n";
     {
         test::check_instances check_;
 
@@ -160,7 +159,7 @@ void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 11\n";
+    std::cerr << "Construct 11\n";
     {
         test::check_instances check_;
 
@@ -186,7 +185,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
     BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
 
-    std::cerr<<"Construct 1\n";
+    std::cerr << "Construct 1\n";
     {
         test::check_instances check_;
         T x(10000, hf1, eq1);
@@ -197,7 +196,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 2\n";
+    std::cerr << "Construct 2\n";
     {
         test::check_instances check_;
         T x(100, hf1);
@@ -209,7 +208,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 3\n";
+    std::cerr << "Construct 3\n";
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -221,7 +220,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"Construct 4\n";
+    std::cerr << "Construct 4\n";
     {
         test::check_instances check_;
         test::random_values<T> v(5, generator);
@@ -234,8 +233,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-
-    std::cerr<<"Construct 5\n";
+    std::cerr << "Construct 5\n";
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -247,7 +245,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    std::cerr<<"Construct 6\n";
+    std::cerr << "Construct 6\n";
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -259,7 +257,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    std::cerr<<"Construct 7\n";
+    std::cerr << "Construct 7\n";
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -271,39 +269,40 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    std::cerr<<"Construct 8 - from input iterator\n";
+    std::cerr << "Construct 8 - from input iterator\n";
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
         BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            v_begin = v.begin(), v_end = v.end();
-        T x(test::input_iterator(v_begin),
-            test::input_iterator(v_end), 0, hf1, eq1);
-        BOOST_DEDUCED_TYPENAME T::const_iterator
-            x_begin = x.begin(), x_end = x.end();
-        T y(test::input_iterator(x_begin),
-            test::input_iterator(x_end), 0, hf2, eq2);
+            v_begin = v.begin(),
+            v_end = v.end();
+        T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
+            eq1);
+        BOOST_DEDUCED_TYPENAME T::const_iterator x_begin = x.begin(),
+                                                 x_end = x.end();
+        T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2,
+            eq2);
         test::check_container(x, v);
         test::check_container(y, x);
         test::check_equivalent_keys(x);
         test::check_equivalent_keys(y);
     }
-    
-    std::cerr<<"Construct 8.5 - from copy iterator\n";
+
+    std::cerr << "Construct 8.5 - from copy iterator\n";
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
-        T x(test::copy_iterator(v.begin()),
-            test::copy_iterator(v.end()), 0, hf1, eq1);
-        T y(test::copy_iterator(x.begin()),
-            test::copy_iterator(x.end()), 0, hf2, eq2);
+        T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0,
+            hf1, eq1);
+        T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0,
+            hf2, eq2);
         test::check_container(x, v);
         test::check_container(y, x);
         test::check_equivalent_keys(x);
         test::check_equivalent_keys(y);
     }
-    
-    std::cerr<<"Construct 9\n";
+
+    std::cerr << "Construct 9\n";
     {
         test::check_instances check_;
 
@@ -320,8 +319,8 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
-    
-    std::cerr<<"Initializer list construct 1\n";
+
+    std::cerr << "Initializer list construct 1\n";
     {
         test::check_instances check_;
 
@@ -332,7 +331,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    std::cerr<<"Initializer list construct 2\n";
+    std::cerr << "Initializer list construct 2\n";
     {
         test::check_instances check_;
 
@@ -344,7 +343,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    std::cerr<<"Initializer list construct 3\n";
+    std::cerr << "Initializer list construct 3\n";
     {
         test::check_instances check_;
 
@@ -356,7 +355,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    std::cerr<<"Initializer list construct 4\n";
+    std::cerr << "Initializer list construct 4\n";
     {
         test::check_instances check_;
 
@@ -368,7 +367,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    std::cerr<<"Initializer list construct 5\n";
+    std::cerr << "Initializer list construct 5\n";
     {
         test::check_instances check_;
 
@@ -385,14 +384,11 @@ void constructor_tests2(T*, test::random_generator const& generator)
 template <class T>
 void map_constructor_test(T*, test::random_generator const& generator)
 {
-    std::cerr<<"map_constructor_test\n";
+    std::cerr << "map_constructor_test\n";
 
-    typedef test::list<
-        std::pair<
-            BOOST_DEDUCED_TYPENAME T::key_type,
-            BOOST_DEDUCED_TYPENAME T::mapped_type
-        >
-    > list;
+    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
+        BOOST_DEDUCED_TYPENAME T::mapped_type> >
+        list;
     test::random_values<T> v(1000, generator);
     list l(v.begin(), v.end());
     T x(l.begin(), l.end());
@@ -401,46 +397,39 @@ void map_constructor_test(T*, test::random_generator const& generator)
     test::check_equivalent_keys(x);
 }
 
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
 UNORDERED_TEST(constructor_tests1,
-    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(constructor_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_set)(test_multiset)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(map_constructor_test,
-    ((test_map_std_alloc)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_map_std_alloc)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(test_default_initializer_list) {
-    std::cerr<<"Initializer List Tests\n";
+UNORDERED_AUTO_TEST(test_default_initializer_list)
+{
+    std::cerr << "Initializer List Tests\n";
     std::initializer_list<int> init;
     boost::unordered_set<int> x1 = init;
     BOOST_TEST(x1.empty());
@@ -450,15 +439,15 @@ UNORDERED_AUTO_TEST(test_default_initializer_list) {
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(test_initializer_list) {
-    std::cerr<<"Initializer List Tests\n";
-    boost::unordered_set<int> x1 = { 2, 10, 45, -5 };
+UNORDERED_AUTO_TEST(test_initializer_list)
+{
+    std::cerr << "Initializer List Tests\n";
+    boost::unordered_set<int> x1 = {2, 10, 45, -5};
     BOOST_TEST(x1.find(10) != x1.end());
     BOOST_TEST(x1.find(46) == x1.end());
 }
 
 #endif
-
 }
 
 RUN_TESTS()
diff --git a/test/unordered/copy_tests.cpp b/test/unordered/copy_tests.cpp
index 14502ff2..5cd5187a 100644
--- a/test/unordered/copy_tests.cpp
+++ b/test/unordered/copy_tests.cpp
@@ -20,8 +20,7 @@
 
 test::seed_t initialize_seed(9063);
 
-namespace copy_tests
-{
+namespace copy_tests {
 
 template <class T>
 void copy_construct_tests1(T*, test::random_generator const& generator)
@@ -30,7 +29,7 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
 
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
-    BOOST_DEDUCED_TYPENAME T::allocator_type al;    
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
     {
         test::check_instances check_;
@@ -43,7 +42,7 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(y.get_allocator(), al));
         BOOST_TEST(x.max_load_factor() == y.max_load_factor());
         BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
+                   (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
@@ -57,7 +56,7 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
         test::unordered_equivalence_tester<T> equivalent(x);
         BOOST_TEST(equivalent(y));
         BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
+                   (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
@@ -77,7 +76,7 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
         // This isn't guaranteed:
         BOOST_TEST(y.load_factor() < y.max_load_factor());
         BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
+                   (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 }
@@ -89,7 +88,7 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
     BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-    
+
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
     {
@@ -103,7 +102,7 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(y.get_allocator(), al));
         BOOST_TEST(x.max_load_factor() == y.max_load_factor());
         BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
+                   (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
@@ -132,7 +131,7 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
         BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
+                   (allocator_type::is_select_on_copy));
         BOOST_TEST(test::equivalent(y.get_allocator(), al));
     }
 
@@ -151,73 +150,60 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
     }
 }
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::select_copy> >*
     test_set_select_copy;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::select_copy> >*
     test_multiset_select_copy;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::select_copy> >*
     test_map_select_copy;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::select_copy> >*
     test_multimap_select_copy;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_set_no_select_copy;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_multiset_no_select_copy;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_map_no_select_copy;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_multimap_no_select_copy;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
-UNORDERED_TEST(copy_construct_tests1, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)
-        (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
-UNORDERED_TEST(copy_construct_tests2, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)
-        (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(copy_construct_tests1,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(
+        test_multiset_select_copy)(test_map_select_copy)(
+        test_multimap_select_copy)(test_set_no_select_copy)(
+        test_multiset_no_select_copy)(test_map_no_select_copy)(
+        test_multimap_no_select_copy))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
+UNORDERED_TEST(copy_construct_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(
+        test_multiset_select_copy)(test_map_select_copy)(
+        test_multimap_select_copy)(test_set_no_select_copy)(
+        test_multiset_no_select_copy)(test_map_no_select_copy)(
+        test_multimap_no_select_copy))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/emplace_tests.cpp b/test/unordered/emplace_tests.cpp
index b6682939..04c0253b 100644
--- a/test/unordered/emplace_tests.cpp
+++ b/test/unordered/emplace_tests.cpp
@@ -15,424 +15,456 @@
 #include "../helpers/count.hpp"
 #include <string>
 
-
 // Test that various emplace methods work with different numbers of
 // arguments.
 
 namespace emplace_tests {
-    // Constructible with 2 to 10 arguments
-    struct emplace_value : private test::counted_object {
-        typedef int A0;
-        typedef std::string A1;
-        typedef char A2;
-        typedef int A3;
-        typedef int A4;
-        typedef int A5;
-        typedef int A6;
-        typedef int A7;
-        typedef int A8;
-        typedef int A9;
+// Constructible with 2 to 10 arguments
+struct emplace_value : private test::counted_object
+{
+    typedef int A0;
+    typedef std::string A1;
+    typedef char A2;
+    typedef int A3;
+    typedef int A4;
+    typedef int A5;
+    typedef int A6;
+    typedef int A7;
+    typedef int A8;
+    typedef int A9;
 
-        int arg_count;
+    int arg_count;
 
-        A0 a0;
-        A1 a1;
-        A2 a2;
-        A3 a3;
-        A4 a4;
-        A5 a5;
-        A6 a6;
-        A7 a7;
-        A8 a8;
-        A9 a9;
+    A0 a0;
+    A1 a1;
+    A2 a2;
+    A3 a3;
+    A4 a4;
+    A5 a5;
+    A6 a6;
+    A7 a7;
+    A8 a8;
+    A9 a9;
 
-        emplace_value(
-                A0 const& b0, A1 const& b1) :
-            arg_count(2),
-            a0(b0), a1(b1) {}
+    emplace_value(A0 const& b0, A1 const& b1) : arg_count(2), a0(b0), a1(b1) {}
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2) :
-            arg_count(3),
-            a0(b0), a1(b1), a2(b2) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2)
+        : arg_count(3), a0(b0), a1(b1), a2(b2)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3) :
-            arg_count(4),
-            a0(b0), a1(b1), a2(b2), a3(b3) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3)
+        : arg_count(4), a0(b0), a1(b1), a2(b2), a3(b3)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
-                A4 const& b4) :
-            arg_count(5),
-            a0(b0), a1(b1), a2(b2), a3(b3), a4(b4) {}
+    emplace_value(
+        A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3, A4 const& b4)
+        : arg_count(5), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
-                A4 const& b4, A5 const& b5) :
-            arg_count(6),
-            a0(b0), a1(b1), a2(b2), a3(b3), a4(b4),
-            a5(b5) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+        A4 const& b4, A5 const& b5)
+        : arg_count(6), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
-                A4 const& b4, A5 const& b5, A6 const& b6) :
-            arg_count(7),
-            a0(b0), a1(b1), a2(b2), a3(b3), a4(b4),
-            a5(b5), a6(b6) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+        A4 const& b4, A5 const& b5, A6 const& b6)
+        : arg_count(7), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
-                A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7) :
-            arg_count(8),
-            a0(b0), a1(b1), a2(b2), a3(b3), a4(b4),
-            a5(b5), a6(b6), a7(b7) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+        A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7)
+        : arg_count(8), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6),
+          a7(b7)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
-                A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7,
-                A8 const& b8) :
-            arg_count(9),
-            a0(b0), a1(b1), a2(b2), a3(b3), a4(b4),
-            a5(b5), a6(b6), a7(b7), a8(b8) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+        A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7, A8 const& b8)
+        : arg_count(9), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6),
+          a7(b7), a8(b8)
+    {
+    }
 
-        emplace_value(
-                A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
-                A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7,
-                A8 const& b8, A9 const& b9) :
-            arg_count(10),
-            a0(b0), a1(b1), a2(b2), a3(b3), a4(b4),
-            a5(b5), a6(b6), a7(b7), a8(b8), a9(b9) {}
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+        A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7, A8 const& b8,
+        A9 const& b9)
+        : arg_count(10), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6),
+          a7(b7), a8(b8), a9(b9)
+    {
+    }
 
+    friend std::size_t hash_value(emplace_value const& x)
+    {
+        std::size_t r1 = 23894278u;
+        if (x.arg_count >= 1)
+            boost::hash_combine(r1, x.a0);
+        if (x.arg_count >= 2)
+            boost::hash_combine(r1, x.a1);
+        if (x.arg_count >= 3)
+            boost::hash_combine(r1, x.a2);
+        if (x.arg_count >= 4)
+            boost::hash_combine(r1, x.a3);
+        if (x.arg_count >= 5)
+            boost::hash_combine(r1, x.a4);
+        if (x.arg_count >= 6)
+            boost::hash_combine(r1, x.a5);
+        if (x.arg_count >= 7)
+            boost::hash_combine(r1, x.a6);
+        if (x.arg_count >= 8)
+            boost::hash_combine(r1, x.a7);
+        if (x.arg_count >= 9)
+            boost::hash_combine(r1, x.a8);
+        if (x.arg_count >= 10)
+            boost::hash_combine(r1, x.a9);
+        return r1;
+    }
 
-        friend std::size_t hash_value(emplace_value const& x) {
-            std::size_t r1 = 23894278u;
-            if (x.arg_count >= 1) boost::hash_combine(r1, x.a0);
-            if (x.arg_count >= 2) boost::hash_combine(r1, x.a1);
-            if (x.arg_count >= 3) boost::hash_combine(r1, x.a2);
-            if (x.arg_count >= 4) boost::hash_combine(r1, x.a3);
-            if (x.arg_count >= 5) boost::hash_combine(r1, x.a4);
-            if (x.arg_count >= 6) boost::hash_combine(r1, x.a5);
-            if (x.arg_count >= 7) boost::hash_combine(r1, x.a6);
-            if (x.arg_count >= 8) boost::hash_combine(r1, x.a7);
-            if (x.arg_count >= 9) boost::hash_combine(r1, x.a8);
-            if (x.arg_count >= 10) boost::hash_combine(r1, x.a9);
-            return r1;
+    friend bool operator==(emplace_value const& x, emplace_value const& y)
+    {
+        if (x.arg_count != y.arg_count) {
+            return false;
         }
-
-        friend bool operator==(emplace_value const& x, emplace_value const& y) {
-            if (x.arg_count != y.arg_count) { return false; }
-            if (x.arg_count >= 1 && x.a0 != y.a0) { return false; }
-            if (x.arg_count >= 2 && x.a1 != y.a1) { return false; }
-            if (x.arg_count >= 3 && x.a2 != y.a2) { return false; }
-            if (x.arg_count >= 4 && x.a3 != y.a3) { return false; }
-            if (x.arg_count >= 5 && x.a4 != y.a4) { return false; }
-            if (x.arg_count >= 6 && x.a5 != y.a5) { return false; }
-            if (x.arg_count >= 7 && x.a6 != y.a6) { return false; }
-            if (x.arg_count >= 8 && x.a7 != y.a7) { return false; }
-            if (x.arg_count >= 9 && x.a8 != y.a8) { return false; }
-            if (x.arg_count >= 10 && x.a9 != y.a9) { return false; }
-            return true;
+        if (x.arg_count >= 1 && x.a0 != y.a0) {
+            return false;
         }
-    private:
-        emplace_value();
-        emplace_value(emplace_value const&);
-    };
-
-    UNORDERED_AUTO_TEST(emplace_set) {
-        test::check_instances check_;
-
-        typedef boost::unordered_set<emplace_value,
-                boost::hash<emplace_value> > container;
-        typedef container::iterator iterator;
-        typedef std::pair<iterator, bool> return_type;
-        container x(10);
-        iterator i1;
-        return_type r1,r2;
-
-        // 2 args
-
-        emplace_value v1(10, "x");
-        r1 = x.emplace(10, std::string("x"));
-        BOOST_TEST_EQ(x.size(), 1u);
-        BOOST_TEST(r1.second);
-        BOOST_TEST(*r1.first == v1);
-        BOOST_TEST(r1.first == x.find(v1));
-        BOOST_TEST_EQ(check_.instances(), 2);
-        BOOST_TEST_EQ(check_.constructions(), 2);
-
-        // 3 args
-
-        emplace_value v2(3, "foo", 'a');
-        r1 = x.emplace(3, "foo", 'a');
-        BOOST_TEST_EQ(x.size(), 2u);
-        BOOST_TEST(r1.second);
-        BOOST_TEST(*r1.first == v2);
-        BOOST_TEST(r1.first == x.find(v2));
-        BOOST_TEST_EQ(check_.instances(), 4);
-        BOOST_TEST_EQ(check_.constructions(), 4);
-
-        // 7 args with hint + duplicate
-
-        emplace_value v3(25, "something", 'z', 4, 5, 6, 7);
-        i1 = x.emplace_hint(r1.first, 25, "something", 'z', 4, 5, 6, 7);
-        BOOST_TEST_EQ(x.size(), 3u);
-        BOOST_TEST(*i1 == v3);
-        BOOST_TEST(i1 == x.find(v3));
-        BOOST_TEST_EQ(check_.instances(), 6);
-        BOOST_TEST_EQ(check_.constructions(), 6);
-
-        r2 = x.emplace(25, "something", 'z', 4, 5, 6, 7);
-        BOOST_TEST_EQ(x.size(), 3u);
-        BOOST_TEST(!r2.second);
-        BOOST_TEST(i1 == r2.first);
-        // The container has to construct an object in order to check
-        // whether it can emplace, so there's an extra cosntruction
-        // here.
-        BOOST_TEST_EQ(check_.instances(), 6);
-        BOOST_TEST_EQ(check_.constructions(), 7);
-
-        // 10 args + hint duplicate
-
-        std::string s1;
-        emplace_value v4(10, s1, 'a', 4, 5, 6, 7, 8, 9, 10);
-        r1 = x.emplace(10, s1, 'a', 4, 5, 6, 7, 8, 9, 10);
-        BOOST_TEST_EQ(x.size(), 4u);
-        BOOST_TEST(r1.second);
-        BOOST_TEST(*r1.first == v4);
-        BOOST_TEST(r1.first == x.find(v4));
-        BOOST_TEST_EQ(check_.instances(), 8);
-        BOOST_TEST_EQ(check_.constructions(), 9);
-
-        BOOST_TEST(r1.first ==
-                x.emplace_hint(r1.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
-        BOOST_TEST(r1.first ==
-                x.emplace_hint(r2.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
-        BOOST_TEST(r1.first ==
-                x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
-        BOOST_TEST_EQ(check_.instances(), 8);
-        BOOST_TEST_EQ(check_.constructions(), 12);
-
-        BOOST_TEST_EQ(x.size(), 4u);
-        BOOST_TEST(x.count(v1) == 1);
-        BOOST_TEST(x.count(v2) == 1);
-        BOOST_TEST(x.count(v3) == 1);
-        BOOST_TEST(x.count(v4) == 1);
+        if (x.arg_count >= 2 && x.a1 != y.a1) {
+            return false;
+        }
+        if (x.arg_count >= 3 && x.a2 != y.a2) {
+            return false;
+        }
+        if (x.arg_count >= 4 && x.a3 != y.a3) {
+            return false;
+        }
+        if (x.arg_count >= 5 && x.a4 != y.a4) {
+            return false;
+        }
+        if (x.arg_count >= 6 && x.a5 != y.a5) {
+            return false;
+        }
+        if (x.arg_count >= 7 && x.a6 != y.a6) {
+            return false;
+        }
+        if (x.arg_count >= 8 && x.a7 != y.a7) {
+            return false;
+        }
+        if (x.arg_count >= 9 && x.a8 != y.a8) {
+            return false;
+        }
+        if (x.arg_count >= 10 && x.a9 != y.a9) {
+            return false;
+        }
+        return true;
     }
 
-    UNORDERED_AUTO_TEST(emplace_multiset) {
-        test::check_instances check_;
+  private:
+    emplace_value();
+    emplace_value(emplace_value const&);
+};
 
-        typedef boost::unordered_multiset<emplace_value,
-                boost::hash<emplace_value> > container;
-        typedef container::iterator iterator;
-        container x(10);
-        iterator i1, i2;
+UNORDERED_AUTO_TEST(emplace_set)
+{
+    test::check_instances check_;
 
-        // 2 args.
+    typedef boost::unordered_set<emplace_value, boost::hash<emplace_value> >
+        container;
+    typedef container::iterator iterator;
+    typedef std::pair<iterator, bool> return_type;
+    container x(10);
+    iterator i1;
+    return_type r1, r2;
 
-        emplace_value v1(10, "x");
-        i1 = x.emplace(10, std::string("x"));
-        BOOST_TEST_EQ(x.size(), 1u);
-        BOOST_TEST(i1 == x.find(v1));
-        BOOST_TEST_EQ(check_.instances(), 2);
-        BOOST_TEST_EQ(check_.constructions(), 2);
+    // 2 args
 
-        // 4 args + duplicate
+    emplace_value v1(10, "x");
+    r1 = x.emplace(10, std::string("x"));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(*r1.first == v1);
+    BOOST_TEST(r1.first == x.find(v1));
+    BOOST_TEST_EQ(check_.instances(), 2);
+    BOOST_TEST_EQ(check_.constructions(), 2);
 
-        emplace_value v2(4, "foo", 'a', 15);
-        i1 = x.emplace(4, "foo", 'a', 15);
-        BOOST_TEST_EQ(x.size(), 2u);
-        BOOST_TEST(i1 == x.find(v2));
-        BOOST_TEST_EQ(check_.instances(), 4);
-        BOOST_TEST_EQ(check_.constructions(), 4);
+    // 3 args
 
-        i2 = x.emplace(4, "foo", 'a', 15);
-        BOOST_TEST_EQ(x.size(), 3u);
-        BOOST_TEST(i1 != i2);
-        BOOST_TEST(*i1 == *i2);
-        BOOST_TEST(x.count(*i1) == 2);
-        BOOST_TEST_EQ(check_.instances(), 5);
-        BOOST_TEST_EQ(check_.constructions(), 5);
+    emplace_value v2(3, "foo", 'a');
+    r1 = x.emplace(3, "foo", 'a');
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(*r1.first == v2);
+    BOOST_TEST(r1.first == x.find(v2));
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
 
-        // 7 args + duplicate using hint.
+    // 7 args with hint + duplicate
 
-        emplace_value v3(7, "", 'z', 4, 5, 6, 7);
-        i1 = x.emplace(7, "", 'z', 4, 5, 6, 7);
-        BOOST_TEST_EQ(x.size(), 4u);
-        BOOST_TEST_EQ(i1->a2, 'z');
-        BOOST_TEST(x.count(*i1) == 1);
-        BOOST_TEST(i1 == x.find(v3));
-        BOOST_TEST_EQ(check_.instances(), 7);
-        BOOST_TEST_EQ(check_.constructions(), 7);
+    emplace_value v3(25, "something", 'z', 4, 5, 6, 7);
+    i1 = x.emplace_hint(r1.first, 25, "something", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(*i1 == v3);
+    BOOST_TEST(i1 == x.find(v3));
+    BOOST_TEST_EQ(check_.instances(), 6);
+    BOOST_TEST_EQ(check_.constructions(), 6);
 
-        i2 = x.emplace_hint(i1, 7, "", 'z', 4, 5, 6, 7);
-        BOOST_TEST_EQ(x.size(), 5u);
-        BOOST_TEST(*i1 == *i2);
-        BOOST_TEST(i1 != i2);
-        BOOST_TEST(x.count(*i1) == 2);
-        BOOST_TEST_EQ(check_.instances(), 8);
-        BOOST_TEST_EQ(check_.constructions(), 8);
+    r2 = x.emplace(25, "something", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(!r2.second);
+    BOOST_TEST(i1 == r2.first);
+    // The container has to construct an object in order to check
+    // whether it can emplace, so there's an extra cosntruction
+    // here.
+    BOOST_TEST_EQ(check_.instances(), 6);
+    BOOST_TEST_EQ(check_.constructions(), 7);
 
-        // 10 args with bad hint + duplicate
+    // 10 args + hint duplicate
 
-        emplace_value v4(10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
-        i1 = x.emplace_hint(i2, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
-        BOOST_TEST_EQ(x.size(), 6u);
-        BOOST_TEST_EQ(i1->arg_count, 10);
-        BOOST_TEST(i1 == x.find(v4));
-        BOOST_TEST_EQ(check_.instances(), 10);
-        BOOST_TEST_EQ(check_.constructions(), 10);
+    std::string s1;
+    emplace_value v4(10, s1, 'a', 4, 5, 6, 7, 8, 9, 10);
+    r1 = x.emplace(10, s1, 'a', 4, 5, 6, 7, 8, 9, 10);
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(*r1.first == v4);
+    BOOST_TEST(r1.first == x.find(v4));
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 9);
 
-        i2 = x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
-        BOOST_TEST_EQ(x.size(), 7u);
-        BOOST_TEST(*i1 == *i2);
-        BOOST_TEST(i1 != i2);
-        BOOST_TEST(x.count(*i1) == 2);
-        BOOST_TEST_EQ(check_.instances(), 11);
-        BOOST_TEST_EQ(check_.constructions(), 11);
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r1.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r2.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST(
+        r1.first == x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 12);
 
-        BOOST_TEST_EQ(x.count(v1), 1u);
-        BOOST_TEST_EQ(x.count(v2), 2u);
-        BOOST_TEST_EQ(x.count(v3), 2u);
-    }
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST(x.count(v1) == 1);
+    BOOST_TEST(x.count(v2) == 1);
+    BOOST_TEST(x.count(v3) == 1);
+    BOOST_TEST(x.count(v4) == 1);
+}
 
-    UNORDERED_AUTO_TEST(emplace_map) {
-        test::check_instances check_;
+UNORDERED_AUTO_TEST(emplace_multiset)
+{
+    test::check_instances check_;
 
-        typedef boost::unordered_map<emplace_value, emplace_value,
-                boost::hash<emplace_value> > container;
-        typedef container::iterator iterator;
-        typedef std::pair<iterator, bool> return_type;
-        container x(10);
-        return_type r1, r2;
+    typedef boost::unordered_multiset<emplace_value,
+        boost::hash<emplace_value> >
+        container;
+    typedef container::iterator iterator;
+    container x(10);
+    iterator i1, i2;
 
-        // 5/8 args + duplicate
+    // 2 args.
 
-        emplace_value k1(5, "", 'b', 4, 5);
-        emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
-        r1 = x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(5, "", 'b', 4, 5),
-                boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
-        BOOST_TEST_EQ(x.size(), 1u);
-        BOOST_TEST(r1.second);
-        BOOST_TEST(x.find(k1) == r1.first);
-        BOOST_TEST(x.find(k1)->second == m1);
-        BOOST_TEST_EQ(check_.instances(), 4);
-        BOOST_TEST_EQ(check_.constructions(), 4);
+    emplace_value v1(10, "x");
+    i1 = x.emplace(10, std::string("x"));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(i1 == x.find(v1));
+    BOOST_TEST_EQ(check_.instances(), 2);
+    BOOST_TEST_EQ(check_.constructions(), 2);
 
-        r2 = x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(5, "", 'b', 4, 5),
-                boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
-        BOOST_TEST_EQ(x.size(), 1u);
-        BOOST_TEST(!r2.second);
-        BOOST_TEST(r1.first == r2.first);
-        BOOST_TEST(x.find(k1)->second == m1);
-        BOOST_TEST_EQ(check_.instances(), 4);
-        // constructions could possibly be 5 if the implementation only
-        // constructed the key.
-        BOOST_TEST_EQ(check_.constructions(), 6);
+    // 4 args + duplicate
 
-        // 9/3 args + duplicates with hints, different mapped value.
+    emplace_value v2(4, "foo", 'a', 15);
+    i1 = x.emplace(4, "foo", 'a', 15);
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(i1 == x.find(v2));
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
 
-        emplace_value k2(9, "", 'b', 4, 5, 6, 7, 8, 9);
-        emplace_value m2(3, "aaa", 'm');
-        r1 = x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(3, "aaa", 'm'));
-        BOOST_TEST_EQ(x.size(), 2u);
-        BOOST_TEST(r1.second);
-        BOOST_TEST(r1.first->first.arg_count == 9);
-        BOOST_TEST(r1.first->second.arg_count == 3);
-        BOOST_TEST(x.find(k2) == r1.first);
-        BOOST_TEST(x.find(k2)->second == m2);
-        BOOST_TEST_EQ(check_.instances(), 8);
-        BOOST_TEST_EQ(check_.constructions(), 10);
+    i2 = x.emplace(4, "foo", 'a', 15);
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(*i1 == *i2);
+    BOOST_TEST(x.count(*i1) == 2);
+    BOOST_TEST_EQ(check_.instances(), 5);
+    BOOST_TEST_EQ(check_.constructions(), 5);
 
-        BOOST_TEST(r1.first == x.emplace_hint(r1.first,
-                boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(15, "jkjk")));
-        BOOST_TEST(r1.first == x.emplace_hint(r2.first,
-                boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(275, "xxx", 'm', 6)));
-        BOOST_TEST(r1.first == x.emplace_hint(x.end(),
-                boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(-10, "blah blah", '\0')));
-        BOOST_TEST_EQ(x.size(), 2u);
-        BOOST_TEST(x.find(k2)->second == m2);
-        BOOST_TEST_EQ(check_.instances(), 8);
-        BOOST_TEST_EQ(check_.constructions(), 16);
-    }
+    // 7 args + duplicate using hint.
 
-    UNORDERED_AUTO_TEST(emplace_multimap) {
-        test::check_instances check_;
+    emplace_value v3(7, "", 'z', 4, 5, 6, 7);
+    i1 = x.emplace(7, "", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST_EQ(i1->a2, 'z');
+    BOOST_TEST(x.count(*i1) == 1);
+    BOOST_TEST(i1 == x.find(v3));
+    BOOST_TEST_EQ(check_.instances(), 7);
+    BOOST_TEST_EQ(check_.constructions(), 7);
 
-        typedef boost::unordered_multimap<emplace_value, emplace_value,
-                boost::hash<emplace_value> > container;
-        typedef container::iterator iterator;
-        container x(10);
-        iterator i1, i2, i3, i4;
+    i2 = x.emplace_hint(i1, 7, "", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 5u);
+    BOOST_TEST(*i1 == *i2);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(x.count(*i1) == 2);
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 8);
 
-        // 5/8 args + duplicate
+    // 10 args with bad hint + duplicate
 
-        emplace_value k1(5, "", 'b', 4, 5);
-        emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
-        i1 = x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(5, "", 'b', 4, 5),
-                boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
-        BOOST_TEST_EQ(x.size(), 1u);
-        BOOST_TEST(x.find(k1) == i1);
-        BOOST_TEST(x.find(k1)->second == m1);
-        BOOST_TEST_EQ(check_.instances(), 4);
-        BOOST_TEST_EQ(check_.constructions(), 4);
+    emplace_value v4(10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
+    i1 = x.emplace_hint(i2, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
+    BOOST_TEST_EQ(x.size(), 6u);
+    BOOST_TEST_EQ(i1->arg_count, 10);
+    BOOST_TEST(i1 == x.find(v4));
+    BOOST_TEST_EQ(check_.instances(), 10);
+    BOOST_TEST_EQ(check_.constructions(), 10);
 
-        emplace_value m1a(8, "xxx", 'z', 4, 5, 6, 7, 8);
-        i2 = x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(5, "", 'b', 4, 5),
-                boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
-        BOOST_TEST_EQ(x.size(), 2u);
-        BOOST_TEST(i1 != i2);
-        BOOST_TEST(i1->second == m1);
-        BOOST_TEST(i2->second == m1a);
-        BOOST_TEST_EQ(check_.instances(), 7);
-        BOOST_TEST_EQ(check_.constructions(), 7);
+    i2 = x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
+    BOOST_TEST_EQ(x.size(), 7u);
+    BOOST_TEST(*i1 == *i2);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(x.count(*i1) == 2);
+    BOOST_TEST_EQ(check_.instances(), 11);
+    BOOST_TEST_EQ(check_.constructions(), 11);
 
-        // 9/3 args + duplicates with hints, different mapped value.
+    BOOST_TEST_EQ(x.count(v1), 1u);
+    BOOST_TEST_EQ(x.count(v2), 2u);
+    BOOST_TEST_EQ(x.count(v3), 2u);
+}
 
-        emplace_value k2(9, "", 'b', 4, 5, 6, 7, 8, 9);
-        emplace_value m2(3, "aaa", 'm');
-        i1 = x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(3, "aaa", 'm'));
-        BOOST_TEST_EQ(x.size(), 3u);
-        BOOST_TEST(i1->first.arg_count == 9);
-        BOOST_TEST(i1->second.arg_count == 3);
-        BOOST_TEST_EQ(check_.instances(), 11);
-        BOOST_TEST_EQ(check_.constructions(), 11);
+UNORDERED_AUTO_TEST(emplace_map)
+{
+    test::check_instances check_;
 
-        emplace_value m2a(15, "jkjk");
-        i2 = x.emplace_hint(i2,
-                boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(15, "jkjk"));
-        emplace_value m2b(275, "xxx", 'm', 6);
-        i3 = x.emplace_hint(i1,
-                boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(275, "xxx", 'm', 6));
-        emplace_value m2c(-10, "blah blah", '\0');
-        i4 = x.emplace_hint(x.end(),
-                boost::unordered::piecewise_construct,
-                boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                boost::make_tuple(-10, "blah blah", '\0'));
-        BOOST_TEST_EQ(x.size(), 6u);
-        BOOST_TEST(x.find(k2)->second == m2);
-        BOOST_TEST_EQ(check_.instances(), 20);
-        BOOST_TEST_EQ(check_.constructions(), 20);
-    }
+    typedef boost::unordered_map<emplace_value, emplace_value,
+        boost::hash<emplace_value> >
+        container;
+    typedef container::iterator iterator;
+    typedef std::pair<iterator, bool> return_type;
+    container x(10);
+    return_type r1, r2;
+
+    // 5/8 args + duplicate
+
+    emplace_value k1(5, "", 'b', 4, 5);
+    emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
+    r1 = x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(5, "", 'b', 4, 5),
+        boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(x.find(k1) == r1.first);
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    r2 = x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(5, "", 'b', 4, 5),
+        boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(!r2.second);
+    BOOST_TEST(r1.first == r2.first);
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    // constructions could possibly be 5 if the implementation only
+    // constructed the key.
+    BOOST_TEST_EQ(check_.constructions(), 6);
+
+    // 9/3 args + duplicates with hints, different mapped value.
+
+    emplace_value k2(9, "", 'b', 4, 5, 6, 7, 8, 9);
+    emplace_value m2(3, "aaa", 'm');
+    r1 = x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+        boost::make_tuple(3, "aaa", 'm'));
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(r1.first->first.arg_count == 9);
+    BOOST_TEST(r1.first->second.arg_count == 3);
+    BOOST_TEST(x.find(k2) == r1.first);
+    BOOST_TEST(x.find(k2)->second == m2);
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 10);
+
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r1.first, boost::unordered::piecewise_construct,
+                   boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                   boost::make_tuple(15, "jkjk")));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r2.first, boost::unordered::piecewise_construct,
+                   boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                   boost::make_tuple(275, "xxx", 'm', 6)));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(x.end(), boost::unordered::piecewise_construct,
+                   boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                   boost::make_tuple(-10, "blah blah", '\0')));
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(x.find(k2)->second == m2);
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 16);
+}
+
+UNORDERED_AUTO_TEST(emplace_multimap)
+{
+    test::check_instances check_;
+
+    typedef boost::unordered_multimap<emplace_value, emplace_value,
+        boost::hash<emplace_value> >
+        container;
+    typedef container::iterator iterator;
+    container x(10);
+    iterator i1, i2, i3, i4;
+
+    // 5/8 args + duplicate
+
+    emplace_value k1(5, "", 'b', 4, 5);
+    emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
+    i1 = x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(5, "", 'b', 4, 5),
+        boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(x.find(k1) == i1);
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    emplace_value m1a(8, "xxx", 'z', 4, 5, 6, 7, 8);
+    i2 = x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(5, "", 'b', 4, 5),
+        boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(i1->second == m1);
+    BOOST_TEST(i2->second == m1a);
+    BOOST_TEST_EQ(check_.instances(), 7);
+    BOOST_TEST_EQ(check_.constructions(), 7);
+
+    // 9/3 args + duplicates with hints, different mapped value.
+
+    emplace_value k2(9, "", 'b', 4, 5, 6, 7, 8, 9);
+    emplace_value m2(3, "aaa", 'm');
+    i1 = x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+        boost::make_tuple(3, "aaa", 'm'));
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(i1->first.arg_count == 9);
+    BOOST_TEST(i1->second.arg_count == 3);
+    BOOST_TEST_EQ(check_.instances(), 11);
+    BOOST_TEST_EQ(check_.constructions(), 11);
+
+    emplace_value m2a(15, "jkjk");
+    i2 = x.emplace_hint(i2, boost::unordered::piecewise_construct,
+        boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+        boost::make_tuple(15, "jkjk"));
+    emplace_value m2b(275, "xxx", 'm', 6);
+    i3 = x.emplace_hint(i1, boost::unordered::piecewise_construct,
+        boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+        boost::make_tuple(275, "xxx", 'm', 6));
+    emplace_value m2c(-10, "blah blah", '\0');
+    i4 = x.emplace_hint(x.end(), boost::unordered::piecewise_construct,
+        boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+        boost::make_tuple(-10, "blah blah", '\0'));
+    BOOST_TEST_EQ(x.size(), 6u);
+    BOOST_TEST(x.find(k2)->second == m2);
+    BOOST_TEST_EQ(check_.instances(), 20);
+    BOOST_TEST_EQ(check_.constructions(), 20);
+}
 }
 
 RUN_TESTS()
diff --git a/test/unordered/equality_tests.cpp b/test/unordered/equality_tests.cpp
index 82b4ef27..7daea70c 100644
--- a/test/unordered/equality_tests.cpp
+++ b/test/unordered/equality_tests.cpp
@@ -14,172 +14,152 @@
 #include <list>
 #include "../helpers/test.hpp"
 
-namespace equality_tests
+namespace equality_tests {
+struct mod_compare
 {
-    struct mod_compare
+    bool alt_hash_;
+
+    explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
+
+    bool operator()(int x, int y) const { return x % 1000 == y % 1000; }
+
+    std::size_t operator()(int x) const
     {
-        bool alt_hash_;
+        return alt_hash_ ? static_cast<std::size_t>(x % 250)
+                         : static_cast<std::size_t>((x + 5) % 250);
+    }
+};
 
-        explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
-
-        bool operator()(int x, int y) const
-        {
-            return x % 1000 == y % 1000;
-        }
-
-        std::size_t operator()(int x) const
-        {
-            return alt_hash_ ?
-                static_cast<std::size_t>(x % 250) :
-                static_cast<std::size_t>((x + 5) % 250);
-        }
-    };
-
-#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                         \
-    {                                                                       \
-        boost::unordered_set<int, mod_compare, mod_compare> set1, set2;     \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
-        BOOST_TEST(set1 op set2);                                           \
+#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
+    {                                                                          \
+        boost::unordered_set<int, mod_compare, mod_compare> set1, set2;        \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                \
+        BOOST_TEST(set1 op set2);                                              \
     }
 
-#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                    \
-    {                                                                       \
-        boost::unordered_multiset<int, mod_compare, mod_compare>            \
-            set1, set2;                                                     \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
-        BOOST_TEST(set1 op set2);                                           \
+#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                       \
+    {                                                                          \
+        boost::unordered_multiset<int, mod_compare, mod_compare> set1, set2;   \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                \
+        BOOST_TEST(set1 op set2);                                              \
     }
 
-#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                         \
-    {                                                                       \
-        boost::unordered_map<int, int, mod_compare, mod_compare>            \
-            map1, map2;                                                     \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
-        BOOST_TEST(map1 op map2);                                           \
+#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                            \
+    {                                                                          \
+        boost::unordered_map<int, int, mod_compare, mod_compare> map1, map2;   \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                \
+        BOOST_TEST(map1 op map2);                                              \
     }
 
-#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                    \
-    {                                                                       \
-        boost::unordered_multimap<int, int, mod_compare, mod_compare>       \
-            map1, map2;                                                     \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
-        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
-        BOOST_TEST(map1 op map2);                                           \
+#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                       \
+    {                                                                          \
+        boost::unordered_multimap<int, int, mod_compare, mod_compare> map1,    \
+            map2;                                                              \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                \
+        BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                \
+        BOOST_TEST(map1 op map2);                                              \
     }
 
 #define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
-#define UNORDERED_MAP_INSERT(r, map, item) \
+#define UNORDERED_MAP_INSERT(r, map, item)                                     \
     map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
 
-    UNORDERED_AUTO_TEST(equality_size_tests)
-    {
-        boost::unordered_set<int> x1, x2;
-        BOOST_TEST(x1 == x2);
-        BOOST_TEST(!(x1 != x2));
+UNORDERED_AUTO_TEST(equality_size_tests)
+{
+    boost::unordered_set<int> x1, x2;
+    BOOST_TEST(x1 == x2);
+    BOOST_TEST(!(x1 != x2));
 
-        x1.insert(1);
-        BOOST_TEST(x1 != x2);
-        BOOST_TEST(!(x1 == x2));
-        BOOST_TEST(x2 != x1);
-        BOOST_TEST(!(x2 == x1));
-        
-        x2.insert(1);
-        BOOST_TEST(x1 == x2);
-        BOOST_TEST(!(x1 != x2));
-        
-        x2.insert(2);
-        BOOST_TEST(x1 != x2);
-        BOOST_TEST(!(x1 == x2));
-        BOOST_TEST(x2 != x1);
-        BOOST_TEST(!(x2 == x1));
-    }
-    
-    UNORDERED_AUTO_TEST(equality_key_value_tests)
-    {
-        UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
-        UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
-        UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
-    }
-    
-    UNORDERED_AUTO_TEST(equality_collision_test)
-    {
-        UNORDERED_EQUALITY_MULTISET_TEST(
-            (1), !=, (501))
-        UNORDERED_EQUALITY_MULTISET_TEST(
-            (1)(251), !=, (1)(501))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
-        UNORDERED_EQUALITY_MULTISET_TEST(
-            (1)(501), ==, (1)(501))
-        UNORDERED_EQUALITY_SET_TEST(
-            (1)(501), ==, (501)(1))
-    }
+    x1.insert(1);
+    BOOST_TEST(x1 != x2);
+    BOOST_TEST(!(x1 == x2));
+    BOOST_TEST(x2 != x1);
+    BOOST_TEST(!(x2 == x1));
 
-    UNORDERED_AUTO_TEST(equality_group_size_test)
-    {
-        UNORDERED_EQUALITY_MULTISET_TEST(
-            (10)(20)(20), !=, (10)(10)(20))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((10)(1))((20)(1))((20)(1)), !=,
-            ((10)(1))((20)(1))((10)(1)))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((20)(1))((10)(1))((10)(1)), ==,
-            ((10)(1))((20)(1))((10)(1)))
-    }
-    
-    UNORDERED_AUTO_TEST(equality_map_value_test)
-    {
-        UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(1)), !=, ((1)(2)))
-        UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(1)), ==, ((1)(1)))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(1)), !=, ((1)(2)))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(2))((1)(1)), ==, ((1)(1))((1)(2)))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(2))((1)(1)), !=, ((1)(1))((1)(3)))
-    }
+    x2.insert(1);
+    BOOST_TEST(x1 == x2);
+    BOOST_TEST(!(x1 != x2));
 
-    UNORDERED_AUTO_TEST(equality_predicate_test)
-    {
-        UNORDERED_EQUALITY_SET_TEST(
-            (1), !=, (1001))
-        UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)))
-    }
+    x2.insert(2);
+    BOOST_TEST(x1 != x2);
+    BOOST_TEST(!(x1 == x2));
+    BOOST_TEST(x2 != x1);
+    BOOST_TEST(!(x2 == x1));
+}
 
-    UNORDERED_AUTO_TEST(equality_multiple_group_test)
-    {
-        UNORDERED_EQUALITY_MULTISET_TEST(
-            (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
-            (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1)
-        );
-    }
+UNORDERED_AUTO_TEST(equality_key_value_tests)
+{
+    UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
+    UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
+    UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
+}
 
-    // Test that equality still works when the two containers have
-    // different hash functions but the same equality predicate.
+UNORDERED_AUTO_TEST(equality_collision_test)
+{
+    UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (501))
+    UNORDERED_EQUALITY_MULTISET_TEST((1)(251), !=, (1)(501))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
+    UNORDERED_EQUALITY_MULTISET_TEST((1)(501), ==, (1)(501))
+    UNORDERED_EQUALITY_SET_TEST((1)(501), ==, (501)(1))
+}
 
-    UNORDERED_AUTO_TEST(equality_different_hash_test)
-    {
-        typedef boost::unordered_set<int, mod_compare, mod_compare> set;
-        set set1(0, mod_compare(false), mod_compare(false));
-        set set2(0, mod_compare(true), mod_compare(true));
-        BOOST_TEST(set1 == set2);
-        set1.insert(1); set2.insert(2);
-        BOOST_TEST(set1 != set2);
-        set1.insert(2); set2.insert(1);
-        BOOST_TEST(set1 == set2);
-        set1.insert(10); set2.insert(20);
-        BOOST_TEST(set1 != set2);
-        set1.insert(20); set2.insert(10);
-        BOOST_TEST(set1 == set2);
-    }
+UNORDERED_AUTO_TEST(equality_group_size_test)
+{
+    UNORDERED_EQUALITY_MULTISET_TEST((10)(20)(20), !=, (10)(10)(20))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(
+        ((10)(1))((20)(1))((20)(1)), !=, ((10)(1))((20)(1))((10)(1)))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(
+        ((20)(1))((10)(1))((10)(1)), ==, ((10)(1))((20)(1))((10)(1)))
+}
+
+UNORDERED_AUTO_TEST(equality_map_value_test)
+{
+    UNORDERED_EQUALITY_MAP_TEST(((1)(1)), !=, ((1)(2)))
+    UNORDERED_EQUALITY_MAP_TEST(((1)(1)), ==, ((1)(1)))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1)), !=, ((1)(2)))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), ==, ((1)(1))((1)(2)))
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), !=, ((1)(1))((1)(3)))
+}
+
+UNORDERED_AUTO_TEST(equality_predicate_test)
+{
+    UNORDERED_EQUALITY_SET_TEST((1), !=, (1001))
+    UNORDERED_EQUALITY_MAP_TEST(((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)))
+}
+
+UNORDERED_AUTO_TEST(equality_multiple_group_test)
+{
+    UNORDERED_EQUALITY_MULTISET_TEST(
+        (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
+        (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1));
+}
+
+// Test that equality still works when the two containers have
+// different hash functions but the same equality predicate.
+
+UNORDERED_AUTO_TEST(equality_different_hash_test)
+{
+    typedef boost::unordered_set<int, mod_compare, mod_compare> set;
+    set set1(0, mod_compare(false), mod_compare(false));
+    set set2(0, mod_compare(true), mod_compare(true));
+    BOOST_TEST(set1 == set2);
+    set1.insert(1);
+    set2.insert(2);
+    BOOST_TEST(set1 != set2);
+    set1.insert(2);
+    set2.insert(1);
+    BOOST_TEST(set1 == set2);
+    set1.insert(10);
+    set2.insert(20);
+    BOOST_TEST(set1 != set2);
+    set1.insert(20);
+    set2.insert(10);
+    BOOST_TEST(set1 == set2);
+}
 }
 
 RUN_TESTS()
diff --git a/test/unordered/equivalent_keys_tests.cpp b/test/unordered/equivalent_keys_tests.cpp
index cf3e792c..72ab057e 100644
--- a/test/unordered/equivalent_keys_tests.cpp
+++ b/test/unordered/equivalent_keys_tests.cpp
@@ -27,7 +27,7 @@ void test_equal_insertion(Iterator begin, Iterator end)
     Container x1;
     tracker x2 = test::create_ordered(x1);
 
-    for(Iterator it = begin; it != end; ++it) {
+    for (Iterator it = begin; it != end; ++it) {
         x1.insert(*it);
         x2.insert(*it);
         x2.compare_key(x1, *it);
@@ -39,13 +39,7 @@ void test_equal_insertion(Iterator begin, Iterator end)
 
 UNORDERED_AUTO_TEST(set_tests)
 {
-    int values[][5] = {
-        {1},
-        {54, 23},
-        {-13, 65},
-        {77, 77},
-        {986, 25, 986}
-    };
+    int values[][5] = {{1}, {54, 23}, {-13, 65}, {77, 77}, {986, 25, 986}};
 
     typedef boost::unordered_set<int> set;
     typedef boost::unordered_multiset<int> multiset;
@@ -67,19 +61,19 @@ UNORDERED_AUTO_TEST(map_tests)
 {
     typedef test::list<std::pair<int const, int> > values_type;
     values_type v[5];
-    v[0].push_back(std::pair<int const, int>(1,1));
-    v[1].push_back(std::pair<int const, int>(28,34));
-    v[1].push_back(std::pair<int const, int>(16,58));
+    v[0].push_back(std::pair<int const, int>(1, 1));
+    v[1].push_back(std::pair<int const, int>(28, 34));
+    v[1].push_back(std::pair<int const, int>(16, 58));
     v[1].push_back(std::pair<int const, int>(-124, 62));
-    v[2].push_back(std::pair<int const, int>(432,12));
-    v[2].push_back(std::pair<int const, int>(9,13));
-    v[2].push_back(std::pair<int const, int>(432,24));
+    v[2].push_back(std::pair<int const, int>(432, 12));
+    v[2].push_back(std::pair<int const, int>(9, 13));
+    v[2].push_back(std::pair<int const, int>(432, 24));
 
-    for(int i = 0; i < 5; ++i)
+    for (int i = 0; i < 5; ++i)
         test_equal_insertion<boost::unordered_map<int, int> >(
             v[i].begin(), v[i].end());
 
-    for(int i2 = 0; i2 < 5; ++i2)
+    for (int i2 = 0; i2 < 5; ++i2)
         test_equal_insertion<boost::unordered_multimap<int, int> >(
             v[i2].begin(), v[i2].end());
 }
diff --git a/test/unordered/erase_equiv_tests.cpp b/test/unordered/erase_equiv_tests.cpp
index 4a46ddf0..1907ddd1 100644
--- a/test/unordered/erase_equiv_tests.cpp
+++ b/test/unordered/erase_equiv_tests.cpp
@@ -22,8 +22,8 @@
 #include "../objects/test.hpp"
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
-#pragma warning(disable:4267) // conversion from 'size_t' to 'unsigned int',
-                              // possible loss of data.
+#pragma warning(disable : 4267) // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data.
 #endif
 
 struct write_pair_type
@@ -31,15 +31,14 @@ struct write_pair_type
     template <class X1, class X2>
     void operator()(std::pair<X1, X2> const& x) const
     {
-        std::cout<<"("<<x.first<<","<<x.second<<")";
+        std::cout << "(" << x.first << "," << x.second << ")";
     }
 } write_pair;
 
-template <class Container>
-void write_container(Container const& x)
+template <class Container> void write_container(Container const& x)
 {
     std::for_each(x.begin(), x.end(), write_pair);
-    std::cout<<"\n";
+    std::cout << "\n";
 }
 
 // Make everything collide - for testing erase in a single bucket.
@@ -51,7 +50,10 @@ struct collision_hash
 // For testing erase in 2 buckets.
 struct collision2_hash
 {
-    std::size_t operator()(int x) const { return static_cast<std::size_t>(x & 1); }
+    std::size_t operator()(int x) const
+    {
+        return static_cast<std::size_t>(x & 1);
+    }
 };
 
 // For testing erase in lots of buckets.
@@ -60,15 +62,15 @@ struct collision3_hash
     std::size_t operator()(int x) const { return static_cast<std::size_t>(x); }
 };
 
-typedef boost::unordered_multimap<int, int,
-    collision_hash, std::equal_to<int>,
-    test::allocator1<std::pair<int const, int> > > collide_map;
-typedef boost::unordered_multimap<int, int,
-    collision2_hash, std::equal_to<int>,
-    test::allocator2<std::pair<int const, int> > > collide_map2;
-typedef boost::unordered_multimap<int, int,
-    collision3_hash, std::equal_to<int>,
-    test::allocator2<std::pair<int const, int> > > collide_map3;
+typedef boost::unordered_multimap<int, int, collision_hash, std::equal_to<int>,
+    test::allocator1<std::pair<int const, int> > >
+    collide_map;
+typedef boost::unordered_multimap<int, int, collision2_hash, std::equal_to<int>,
+    test::allocator2<std::pair<int const, int> > >
+    collide_map2;
+typedef boost::unordered_multimap<int, int, collision3_hash, std::equal_to<int>,
+    test::allocator2<std::pair<int const, int> > >
+    collide_map3;
 typedef collide_map::value_type collide_value;
 typedef test::list<collide_value> collide_list;
 
@@ -84,7 +86,7 @@ UNORDERED_AUTO_TEST(empty_range_tests)
 UNORDERED_AUTO_TEST(single_item_tests)
 {
     collide_list init;
-    init.push_back(collide_value(1,1));
+    init.push_back(collide_value(1, 1));
 
     collide_map x(init.begin(), init.end());
     x.erase(x.begin(), x.begin());
@@ -101,8 +103,8 @@ UNORDERED_AUTO_TEST(single_item_tests)
 UNORDERED_AUTO_TEST(two_equivalent_item_tests)
 {
     collide_list init;
-    init.push_back(collide_value(1,1));
-    init.push_back(collide_value(1,2));
+    init.push_back(collide_value(1, 1));
+    init.push_back(collide_value(1, 2));
 
     {
         collide_map x(init.begin(), init.end());
@@ -115,8 +117,8 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
         collide_map x(init.begin(), init.end());
         int value = test::next(x.begin())->second;
         x.erase(x.begin(), test::next(x.begin()));
-        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
-            x.begin()->first == 1 && x.begin()->second == value);
+        BOOST_TEST(x.count(1) == 1 && x.size() == 1 && x.begin()->first == 1 &&
+                   x.begin()->second == value);
         test::check_equivalent_keys(x);
     }
 
@@ -124,15 +126,15 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
         collide_map x(init.begin(), init.end());
         int value = x.begin()->second;
         x.erase(test::next(x.begin()), x.end());
-        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
-                x.begin()->first == 1 && x.begin()->second == value);
+        BOOST_TEST(x.count(1) == 1 && x.size() == 1 && x.begin()->first == 1 &&
+                   x.begin()->second == value);
         test::check_equivalent_keys(x);
     }
 }
 
 // More automated tests...
 
-template<class Range1, class Range2>
+template <class Range1, class Range2>
 bool compare(Range1 const& x, Range2 const& y)
 {
     collide_list a(x.begin(), x.end());
@@ -154,17 +156,17 @@ bool general_erase_range_test(Container& x, std::size_t start, std::size_t end)
     return compare(l, x);
 }
 
-template <class Container>
-void erase_subrange_tests(Container const& x)
+template <class Container> void erase_subrange_tests(Container const& x)
 {
-    for(std::size_t length = 0; length < x.size(); ++length) {
-        for(std::size_t position = 0; position < x.size() - length; ++position)
-        {
+    for (std::size_t length = 0; length < x.size(); ++length) {
+        for (std::size_t position = 0; position < x.size() - length;
+             ++position) {
             Container y(x);
             collide_list init(y.begin(), y.end());
-            if(!general_erase_range_test(y, position, position + length)) {
+            if (!general_erase_range_test(y, position, position + length)) {
                 BOOST_ERROR("general_erase_range_test failed.");
-                std::cout<<"Erase: ["<<position<<","<<position + length<<")\n";
+                std::cout << "Erase: [" << position << "," << position + length
+                          << ")\n";
                 write_container(init);
                 write_container(y);
             }
@@ -177,47 +179,46 @@ void x_by_y_erase_range_tests(Container*, int values, int duplicates)
 {
     Container y;
 
-    for(int i = 0; i < values; ++i) {
-        for(int j = 0; j < duplicates; ++j) {
+    for (int i = 0; i < values; ++i) {
+        for (int j = 0; j < duplicates; ++j) {
             y.insert(collide_value(i, j));
         }
     }
 
-    std::cout<<"Values: "<<values<<", Duplicates: "<<duplicates<<"\n";
+    std::cout << "Values: " << values << ", Duplicates: " << duplicates << "\n";
     erase_subrange_tests(y);
 }
 
 template <class Container>
-void exhaustive_erase_tests(Container* x, int num_values,
-        int num_duplicated)
+void exhaustive_erase_tests(Container* x, int num_values, int num_duplicated)
 {
-    for(int i = 0; i < num_values; ++i) {
-        for(int j = 0; j < num_duplicated; ++j) {
+    for (int i = 0; i < num_values; ++i) {
+        for (int j = 0; j < num_duplicated; ++j) {
             x_by_y_erase_range_tests(x, i, j);
         }
     }
 }
 
-UNORDERED_AUTO_TEST(exhaustive_collide_tests) 
+UNORDERED_AUTO_TEST(exhaustive_collide_tests)
 {
-    std::cout<<"exhaustive_collide_tests:\n";
+    std::cout << "exhaustive_collide_tests:\n";
     collide_map m;
-    exhaustive_erase_tests((collide_map*) 0, 4, 4);
-    std::cout<<"\n";
+    exhaustive_erase_tests((collide_map*)0, 4, 4);
+    std::cout << "\n";
 }
 
 UNORDERED_AUTO_TEST(exhaustive_collide2_tests)
 {
-    std::cout<<"exhaustive_collide2_tests:\n";
-    exhaustive_erase_tests((collide_map2*) 0, 8, 4);
-    std::cout<<"\n";
+    std::cout << "exhaustive_collide2_tests:\n";
+    exhaustive_erase_tests((collide_map2*)0, 8, 4);
+    std::cout << "\n";
 }
 
 UNORDERED_AUTO_TEST(exhaustive_collide3_tests)
 {
-    std::cout<<"exhaustive_collide3_tests:\n";
-    exhaustive_erase_tests((collide_map3*) 0, 8, 4);
-    std::cout<<"\n";
+    std::cout << "exhaustive_collide3_tests:\n";
+    exhaustive_erase_tests((collide_map3*)0, 8, 4);
+    std::cout << "\n";
 }
 
 RUN_TESTS()
diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp
index 7e6a98ed..c763c66f 100644
--- a/test/unordered/erase_tests.cpp
+++ b/test/unordered/erase_tests.cpp
@@ -21,8 +21,7 @@
 #include <iostream>
 #include <cstdlib>
 
-namespace erase_tests
-{
+namespace erase_tests {
 
 test::seed_t initialize_seed(85638);
 
@@ -32,27 +31,28 @@ void erase_tests1(Container*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
 
-    std::cerr<<"Erase by key.\n";
+    std::cerr << "Erase by key.\n";
     {
         test::check_instances check_;
 
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         int iterations = 0;
-        for(BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator
-            it = v.begin(); it != v.end(); ++it)
-        {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator
+                 it = v.begin();
+             it != v.end(); ++it) {
             std::size_t count = x.count(test::get_key<Container>(*it));
             std::size_t old_size = x.size();
             BOOST_TEST(count == x.erase(test::get_key<Container>(*it)));
             BOOST_TEST(x.size() == old_size - count);
             BOOST_TEST(x.count(test::get_key<Container>(*it)) == 0);
             BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
+            if (++iterations % 20 == 0)
+                test::check_equivalent_keys(x);
         }
     }
 
-    std::cerr<<"erase(begin()).\n";
+    std::cerr << "erase(begin()).\n";
     {
         test::check_instances check_;
 
@@ -60,22 +60,22 @@ void erase_tests1(Container*, test::random_generator generator)
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         int iterations = 0;
-        while(size > 0 && !x.empty())
-        {
-            BOOST_DEDUCED_TYPENAME Container::key_type
-                key = test::get_key<Container>(*x.begin());
+        while (size > 0 && !x.empty()) {
+            BOOST_DEDUCED_TYPENAME Container::key_type key =
+                test::get_key<Container>(*x.begin());
             std::size_t count = x.count(key);
             iterator pos = x.erase(x.begin());
             --size;
             BOOST_TEST(pos == x.begin());
             BOOST_TEST(x.count(key) == count - 1);
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
+            if (++iterations % 20 == 0)
+                test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
-    std::cerr<<"erase(random position).\n";
+    std::cerr << "erase(random position).\n";
     {
         test::check_instances check_;
 
@@ -83,38 +83,37 @@ void erase_tests1(Container*, test::random_generator generator)
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         int iterations = 0;
-        while(size > 0 && !x.empty())
-        {
+        while (size > 0 && !x.empty()) {
             std::size_t index = test::random_value(x.size());
             c_iterator prev, pos, next;
-            if(index == 0) {
+            if (index == 0) {
                 prev = pos = x.begin();
-            }
-            else {
+            } else {
                 prev = test::next(x.begin(), index - 1);
                 pos = test::next(prev);
             }
             next = test::next(pos);
-            BOOST_DEDUCED_TYPENAME Container::key_type
-                key = test::get_key<Container>(*pos);
+            BOOST_DEDUCED_TYPENAME Container::key_type key =
+                test::get_key<Container>(*pos);
             std::size_t count = x.count(key);
             BOOST_TEST(count > 0);
             BOOST_TEST(next == x.erase(pos));
             --size;
-            if(size > 0)
-                BOOST_TEST(index == 0 ? next == x.begin() :
-                        next == test::next(prev));
+            if (size > 0)
+                BOOST_TEST(
+                    index == 0 ? next == x.begin() : next == test::next(prev));
             BOOST_TEST(x.count(key) == count - 1);
             if (x.count(key) != count - 1) {
                 std::cerr << count << " => " << x.count(key) << std::endl;
             }
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
+            if (++iterations % 20 == 0)
+                test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
-    std::cerr<<"erase(ranges).\n";
+    std::cerr << "erase(ranges).\n";
     {
         test::check_instances check_;
 
@@ -141,7 +140,7 @@ void erase_tests1(Container*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"erase(random ranges).\n";
+    std::cerr << "erase(random ranges).\n";
     {
         test::check_instances check_;
         Container x;
@@ -152,23 +151,23 @@ void erase_tests1(Container*, test::random_generator generator)
 
             // Note that erase only invalidates the erased iterators.
             std::vector<c_iterator> iterators;
-            for(c_iterator it = x.cbegin(); it != x.cend(); ++it) {
+            for (c_iterator it = x.cbegin(); it != x.cend(); ++it) {
                 iterators.push_back(it);
             }
             iterators.push_back(x.cend());
 
-            while(iterators.size() > 1) {
+            while (iterators.size() > 1) {
                 std::size_t start = test::random_value(iterators.size());
-                std::size_t length = test::random_value(iterators.size() - start);
+                std::size_t length =
+                    test::random_value(iterators.size() - start);
                 x.erase(iterators[start], iterators[start + length]);
-                iterators.erase(
-                        test::next(iterators.begin(), start),
-                        test::next(iterators.begin(), start + length));
+                iterators.erase(test::next(iterators.begin(), start),
+                    test::next(iterators.begin(), start + length));
 
                 BOOST_TEST(x.size() == iterators.size() - 1);
                 BOOST_DEDUCED_TYPENAME std::vector<c_iterator>::const_iterator
                     i2 = iterators.begin();
-                for(c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) {
+                for (c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) {
                     BOOST_TEST(i1 == *i2);
                     ++i2;
                 }
@@ -180,7 +179,7 @@ void erase_tests1(Container*, test::random_generator generator)
         }
     }
 
-    std::cerr<<"quick_erase(begin()).\n";
+    std::cerr << "quick_erase(begin()).\n";
     {
         test::check_instances check_;
 
@@ -188,21 +187,21 @@ void erase_tests1(Container*, test::random_generator generator)
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         int iterations = 0;
-        while(size > 0 && !x.empty())
-        {
-            BOOST_DEDUCED_TYPENAME Container::key_type
-                key = test::get_key<Container>(*x.begin());
+        while (size > 0 && !x.empty()) {
+            BOOST_DEDUCED_TYPENAME Container::key_type key =
+                test::get_key<Container>(*x.begin());
             std::size_t count = x.count(key);
             x.quick_erase(x.begin());
             --size;
             BOOST_TEST(x.count(key) == count - 1);
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
+            if (++iterations % 20 == 0)
+                test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
-    std::cerr<<"quick_erase(random position).\n";
+    std::cerr << "quick_erase(random position).\n";
     {
         test::check_instances check_;
 
@@ -210,39 +209,37 @@ void erase_tests1(Container*, test::random_generator generator)
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         int iterations = 0;
-        while(size > 0 && !x.empty())
-        {
+        while (size > 0 && !x.empty()) {
             std::size_t index = test::random_value(x.size());
             BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
-            if(index == 0) {
+            if (index == 0) {
                 prev = pos = x.begin();
-            }
-            else {
+            } else {
                 prev = test::next(x.begin(), index - 1);
                 pos = test::next(prev);
             }
             next = test::next(pos);
-            BOOST_DEDUCED_TYPENAME Container::key_type
-                key = test::get_key<Container>(*pos);
+            BOOST_DEDUCED_TYPENAME Container::key_type key =
+                test::get_key<Container>(*pos);
             std::size_t count = x.count(key);
             BOOST_TEST(count > 0);
             x.quick_erase(pos);
             --size;
-            if(size > 0)
-                BOOST_TEST(index == 0 ? next == x.begin() :
-                        next == test::next(prev));
+            if (size > 0)
+                BOOST_TEST(
+                    index == 0 ? next == x.begin() : next == test::next(prev));
             BOOST_TEST(x.count(key) == count - 1);
             if (x.count(key) != count - 1) {
                 std::cerr << count << " => " << x.count(key) << std::endl;
             }
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
+            if (++iterations % 20 == 0)
+                test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
-
-    std::cerr<<"clear().\n";
+    std::cerr << "clear().\n";
     {
         test::check_instances check_;
 
@@ -253,31 +250,25 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.begin() == x.end());
     }
 
-    std::cerr<<"\n";
+    std::cerr << "\n";
 }
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
-UNORDERED_TEST(erase_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
+UNORDERED_TEST(
+    erase_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
+                      (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/find_tests.cpp b/test/unordered/find_tests.cpp
index 38c7c09c..c6ac6742 100644
--- a/test/unordered/find_tests.cpp
+++ b/test/unordered/find_tests.cpp
@@ -16,13 +16,11 @@
 #include "../helpers/tracker.hpp"
 #include "../helpers/helpers.hpp"
 
-namespace find_tests
-{
+namespace find_tests {
 
 test::seed_t initialize_seed(78937);
 
-template <class X>
-void find_tests1(X*, test::random_generator generator)
+template <class X> void find_tests1(X*, test::random_generator generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
@@ -35,37 +33,35 @@ void find_tests1(X*, test::random_generator generator)
         test::ordered<X> tracker = test::create_ordered(x);
         tracker.insert_range(v.begin(), v.end());
 
-        for(BOOST_DEDUCED_TYPENAME test::ordered<X>::const_iterator it1 =
-                tracker.begin(); it1 != tracker.end(); ++it1)
-        {
+        for (BOOST_DEDUCED_TYPENAME test::ordered<X>::const_iterator it1 =
+                 tracker.begin();
+             it1 != tracker.end(); ++it1) {
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
-            BOOST_DEDUCED_TYPENAME X::const_iterator
-                const_pos = x_const.find(key);
+            BOOST_DEDUCED_TYPENAME X::const_iterator const_pos =
+                x_const.find(key);
             iterator pos = x.find(key);
             BOOST_TEST(const_pos != x_const.end());
             BOOST_TEST(const_pos != x_const.end() &&
-                    x_const.key_eq()(key, test::get_key<X>(*const_pos)));
+                       x_const.key_eq()(key, test::get_key<X>(*const_pos)));
             BOOST_TEST(pos != x.end());
-            BOOST_TEST(pos != x.end() &&
-                    x.key_eq()(key, test::get_key<X>(*pos)));
+            BOOST_TEST(
+                pos != x.end() && x.key_eq()(key, test::get_key<X>(*pos)));
 
             BOOST_TEST(x.count(key) == tracker.count(key));
 
-            test::compare_pairs(x.equal_range(key),
-                    tracker.equal_range(key),
-                    (BOOST_DEDUCED_TYPENAME X::value_type*) 0);
+            test::compare_pairs(x.equal_range(key), tracker.equal_range(key),
+                (BOOST_DEDUCED_TYPENAME X::value_type*)0);
             test::compare_pairs(x_const.equal_range(key),
-                    tracker.equal_range(key),
-                    (BOOST_DEDUCED_TYPENAME X::value_type*) 0);
+                tracker.equal_range(key),
+                (BOOST_DEDUCED_TYPENAME X::value_type*)0);
         }
 
         test::random_values<X> v2(500, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it2 =
-                v2.begin(); it2 != v2.end(); ++it2)
-        {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it2 =
+                 v2.begin();
+             it2 != v2.end(); ++it2) {
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
-            if(tracker.find(test::get_key<X>(key)) == tracker.end())
-            {
+            if (tracker.find(test::get_key<X>(key)) == tracker.end()) {
                 BOOST_TEST(x.find(key) == x.end());
                 BOOST_TEST(x_const.find(key) == x_const.end());
                 BOOST_TEST(x.count(key) == 0);
@@ -81,9 +77,9 @@ void find_tests1(X*, test::random_generator generator)
         X x;
 
         test::random_values<X> v2(5, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it3 =
-                v2.begin(); it3 != v2.end(); ++it3)
-        {
+        for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it3 =
+                 v2.begin();
+             it3 != v2.end(); ++it3) {
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3);
             BOOST_TEST(x.find(key) == x.end());
             BOOST_TEST(x.count(key) == 0);
@@ -96,7 +92,7 @@ void find_tests1(X*, test::random_generator generator)
 struct compatible_key
 {
     test::object o_;
-    
+
     compatible_key(test::object const& o) : o_(o) {}
 };
 
@@ -104,7 +100,8 @@ struct compatible_hash
 {
     test::hash hash_;
 
-    std::size_t operator()(compatible_key const& k) const {
+    std::size_t operator()(compatible_key const& k) const
+    {
         return hash_(k.o_);
     }
 };
@@ -113,7 +110,8 @@ struct compatible_predicate
 {
     test::equal_to equal_;
 
-    bool operator()(compatible_key const& k1, compatible_key const& k2) const {
+    bool operator()(compatible_key const& k1, compatible_key const& k2) const
+    {
         return equal_(k1.o_, k2.o_);
     }
 };
@@ -125,49 +123,42 @@ void find_compatible_keys_test(X*, test::random_generator generator)
         value_iterator;
     test::random_values<X> v(500, generator);
     X x(v.begin(), v.end());
-    
+
     compatible_hash h;
     compatible_predicate eq;
-    
-    for(value_iterator it = v.begin(), end = v.end(); it != end; ++it) {
+
+    for (value_iterator it = v.begin(), end = v.end(); it != end; ++it) {
         BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
         BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
     }
 
     test::random_values<X> v2(20, generator);
-    
-    for(value_iterator it = v2.begin(), end = v2.end(); it != end; ++it) {
+
+    for (value_iterator it = v2.begin(), end = v2.end(); it != end; ++it) {
         BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
         BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
     }
 }
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
-UNORDERED_TEST(find_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(
+    find_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
+                     (default_generator)(generate_collisions)(limited_range)))
 UNORDERED_TEST(find_compatible_keys_test,
-    ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
+    ((test_set)(test_multiset)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/fwd_map_test.cpp b/test/unordered/fwd_map_test.cpp
index 1e656331..6f4179d9 100644
--- a/test/unordered/fwd_map_test.cpp
+++ b/test/unordered/fwd_map_test.cpp
@@ -10,43 +10,41 @@
 // clang-format on
 
 template <typename T>
-void call_swap(boost::unordered_map<T,T>& x,
-    boost::unordered_map<T,T>& y)
+void call_swap(boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
 {
-    swap(x,y);
+    swap(x, y);
 }
 
 template <typename T>
-bool call_equals(boost::unordered_map<T,T>& x,
-    boost::unordered_map<T,T>& y)
+bool call_equals(boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
 {
     return x == y;
 }
 
 template <typename T>
-bool call_not_equals(boost::unordered_map<T,T>& x,
-    boost::unordered_map<T,T>& y)
+bool call_not_equals(
+    boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
 {
     return x != y;
 }
 
 template <typename T>
-void call_swap(boost::unordered_multimap<T,T>& x,
-    boost::unordered_multimap<T,T>& y)
+void call_swap(
+    boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
 {
-    swap(x,y);
+    swap(x, y);
 }
 
 template <typename T>
-bool call_equals(boost::unordered_multimap<T,T>& x,
-    boost::unordered_multimap<T,T>& y)
+bool call_equals(
+    boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
 {
     return x == y;
 }
 
 template <typename T>
-bool call_not_equals(boost::unordered_multimap<T,T>& x,
-    boost::unordered_multimap<T,T>& y)
+bool call_not_equals(
+    boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
 {
     return x != y;
 }
@@ -57,7 +55,8 @@ bool call_not_equals(boost::unordered_multimap<T,T>& x,
 typedef boost::unordered_map<int, int> int_map;
 typedef boost::unordered_multimap<int, int> int_multimap;
 
-UNORDERED_AUTO_TEST(use_map_fwd_declared_function) {
+UNORDERED_AUTO_TEST(use_map_fwd_declared_function)
+{
     int_map x, y;
     x[1] = 2;
     y[2] = 1;
@@ -73,7 +72,8 @@ UNORDERED_AUTO_TEST(use_map_fwd_declared_function) {
     BOOST_TEST(call_not_equals(x, y));
 }
 
-UNORDERED_AUTO_TEST(use_multimap_fwd_declared_function) {
+UNORDERED_AUTO_TEST(use_multimap_fwd_declared_function)
+{
     int_multimap x, y;
     call_swap(x, y);
     BOOST_TEST(call_equals(x, y));
diff --git a/test/unordered/fwd_set_test.cpp b/test/unordered/fwd_set_test.cpp
index 44cd1436..9c5b3bbf 100644
--- a/test/unordered/fwd_set_test.cpp
+++ b/test/unordered/fwd_set_test.cpp
@@ -9,53 +9,55 @@
 #include "../helpers/postfix.hpp"
 // clang-format on
 
-struct true_type { char x[100]; };
-struct false_type { char x; };
+struct true_type
+{
+    char x[100];
+};
+struct false_type
+{
+    char x;
+};
 
 false_type is_unordered_set_impl(void*);
 
 template <class Value, class Hash, class Pred, class Alloc>
 true_type is_unordered_set_impl(
-        boost::unordered_set<Value, Hash, Pred, Alloc>*);
+    boost::unordered_set<Value, Hash, Pred, Alloc>*);
 
-template<typename T>
-void call_swap(boost::unordered_set<T>& x,
-    boost::unordered_set<T>& y)
+template <typename T>
+void call_swap(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
 {
-    swap(x,y);
+    swap(x, y);
 }
 
-template<typename T>
-bool call_equals(boost::unordered_set<T>& x,
-    boost::unordered_set<T>& y)
+template <typename T>
+bool call_equals(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
 {
     return x == y;
 }
 
-template<typename T>
-bool call_not_equals(boost::unordered_set<T>& x,
-    boost::unordered_set<T>& y)
+template <typename T>
+bool call_not_equals(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
 {
     return x != y;
 }
 
-template<typename T>
-void call_swap(boost::unordered_multiset<T>& x,
-    boost::unordered_multiset<T>& y)
+template <typename T>
+void call_swap(boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
 {
-    swap(x,y);
+    swap(x, y);
 }
 
-template<typename T>
-bool call_equals(boost::unordered_multiset<T>& x,
-    boost::unordered_multiset<T>& y)
+template <typename T>
+bool call_equals(
+    boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
 {
     return x == y;
 }
 
-template<typename T>
-bool call_not_equals(boost::unordered_multiset<T>& x,
-    boost::unordered_multiset<T>& y)
+template <typename T>
+bool call_not_equals(
+    boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
 {
     return x != y;
 }
@@ -65,21 +67,23 @@ bool call_not_equals(boost::unordered_multiset<T>& x,
 typedef boost::unordered_set<int> int_set;
 typedef boost::unordered_multiset<int> int_multiset;
 
-UNORDERED_AUTO_TEST(use_fwd_declared_trait_without_definition) {
-    BOOST_TEST(sizeof(is_unordered_set_impl((int_set*) 0))
-        == sizeof(true_type));
+UNORDERED_AUTO_TEST(use_fwd_declared_trait_without_definition)
+{
+    BOOST_TEST(sizeof(is_unordered_set_impl((int_set*)0)) == sizeof(true_type));
 }
 
 #include <boost/unordered_set.hpp>
 
-UNORDERED_AUTO_TEST(use_fwd_declared_trait) {
+UNORDERED_AUTO_TEST(use_fwd_declared_trait)
+{
     boost::unordered_set<int> x;
     BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
 
-    BOOST_TEST(sizeof(is_unordered_set_impl((int*) 0)) == sizeof(false_type));
+    BOOST_TEST(sizeof(is_unordered_set_impl((int*)0)) == sizeof(false_type));
 }
 
-UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
+UNORDERED_AUTO_TEST(use_set_fwd_declared_function)
+{
     int_set x, y;
     x.insert(1);
     y.insert(2);
@@ -95,7 +99,8 @@ UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
     BOOST_TEST(call_not_equals(x, y));
 }
 
-UNORDERED_AUTO_TEST(use_multiset_fwd_declared_function) {
+UNORDERED_AUTO_TEST(use_multiset_fwd_declared_function)
+{
     int_multiset x, y;
     call_swap(x, y);
     BOOST_TEST(call_equals(x, y));
diff --git a/test/unordered/incomplete_test.cpp b/test/unordered/incomplete_test.cpp
index 8c3d2a53..8848fe80 100644
--- a/test/unordered/incomplete_test.cpp
+++ b/test/unordered/incomplete_test.cpp
@@ -12,142 +12,155 @@
 
 #include <utility>
 
-namespace x
+namespace x {
+struct D
 {
-    struct D { boost::unordered_map<D, D> x; };
+    boost::unordered_map<D, D> x;
+};
 }
 
-namespace incomplete_test
+namespace incomplete_test {
+// Declare, but don't define some types.
+
+struct value;
+struct hash;
+struct equals;
+template <class T> struct allocator;
+
+// Declare some instances
+
+typedef boost::unordered_map<value, value, hash, equals,
+    allocator<std::pair<value const, value> > >
+    map;
+typedef boost::unordered_multimap<value, value, hash, equals,
+    allocator<std::pair<value const, value> > >
+    multimap;
+typedef boost::unordered_set<value, hash, equals, allocator<value> > set;
+typedef boost::unordered_multiset<value, hash, equals, allocator<value> >
+    multiset;
+
+// Now define the types which are stored as members, as they are needed for
+// declaring struct members.
+
+struct hash
 {
-    // Declare, but don't define some types.
+    template <typename T> std::size_t operator()(T const&) const { return 0; }
+};
 
-    struct value;
-    struct hash;
-    struct equals;
-    template <class T> struct allocator;
-
-    // Declare some instances
-    
-    typedef boost::unordered_map<value, value, hash, equals,
-        allocator<std::pair<value const, value> > > map;
-    typedef boost::unordered_multimap<value, value, hash, equals,
-        allocator<std::pair<value const, value> > > multimap;
-    typedef boost::unordered_set<value, hash, equals,
-        allocator<value> > set;
-    typedef boost::unordered_multiset<value, hash, equals,
-        allocator<value> > multiset;
-    
-    // Now define the types which are stored as members, as they are needed for
-    // declaring struct members.
-
-    struct hash { 
-        template <typename T>
-        std::size_t operator()(T const&) const { return 0; }
-    };
-
-    struct equals {
-        template <typename T>
-        bool operator()(T const&, T const&) const { return true; }
-    };
-
-    // This is a dubious way to implement an allocator, but good enough
-    // for this test.
-    template <typename T>
-    struct allocator : std::allocator<T> {
-        allocator() {}
-
-        template <typename T2>
-        allocator(const allocator<T2>& other) :
-            std::allocator<T>(other) {}
-    };
-
-    // Declare some members of a structs.
-    //
-    // Incomplete hash, equals and allocator aren't here supported at the
-    // moment.
-    
-    struct struct1 {
-        boost::unordered_map<struct1, struct1, hash, equals,
-            allocator<std::pair<struct1 const, struct1> > > x;
-    };
-    struct struct2 {
-        boost::unordered_multimap<struct2, struct2, hash, equals,
-            allocator<std::pair<struct2 const, struct2> > > x;
-    };
-    struct struct3 {
-        boost::unordered_set<struct3, hash, equals,
-            allocator<struct3> > x;
-    };
-    struct struct4 {
-        boost::unordered_multiset<struct4, hash, equals,
-            allocator<struct4> > x;
-    };
-    
-    // Now define the value type.
-
-    struct value {};
-
-    // Create some instances.
-    
-    incomplete_test::map m1;
-    incomplete_test::multimap m2;
-    incomplete_test::set s1;
-    incomplete_test::multiset s2;
-
-    incomplete_test::struct1 c1;
-    incomplete_test::struct2 c2;
-    incomplete_test::struct3 c3;
-    incomplete_test::struct4 c4;
-
-    // Now declare, but don't define, the operators required for comparing
-    // elements.
-
-    std::size_t hash_value(value const&);
-    bool operator==(value const&, value const&);
-
-    std::size_t hash_value(struct1 const&);
-    std::size_t hash_value(struct2 const&);
-    std::size_t hash_value(struct3 const&);
-    std::size_t hash_value(struct4 const&);
-    
-    bool operator==(struct1 const&, struct1 const&);
-    bool operator==(struct2 const&, struct2 const&);
-    bool operator==(struct3 const&, struct3 const&);
-    bool operator==(struct4 const&, struct4 const&);
-    
-    // And finally use these
-    
-    void use_types()
+struct equals
+{
+    template <typename T> bool operator()(T const&, T const&) const
     {
-        incomplete_test::value x;
-        m1[x] = x;
-        m2.insert(std::make_pair(x, x));
-        s1.insert(x);
-        s2.insert(x);
-
-        c1.x.insert(std::make_pair(c1, c1));
-        c2.x.insert(std::make_pair(c2, c2));
-        c3.x.insert(c3);
-        c4.x.insert(c4);
+        return true;
     }
+};
 
-    // And finally define the operators required for comparing elements.
+// This is a dubious way to implement an allocator, but good enough
+// for this test.
+template <typename T> struct allocator : std::allocator<T>
+{
+    allocator() {}
 
-    std::size_t hash_value(value const&) { return 0; }
-    bool operator==(value const&, value const&) { return true; }
+    template <typename T2>
+    allocator(const allocator<T2>& other) : std::allocator<T>(other)
+    {
+    }
+};
 
-    std::size_t hash_value(struct1 const&) { return 0; }
-    std::size_t hash_value(struct2 const&) { return 0; }
-    std::size_t hash_value(struct3 const&) { return 0; }
-    std::size_t hash_value(struct4 const&) { return 0; }
-    
-    bool operator==(struct1 const&, struct1 const&) { return true; }
-    bool operator==(struct2 const&, struct2 const&) { return true; }
-    bool operator==(struct3 const&, struct3 const&) { return true; }
-    bool operator==(struct4 const&, struct4 const&) { return true; }
+// Declare some members of a structs.
+//
+// Incomplete hash, equals and allocator aren't here supported at the
+// moment.
+
+struct struct1
+{
+    boost::unordered_map<struct1, struct1, hash, equals,
+        allocator<std::pair<struct1 const, struct1> > >
+        x;
+};
+struct struct2
+{
+    boost::unordered_multimap<struct2, struct2, hash, equals,
+        allocator<std::pair<struct2 const, struct2> > >
+        x;
+};
+struct struct3
+{
+    boost::unordered_set<struct3, hash, equals, allocator<struct3> > x;
+};
+struct struct4
+{
+    boost::unordered_multiset<struct4, hash, equals, allocator<struct4> > x;
+};
+
+// Now define the value type.
+
+struct value
+{
+};
+
+// Create some instances.
+
+incomplete_test::map m1;
+incomplete_test::multimap m2;
+incomplete_test::set s1;
+incomplete_test::multiset s2;
+
+incomplete_test::struct1 c1;
+incomplete_test::struct2 c2;
+incomplete_test::struct3 c3;
+incomplete_test::struct4 c4;
+
+// Now declare, but don't define, the operators required for comparing
+// elements.
+
+std::size_t hash_value(value const&);
+bool operator==(value const&, value const&);
+
+std::size_t hash_value(struct1 const&);
+std::size_t hash_value(struct2 const&);
+std::size_t hash_value(struct3 const&);
+std::size_t hash_value(struct4 const&);
+
+bool operator==(struct1 const&, struct1 const&);
+bool operator==(struct2 const&, struct2 const&);
+bool operator==(struct3 const&, struct3 const&);
+bool operator==(struct4 const&, struct4 const&);
+
+// And finally use these
+
+void use_types()
+{
+    incomplete_test::value x;
+    m1[x] = x;
+    m2.insert(std::make_pair(x, x));
+    s1.insert(x);
+    s2.insert(x);
+
+    c1.x.insert(std::make_pair(c1, c1));
+    c2.x.insert(std::make_pair(c2, c2));
+    c3.x.insert(c3);
+    c4.x.insert(c4);
 }
 
-int main() {
+// And finally define the operators required for comparing elements.
+
+std::size_t hash_value(value const&) { return 0; }
+bool operator==(value const&, value const&) { return true; }
+
+std::size_t hash_value(struct1 const&) { return 0; }
+std::size_t hash_value(struct2 const&) { return 0; }
+std::size_t hash_value(struct3 const&) { return 0; }
+std::size_t hash_value(struct4 const&) { return 0; }
+
+bool operator==(struct1 const&, struct1 const&) { return true; }
+bool operator==(struct2 const&, struct2 const&) { return true; }
+bool operator==(struct3 const&, struct3 const&) { return true; }
+bool operator==(struct4 const&, struct4 const&) { return true; }
+}
+
+int main()
+{
     // This could just be a compile test, but I like to be able to run these
     // things. It's probably irrational, but I find it reassuring.
 
diff --git a/test/unordered/insert_hint_tests.cpp b/test/unordered/insert_hint_tests.cpp
index 90289f75..ea9c9b8e 100644
--- a/test/unordered/insert_hint_tests.cpp
+++ b/test/unordered/insert_hint_tests.cpp
@@ -17,9 +17,9 @@
 #include <set>
 #include <iostream>
 
-namespace insert_hint
+namespace insert_hint {
+UNORDERED_AUTO_TEST(insert_hint_empty)
 {
-UNORDERED_AUTO_TEST(insert_hint_empty) {
     typedef boost::unordered_multiset<int> container;
     container x;
     x.insert(x.cbegin(), 10);
@@ -28,7 +28,8 @@ UNORDERED_AUTO_TEST(insert_hint_empty) {
     test::check_equivalent_keys(x);
 }
 
-UNORDERED_AUTO_TEST(insert_hint_empty2) {
+UNORDERED_AUTO_TEST(insert_hint_empty2)
+{
     typedef boost::unordered_multimap<std::string, int> container;
     container x;
     x.emplace_hint(x.cbegin(), "hello", 50);
@@ -38,7 +39,8 @@ UNORDERED_AUTO_TEST(insert_hint_empty2) {
     test::check_equivalent_keys(x);
 }
 
-UNORDERED_AUTO_TEST(insert_hint_single) {
+UNORDERED_AUTO_TEST(insert_hint_single)
+{
     typedef boost::unordered_multiset<std::string> container;
     container x;
     x.insert("equal");
@@ -48,7 +50,8 @@ UNORDERED_AUTO_TEST(insert_hint_single) {
     test::check_equivalent_keys(x);
 }
 
-UNORDERED_AUTO_TEST(insert_hint_single2) {
+UNORDERED_AUTO_TEST(insert_hint_single2)
+{
     typedef boost::unordered_multimap<int, std::string> container;
     container x;
     x.emplace(10, "one");
@@ -67,18 +70,23 @@ UNORDERED_AUTO_TEST(insert_hint_single2) {
     test::check_equivalent_keys(x);
 }
 
-UNORDERED_AUTO_TEST(insert_hint_multiple) {
+UNORDERED_AUTO_TEST(insert_hint_multiple)
+{
     for (unsigned int size = 0; size < 10; ++size) {
-        for (unsigned int offset = 0; offset <= size;  ++offset) {
+        for (unsigned int offset = 0; offset <= size; ++offset) {
             typedef boost::unordered_multiset<std::string> container;
             container x;
 
-            for (unsigned int i = 0; i < size; ++i) { x.insert("multiple"); }
+            for (unsigned int i = 0; i < size; ++i) {
+                x.insert("multiple");
+            }
 
             BOOST_TEST_EQ(x.size(), size);
 
             container::const_iterator position = x.cbegin();
-            for (unsigned int i = 0; i < offset; ++i) { ++position; }
+            for (unsigned int i = 0; i < offset; ++i) {
+                ++position;
+            }
 
             x.insert(position, "multiple");
 
@@ -89,7 +97,8 @@ UNORDERED_AUTO_TEST(insert_hint_multiple) {
     }
 }
 
-UNORDERED_AUTO_TEST(insert_hint_unique) {
+UNORDERED_AUTO_TEST(insert_hint_unique)
+{
     typedef boost::unordered_set<int> container;
     container x;
     x.insert(x.cbegin(), 10);
@@ -98,7 +107,8 @@ UNORDERED_AUTO_TEST(insert_hint_unique) {
     test::check_equivalent_keys(x);
 }
 
-UNORDERED_AUTO_TEST(insert_hint_unique_single) {
+UNORDERED_AUTO_TEST(insert_hint_unique_single)
+{
     typedef boost::unordered_set<int> container;
     container x;
     x.insert(10);
@@ -114,7 +124,6 @@ UNORDERED_AUTO_TEST(insert_hint_unique_single) {
     BOOST_TEST_EQ(x.count(20), 1u);
     test::check_equivalent_keys(x);
 }
-
 }
 
 RUN_TESTS()
diff --git a/test/unordered/insert_stable_tests.cpp b/test/unordered/insert_stable_tests.cpp
index 5a22e267..477c0ef3 100644
--- a/test/unordered/insert_stable_tests.cpp
+++ b/test/unordered/insert_stable_tests.cpp
@@ -14,23 +14,25 @@
 
 #include <iostream>
 
-namespace insert_stable
+namespace insert_stable {
+struct member
 {
-    struct member {
-        int tag1_;
-        int tag2_;
-    
-        member() : tag1_(0), tag2_(0) {}
-        member(int t1, int t2) : tag1_(t1), tag2_(t2) {}
-    
-        friend bool operator==(member const& x, member const& y) {
-            return x.tag1_ == y.tag1_;
-        }
-    
-        friend bool operator!=(member const& x, member const& y) {
-            return x.tag1_ != y.tag1_;
-        }
-    };
+    int tag1_;
+    int tag2_;
+
+    member() : tag1_(0), tag2_(0) {}
+    member(int t1, int t2) : tag1_(t1), tag2_(t2) {}
+
+    friend bool operator==(member const& x, member const& y)
+    {
+        return x.tag1_ == y.tag1_;
+    }
+
+    friend bool operator!=(member const& x, member const& y)
+    {
+        return x.tag1_ != y.tag1_;
+    }
+};
 }
 
 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
@@ -39,51 +41,72 @@ namespace boost
 namespace insert_stable
 #endif
 {
-    std::size_t hash_value(insert_stable::member const& x) {
-        return static_cast<std::size_t>(x.tag1_);
-    }
+std::size_t hash_value(insert_stable::member const& x)
+{
+    return static_cast<std::size_t>(x.tag1_);
+}
 }
 
-UNORDERED_AUTO_TEST(stable_insert_test1) {
+UNORDERED_AUTO_TEST(stable_insert_test1)
+{
     boost::unordered_multiset<insert_stable::member> x;
 
-    x.insert(insert_stable::member(1,1));
-    x.insert(insert_stable::member(1,2));
-    x.insert(insert_stable::member(1,3));
+    x.insert(insert_stable::member(1, 1));
+    x.insert(insert_stable::member(1, 2));
+    x.insert(insert_stable::member(1, 3));
 
-    BOOST_TEST(x.count(insert_stable::member(1,4)) == 3);
+    BOOST_TEST(x.count(insert_stable::member(1, 4)) == 3);
 
     boost::unordered_multiset<insert_stable::member>::const_iterator
-        it = x.begin(), end = x.end();
+        it = x.begin(),
+        end = x.end();
     BOOST_TEST(it != end);
-    if(it != end) { BOOST_TEST(it->tag2_ == 1); ++it; }
+    if (it != end) {
+        BOOST_TEST(it->tag2_ == 1);
+        ++it;
+    }
     BOOST_TEST(it != end);
-    if(it != end) { BOOST_TEST(it->tag2_ == 2); ++it; }
+    if (it != end) {
+        BOOST_TEST(it->tag2_ == 2);
+        ++it;
+    }
     BOOST_TEST(it != end);
-    if(it != end) { BOOST_TEST(it->tag2_ == 3); ++it; }
+    if (it != end) {
+        BOOST_TEST(it->tag2_ == 3);
+        ++it;
+    }
     BOOST_TEST(it == end);
 }
 
-UNORDERED_AUTO_TEST(stable_insert_test2) {
+UNORDERED_AUTO_TEST(stable_insert_test2)
+{
     boost::unordered_multimap<insert_stable::member, int> x;
-    typedef
-        boost::unordered_multimap<insert_stable::member, int>::const_iterator
-        iterator;
+    typedef boost::unordered_multimap<insert_stable::member,
+        int>::const_iterator iterator;
 
-    iterator it = x.emplace(insert_stable::member(1,1), 1);
-    it = x.emplace(insert_stable::member(1,2), 2);
-    it = x.emplace(insert_stable::member(1,3), 3);
+    iterator it = x.emplace(insert_stable::member(1, 1), 1);
+    it = x.emplace(insert_stable::member(1, 2), 2);
+    it = x.emplace(insert_stable::member(1, 3), 3);
 
-    BOOST_TEST(x.count(insert_stable::member(1,4)) == 3);
+    BOOST_TEST(x.count(insert_stable::member(1, 4)) == 3);
 
     it = x.begin();
     iterator end = x.end();
     BOOST_TEST(it != end);
-    if(it != end) { BOOST_TEST(it->first.tag2_ == 1 && it->second == 1); ++it; }
+    if (it != end) {
+        BOOST_TEST(it->first.tag2_ == 1 && it->second == 1);
+        ++it;
+    }
     BOOST_TEST(it != end);
-    if(it != end) { BOOST_TEST(it->first.tag2_ == 2 && it->second == 2); ++it; }
+    if (it != end) {
+        BOOST_TEST(it->first.tag2_ == 2 && it->second == 2);
+        ++it;
+    }
     BOOST_TEST(it != end);
-    if(it != end) { BOOST_TEST(it->first.tag2_ == 3 && it->second == 3); ++it; }
+    if (it != end) {
+        BOOST_TEST(it->first.tag2_ == 3 && it->second == 3);
+        ++it;
+    }
     BOOST_TEST(it == end);
 }
 
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index 73c44873..1f477ade 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -22,7 +22,7 @@
 #include <iostream>
 
 namespace insert_tests {
-    
+
 test::seed_t initialize_seed(243432);
 
 template <class X>
@@ -33,30 +33,30 @@ void unique_insert_tests1(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
-    std::cerr<<"insert(value) tests for containers with unique keys.\n";
+    std::cerr << "insert(value) tests for containers with unique keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
     test::random_values<X> v(1000, generator);
 
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
 
         BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
         float b = x.max_load_factor();
 
         std::pair<iterator, bool> r1 = x.insert(*it);
-        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool>
-            r2 = tracker.insert(*it);
+        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 =
+            tracker.insert(*it);
 
         BOOST_TEST(r1.second == r2.second);
         BOOST_TEST(*r1.first == *r2.first);
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -66,45 +66,43 @@ void unique_insert_tests1(X*, test::random_generator generator)
 template <class X>
 void equivalent_insert_tests1(X*, test::random_generator generator)
 {
-    std::cerr<<"insert(value) tests for containers with equivalent keys.\n";
+    std::cerr << "insert(value) tests for containers with equivalent keys.\n";
 
     test::check_instances check_;
 
-
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
     test::random_values<X> v(1000, generator);
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
         BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
         float b = x.max_load_factor();
 
         BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it);
-        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2
-            = tracker.insert(*it);
+        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 =
+            tracker.insert(*it);
 
         BOOST_TEST(*r1 == *r2);
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
 }
 
-template <class X>
-void insert_tests2(X*, test::random_generator generator)
+template <class X> void insert_tests2(X*, test::random_generator generator)
 {
     typedef BOOST_DEDUCED_TYPENAME test::ordered<X> tracker_type;
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
     typedef BOOST_DEDUCED_TYPENAME tracker_type::iterator tracker_iterator;
 
-    std::cerr<<"insert(begin(), value) tests.\n";
+    std::cerr << "insert(begin(), value) tests.\n";
 
     {
         test::check_instances check_;
@@ -113,11 +111,11 @@ void insert_tests2(X*, test::random_generator generator)
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(1000, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-            it = v.begin(); it != v.end(); ++it)
-        {
-            BOOST_DEDUCED_TYPENAME X::size_type
-                old_bucket_count = x.bucket_count();
+        for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
+                 v.begin();
+             it != v.end(); ++it) {
+            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+                x.bucket_count();
             float b = x.max_load_factor();
 
             iterator r1 = x.insert(x.begin(), *it);
@@ -125,7 +123,8 @@ void insert_tests2(X*, test::random_generator generator)
             BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if (static_cast<double>(x.size()) <=
+                b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -133,7 +132,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert(end(), value) tests.\n";
+    std::cerr << "insert(end(), value) tests.\n";
 
     {
         test::check_instances check_;
@@ -143,11 +142,11 @@ void insert_tests2(X*, test::random_generator generator)
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(100, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-            it = v.begin(); it != v.end(); ++it)
-        {
-            BOOST_DEDUCED_TYPENAME X::size_type
-                old_bucket_count = x.bucket_count();
+        for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
+                 v.begin();
+             it != v.end(); ++it) {
+            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+                x.bucket_count();
             float b = x.max_load_factor();
 
             const_iterator r1 = x.insert(x_const.end(), *it);
@@ -155,7 +154,8 @@ void insert_tests2(X*, test::random_generator generator)
             BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if (static_cast<double>(x.size()) <=
+                b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -163,7 +163,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert(pos, value) tests.\n";
+    std::cerr << "insert(pos, value) tests.\n";
 
     {
         test::check_instances check_;
@@ -173,11 +173,11 @@ void insert_tests2(X*, test::random_generator generator)
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(1000, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-            it = v.begin(); it != v.end(); ++it)
-        {
-            BOOST_DEDUCED_TYPENAME X::size_type
-                old_bucket_count = x.bucket_count();
+        for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
+                 v.begin();
+             it != v.end(); ++it) {
+            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+                x.bucket_count();
             float b = x.max_load_factor();
 
             pos = x.insert(pos, *it);
@@ -185,7 +185,8 @@ void insert_tests2(X*, test::random_generator generator)
             BOOST_TEST(*pos == *r2);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if (static_cast<double>(x.size()) <=
+                b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -193,7 +194,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert single item range tests.\n";
+    std::cerr << "insert single item range tests.\n";
 
     {
         test::check_instances check_;
@@ -202,18 +203,19 @@ void insert_tests2(X*, test::random_generator generator)
         tracker_type tracker = test::create_ordered(x);
 
         test::random_values<X> v(1000, generator);
-        for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-            it = v.begin(); it != v.end(); ++it)
-        {
-            BOOST_DEDUCED_TYPENAME X::size_type
-                old_bucket_count = x.bucket_count();
+        for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
+                 v.begin();
+             it != v.end(); ++it) {
+            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+                x.bucket_count();
             float b = x.max_load_factor();
 
             x.insert(it, test::next(it));
             tracker.insert(*it);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if (static_cast<double>(x.size()) <=
+                b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
@@ -221,7 +223,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert range tests.\n";
+    std::cerr << "insert range tests.\n";
 
     {
         test::check_instances check_;
@@ -235,7 +237,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert range with rehash tests.\n";
+    std::cerr << "insert range with rehash tests.\n";
 
     {
         test::check_instances check_;
@@ -253,7 +255,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert input iterator range tests.\n";
+    std::cerr << "insert input iterator range tests.\n";
 
     {
         test::check_instances check_;
@@ -262,14 +264,15 @@ void insert_tests2(X*, test::random_generator generator)
 
         test::random_values<X> v(1000, generator);
         BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
-            begin = v.begin(), end = v.end();
+            begin = v.begin(),
+            end = v.end();
         x.insert(test::input_iterator(begin), test::input_iterator(end));
         test::check_container(x, v);
 
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert copy iterator range tests.\n";
+    std::cerr << "insert copy iterator range tests.\n";
 
     {
         test::check_instances check_;
@@ -283,7 +286,7 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert copy iterator range test 2.\n";
+    std::cerr << "insert copy iterator range test 2.\n";
 
     {
         test::check_instances check_;
@@ -292,13 +295,15 @@ void insert_tests2(X*, test::random_generator generator)
 
         test::random_values<X> v1(500, generator);
         test::random_values<X> v2(500, generator);
-        x.insert(test::copy_iterator(v1.begin()), test::copy_iterator(v1.end()));
-        x.insert(test::copy_iterator(v2.begin()), test::copy_iterator(v2.end()));
+        x.insert(
+            test::copy_iterator(v1.begin()), test::copy_iterator(v1.end()));
+        x.insert(
+            test::copy_iterator(v2.begin()), test::copy_iterator(v2.end()));
 
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert various ranges.\n";
+    std::cerr << "insert various ranges.\n";
 
     {
         for (int i = 0; i < 100; ++i) {
@@ -307,17 +312,20 @@ void insert_tests2(X*, test::random_generator generator)
 
             test::random_values<X> v(1000, generator);
 
-            for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-                    it = v.begin(); it != v.end();)
-            {
-                BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+            for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
+                     v.begin();
+                 it != v.end();) {
+                BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+                    x.bucket_count();
                 float b = x.max_load_factor();
 
-                BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-                    next = it;
+                BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator next =
+                    it;
                 for (std::size_t j = test::random_value(20); j > 0; ++j) {
                     ++next;
-                    if (next == v.end()) { break; }
+                    if (next == v.end()) {
+                        break;
+                    }
                 }
 
                 x.insert(it, next);
@@ -326,7 +334,8 @@ void insert_tests2(X*, test::random_generator generator)
 
                 tracker.compare(x); // Slow, but I can't see any other way.
 
-                if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+                if (static_cast<double>(x.size()) <=
+                    b * static_cast<double>(old_bucket_count))
                     BOOST_TEST(x.bucket_count() == old_bucket_count);
             }
 
@@ -341,30 +350,30 @@ void unique_emplace_tests1(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
-    std::cerr<<"emplace(value) tests for containers with unique keys.\n";
+    std::cerr << "emplace(value) tests for containers with unique keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
     test::random_values<X> v(1000, generator);
 
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
 
         BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
         float b = x.max_load_factor();
 
         std::pair<iterator, bool> r1 = x.emplace(*it);
-        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool>
-            r2 = tracker.insert(*it);
+        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 =
+            tracker.insert(*it);
 
         BOOST_TEST(r1.second == r2.second);
         BOOST_TEST(*r1.first == *r2.first);
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -375,27 +384,27 @@ void unique_emplace_tests1(X*, test::random_generator generator)
 template <class X>
 void equivalent_emplace_tests1(X*, test::random_generator generator)
 {
-    std::cerr<<"emplace(value) tests for containers with equivalent keys.\n";
+    std::cerr << "emplace(value) tests for containers with equivalent keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
     test::random_values<X> v(1000, generator);
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
         BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
         float b = x.max_load_factor();
 
         BOOST_DEDUCED_TYPENAME X::iterator r1 = x.emplace(*it);
-        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator
-            r2 = tracker.insert(*it);
+        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 =
+            tracker.insert(*it);
 
         BOOST_TEST(*r1 == *r2);
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -403,19 +412,18 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
     test::check_equivalent_keys(x);
 }
 
-template <class X>
-void move_emplace_tests(X*, test::random_generator generator)
+template <class X> void move_emplace_tests(X*, test::random_generator generator)
 {
-    std::cerr<<"emplace(move(value)) tests for containers with unique keys.\n";
+    std::cerr
+        << "emplace(move(value)) tests for containers with unique keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
     test::random_values<X> v(1000, generator);
 
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
 
         BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
         float b = x.max_load_factor();
@@ -425,7 +433,8 @@ void move_emplace_tests(X*, test::random_generator generator)
         tracker.insert(*it);
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -433,11 +442,10 @@ void move_emplace_tests(X*, test::random_generator generator)
     test::check_equivalent_keys(x);
 }
 
-template <class X>
-void default_emplace_tests(X*, test::random_generator)
+template <class X> void default_emplace_tests(X*, test::random_generator)
 {
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-    std::cerr<<"emplace() tests.\n";
+    std::cerr << "emplace() tests.\n";
     bool is_unique = test::has_unique_keys<X>::value;
 
     X x;
@@ -448,7 +456,7 @@ void default_emplace_tests(X*, test::random_generator)
     BOOST_TEST(x.size() == (is_unique ? 1u : 2u));
     x.emplace();
     BOOST_TEST(x.size() == (is_unique ? 1u : 3u));
-    
+
     typename X::value_type y;
     BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 3u));
     BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
@@ -457,31 +465,29 @@ void default_emplace_tests(X*, test::random_generator)
     BOOST_TEST(x.size() == (is_unique ? 1u : 4u));
     BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 4u));
     BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
-    
+
     x.clear();
     BOOST_TEST(x.empty());
     x.emplace(y);
     BOOST_TEST(x.size() == 1);
     x.emplace(y);
     BOOST_TEST(x.size() == (is_unique ? 1u : 2u));
-    
+
     BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 2u));
     BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
 #endif
 }
 
-template <class X>
-void map_tests(X*, test::random_generator generator)
+template <class X> void map_tests(X*, test::random_generator generator)
 {
-    std::cerr<<"map tests.\n";
+    std::cerr << "map tests.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
     test::random_values<X> v(1000, generator);
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
         BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
         float b = x.max_load_factor();
 
@@ -490,12 +496,13 @@ void map_tests(X*, test::random_generator generator)
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     tracker.compare(x);
-    test::check_equivalent_keys(x);   
+    test::check_equivalent_keys(x);
 }
 
 // Some tests for when the range's value type doesn't match the container's
@@ -504,20 +511,18 @@ void map_tests(X*, test::random_generator generator)
 template <class X>
 void map_insert_range_test1(X*, test::random_generator generator)
 {
-    std::cerr<<"map_insert_range_test1\n";
+    std::cerr << "map_insert_range_test1\n";
 
     test::check_instances check_;
 
-    typedef test::list<
-        std::pair<
-            BOOST_DEDUCED_TYPENAME X::key_type,
-            BOOST_DEDUCED_TYPENAME X::mapped_type
-        >
-    > list;
+    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type,
+        BOOST_DEDUCED_TYPENAME X::mapped_type> >
+        list;
     test::random_values<X> v(1000, generator);
     list l(v.begin(), v.end());
 
-    X x; x.insert(l.begin(), l.end());
+    X x;
+    x.insert(l.begin(), l.end());
 
     test::check_equivalent_keys(x);
 }
@@ -525,98 +530,83 @@ void map_insert_range_test1(X*, test::random_generator generator)
 template <class X>
 void map_insert_range_test2(X*, test::random_generator generator)
 {
-    std::cerr<<"map_insert_range_test2\n";
+    std::cerr << "map_insert_range_test2\n";
 
     test::check_instances check_;
 
-    typedef test::list<
-        std::pair<BOOST_DEDUCED_TYPENAME X::key_type const, test::implicitly_convertible>
-    > list;
-    test::random_values<
-        boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type, test::implicitly_convertible>
-    > v(1000, generator);
+    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type const,
+        test::implicitly_convertible> >
+        list;
+    test::random_values<boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type,
+        test::implicitly_convertible> >
+        v(1000, generator);
     list l(v.begin(), v.end());
 
-    X x; x.insert(l.begin(), l.end());
+    X x;
+    x.insert(l.begin(), l.end());
 
     test::check_equivalent_keys(x);
 }
 
-boost::unordered_set<test::movable,
-    test::hash, test::equal_to,
+boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    std::allocator<test::object> >* test_multimap_std_alloc;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
 
-boost::unordered_set<test::object,
-    test::hash, test::equal_to,
+boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::movable,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_multiset;
-boost::unordered_map<test::movable, test::movable,
-    test::hash, test::equal_to,
+boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
 using test::limited_range;
 
 UNORDERED_TEST(unique_insert_tests1,
-    ((test_set_std_alloc)(test_set)(test_map))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_set_std_alloc)(test_set)(test_map))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(equivalent_insert_tests1,
-    ((test_multimap_std_alloc)(test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(insert_tests2,
-    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(
+    insert_tests2, ((test_multimap_std_alloc)(test_set)(test_multiset)(
+                       test_map)(test_multimap))(
+                       (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(unique_emplace_tests1,
-    ((test_set_std_alloc)(test_set)(test_map))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_set_std_alloc)(test_set)(test_map))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(equivalent_emplace_tests1,
-    ((test_multimap_std_alloc)(test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(move_emplace_tests,
-    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)
-        (test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
+        test_multiset)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(default_emplace_tests,
-    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)
-        (test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
+        test_multiset)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(map_tests,
-    ((test_map))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_map))((default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(map_insert_range_test1,
-    ((test_multimap_std_alloc)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_multimap_std_alloc)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 UNORDERED_TEST(map_insert_range_test2,
-    ((test_multimap_std_alloc)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((test_multimap_std_alloc)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
@@ -638,7 +628,7 @@ struct initialize_from_two_ints
 UNORDERED_AUTO_TEST(insert_initializer_list_set)
 {
     boost::unordered_set<int> set;
-    set.insert({1,2,3,1});
+    set.insert({1, 2, 3, 1});
     BOOST_TEST_EQ(set.size(), 3u);
     BOOST_TEST(set.find(1) != set.end());
     BOOST_TEST(set.find(4) == set.end());
@@ -651,25 +641,25 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
     set2.insert({1, 2});
 #endif
     BOOST_TEST(set2.size() == 1);
-    BOOST_TEST(set2.find({1,2}) != set2.end());
-    BOOST_TEST(set2.find({2,1}) == set2.end());
+    BOOST_TEST(set2.find({1, 2}) != set2.end());
+    BOOST_TEST(set2.find({2, 1}) == set2.end());
 
-    set2.insert({{3,4},{5,6},{7,8}});
+    set2.insert({{3, 4}, {5, 6}, {7, 8}});
     BOOST_TEST(set2.size() == 4);
-    BOOST_TEST(set2.find({1,2}) != set2.end());
-    BOOST_TEST(set2.find({3,4}) != set2.end());
-    BOOST_TEST(set2.find({5,6}) != set2.end());
-    BOOST_TEST(set2.find({7,8}) != set2.end());
-    BOOST_TEST(set2.find({8,7}) == set2.end());
+    BOOST_TEST(set2.find({1, 2}) != set2.end());
+    BOOST_TEST(set2.find({3, 4}) != set2.end());
+    BOOST_TEST(set2.find({5, 6}) != set2.end());
+    BOOST_TEST(set2.find({7, 8}) != set2.end());
+    BOOST_TEST(set2.find({8, 7}) == set2.end());
 
-    set2.insert({{2, 1}, {3,4}});
+    set2.insert({{2, 1}, {3, 4}});
     BOOST_TEST(set2.size() == 5);
-    BOOST_TEST(set2.find({1,2}) != set2.end());
-    BOOST_TEST(set2.find({2,1}) != set2.end());
-    BOOST_TEST(set2.find({3,4}) != set2.end());
-    BOOST_TEST(set2.find({5,6}) != set2.end());
-    BOOST_TEST(set2.find({7,8}) != set2.end());
-    BOOST_TEST(set2.find({8,7}) == set2.end());
+    BOOST_TEST(set2.find({1, 2}) != set2.end());
+    BOOST_TEST(set2.find({2, 1}) != set2.end());
+    BOOST_TEST(set2.find({3, 4}) != set2.end());
+    BOOST_TEST(set2.find({5, 6}) != set2.end());
+    BOOST_TEST(set2.find({7, 8}) != set2.end());
+    BOOST_TEST(set2.find({8, 7}) == set2.end());
 }
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
@@ -677,13 +667,13 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
 UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
 {
     boost::unordered_multiset<std::string> multiset;
-    //multiset.insert({});
+    // multiset.insert({});
     BOOST_TEST(multiset.empty());
     multiset.insert({"a"});
     BOOST_TEST_EQ(multiset.size(), 1u);
     BOOST_TEST(multiset.find("a") != multiset.end());
     BOOST_TEST(multiset.find("b") == multiset.end());
-    multiset.insert({"a","b"});
+    multiset.insert({"a", "b"});
     BOOST_TEST(multiset.size() == 3);
     BOOST_TEST_EQ(multiset.count("a"), 2u);
     BOOST_TEST_EQ(multiset.count("b"), 1u);
@@ -695,18 +685,18 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
 UNORDERED_AUTO_TEST(insert_initializer_list_map)
 {
     boost::unordered_map<std::string, std::string> map;
-    //map.insert({});
+    // map.insert({});
     BOOST_TEST(map.empty());
-    map.insert({{"a", "b"},{"a", "b"},{"d", ""}});
+    map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(map.size(), 2u);
 }
 
 UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
 {
     boost::unordered_multimap<std::string, std::string> multimap;
-    //multimap.insert({});
+    // multimap.insert({});
     BOOST_TEST(multimap.empty());
-    multimap.insert({{"a", "b"},{"a", "b"},{"d", ""}});
+    multimap.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(multimap.size(), 3u);
     BOOST_TEST_EQ(multimap.count("a"), 2u);
 }
@@ -716,15 +706,17 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
 struct overloaded_constructor
 {
     overloaded_constructor(int x1_ = 1, int x2_ = 2, int x3_ = 3, int x4_ = 4)
-      : x1(x1_), x2(x2_), x3(x3_), x4(x4_) {}
+        : x1(x1_), x2(x2_), x3(x3_), x4(x4_)
+    {
+    }
 
     int x1, x2, x3, x4;
-    
+
     bool operator==(overloaded_constructor const& rhs) const
     {
         return x1 == rhs.x1 && x2 == rhs.x2 && x3 == rhs.x3 && x4 == rhs.x4;
     }
-    
+
     friend std::size_t hash_value(overloaded_constructor const& x)
     {
         std::size_t hash = 0;
@@ -742,13 +734,13 @@ UNORDERED_AUTO_TEST(map_emplace_test)
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
     x.emplace();
-    BOOST_TEST(x.find(0) != x.end() &&
-        x.find(0)->second == overloaded_constructor());
+    BOOST_TEST(
+        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
 #endif
 
     x.emplace(2, 3);
-    BOOST_TEST(x.find(2) != x.end() &&
-        x.find(2)->second == overloaded_constructor(3));
+    BOOST_TEST(
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
 }
 
 UNORDERED_AUTO_TEST(set_emplace_test)
@@ -782,15 +774,20 @@ UNORDERED_AUTO_TEST(set_emplace_test)
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
 }
 
-struct derived_from_piecewise_construct_t :
-    boost::unordered::piecewise_construct_t {};
+struct derived_from_piecewise_construct_t
+    : boost::unordered::piecewise_construct_t
+{
+};
 
-derived_from_piecewise_construct_t piecewise_rvalue() {
+derived_from_piecewise_construct_t piecewise_rvalue()
+{
     return derived_from_piecewise_construct_t();
 }
 
-struct convertible_to_piecewise {
-    operator boost::unordered::piecewise_construct_t() const {
+struct convertible_to_piecewise
+{
+    operator boost::unordered::piecewise_construct_t() const
+    {
         return boost::unordered::piecewise_construct;
     }
 };
@@ -799,38 +796,50 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
 {
     boost::unordered_map<overloaded_constructor, overloaded_constructor> x;
 
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(), boost::make_tuple());
-    BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+        boost::make_tuple());
+    BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
         x.find(overloaded_constructor())->second == overloaded_constructor());
 
-    x.emplace(convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
-    BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+    x.emplace(
+        convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
+    BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
         x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
-    x.emplace(piecewise_rvalue(), boost::make_tuple(2,3), boost::make_tuple(4,5,6));
-    BOOST_TEST(x.find(overloaded_constructor(2,3)) != x.end() &&
-        x.find(overloaded_constructor(2,3))->second == overloaded_constructor(4,5,6));
+    x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
+        boost::make_tuple(4, 5, 6));
+    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+               x.find(overloaded_constructor(2, 3))->second ==
+                   overloaded_constructor(4, 5, 6));
 
     derived_from_piecewise_construct_t d;
-    x.emplace(d, boost::make_tuple(9,3,1), boost::make_tuple(10));
-    BOOST_TEST(x.find(overloaded_constructor(9,3,1)) != x.end() &&
-        x.find(overloaded_constructor(9,3,1))->second == overloaded_constructor(10));
+    x.emplace(d, boost::make_tuple(9, 3, 1), boost::make_tuple(10));
+    BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+               x.find(overloaded_constructor(9, 3, 1))->second ==
+                   overloaded_constructor(10));
 }
 
 UNORDERED_AUTO_TEST(set_emplace_test2)
 {
-    boost::unordered_set<std::pair<overloaded_constructor, overloaded_constructor> > x;
+    boost::unordered_set<
+        std::pair<overloaded_constructor, overloaded_constructor> >
+        x;
     std::pair<overloaded_constructor, overloaded_constructor> check;
 
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(), boost::make_tuple());
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+        boost::make_tuple());
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
 
     x.clear();
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(1), boost::make_tuple(2,3));
-    check = std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));;
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(1),
+        boost::make_tuple(2, 3));
+    check =
+        std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
+    ;
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
 }
-
 }
 
 RUN_TESTS()
diff --git a/test/unordered/link_test_1.cpp b/test/unordered/link_test_1.cpp
index f44c1116..120bde59 100644
--- a/test/unordered/link_test_1.cpp
+++ b/test/unordered/link_test_1.cpp
@@ -10,10 +10,8 @@
 #include "../helpers/postfix.hpp"
 // clang-format on
 
-void foo(boost::unordered_set<int>&,
-        boost::unordered_map<int, int>&,
-        boost::unordered_multiset<int>&,
-        boost::unordered_multimap<int, int>&);
+void foo(boost::unordered_set<int>&, boost::unordered_map<int, int>&,
+    boost::unordered_multiset<int>&, boost::unordered_multimap<int, int>&);
 
 int main()
 {
@@ -23,6 +21,6 @@ int main()
     boost::unordered_multimap<int, int> x4;
 
     foo(x1, x2, x3, x4);
-    
+
     return 0;
 }
diff --git a/test/unordered/link_test_2.cpp b/test/unordered/link_test_2.cpp
index b052be17..b76da7b0 100644
--- a/test/unordered/link_test_2.cpp
+++ b/test/unordered/link_test_2.cpp
@@ -10,18 +10,17 @@
 #include "../helpers/postfix.hpp"
 // clang-format on
 
-void foo(boost::unordered_set<int>& x1,
-        boost::unordered_map<int, int>& x2,
-        boost::unordered_multiset<int>& x3,
-        boost::unordered_multimap<int, int>& x4)
+void foo(boost::unordered_set<int>& x1, boost::unordered_map<int, int>& x2,
+    boost::unordered_multiset<int>& x3, boost::unordered_multimap<int, int>& x4)
 {
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-        struct dummy {
-            boost::unordered_set<int> x1;
-            boost::unordered_map<int, int> x2;
-            boost::unordered_multiset<int> x3;
-            boost::unordered_multimap<int, int> x4;
-        };
+    struct dummy
+    {
+        boost::unordered_set<int> x1;
+        boost::unordered_map<int, int> x2;
+        boost::unordered_multiset<int> x3;
+        boost::unordered_multimap<int, int> x4;
+    };
 #endif
 
     x1.insert(1);
diff --git a/test/unordered/load_factor_tests.cpp b/test/unordered/load_factor_tests.cpp
index dd4fbb1f..6280d977 100644
--- a/test/unordered/load_factor_tests.cpp
+++ b/test/unordered/load_factor_tests.cpp
@@ -16,16 +16,14 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 #endif
 
-namespace load_factor_tests
-{
+namespace load_factor_tests {
 
 test::seed_t initialize_seed(783656);
 
-template <class X>
-void set_load_factor_tests(X*)
+template <class X> void set_load_factor_tests(X*)
 {
     X x;
 
@@ -34,8 +32,10 @@ void set_load_factor_tests(X*)
 
     // A valid implementation could fail these tests, but I think they're
     // reasonable.
-    x.max_load_factor(2.0); BOOST_TEST(x.max_load_factor() == 2.0);
-    x.max_load_factor(0.5); BOOST_TEST(x.max_load_factor() == 0.5);
+    x.max_load_factor(2.0);
+    BOOST_TEST(x.max_load_factor() == 2.0);
+    x.max_load_factor(0.5);
+    BOOST_TEST(x.max_load_factor() == 0.5);
 }
 
 template <class X>
@@ -47,13 +47,15 @@ void insert_test(X*, float mlf, test::random_generator generator)
 
     test::random_values<X> values(1000, generator);
 
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
-            it = values.begin(), end = values.end(); it != end; ++it)
-    {
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
+             it = values.begin(),
+             end = values.end();
+         it != end; ++it) {
         BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
-                 old_bucket_count = x.bucket_count();
+                                            old_bucket_count = x.bucket_count();
         x.insert(*it);
-        if(static_cast<double>(old_size + 1) <= b * static_cast<double>(old_bucket_count))
+        if (static_cast<double>(old_size + 1) <=
+            b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 }
@@ -65,12 +67,10 @@ void load_factor_insert_tests(X* ptr, test::random_generator generator)
     insert_test(ptr, 0.1f, generator);
     insert_test(ptr, 100.0f, generator);
 
-    insert_test(ptr, (std::numeric_limits<float>::min)(),
-        generator);
+    insert_test(ptr, (std::numeric_limits<float>::min)(), generator);
 
-    if(std::numeric_limits<float>::has_infinity)
-        insert_test(ptr, std::numeric_limits<float>::infinity(),
-            generator);
+    if (std::numeric_limits<float>::has_infinity)
+        insert_test(ptr, std::numeric_limits<float>::infinity(), generator);
 }
 
 boost::unordered_set<int>* int_set_ptr;
@@ -83,19 +83,16 @@ using test::generate_collisions;
 using test::limited_range;
 
 UNORDERED_TEST(set_load_factor_tests,
-    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
-)
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)))
 
 UNORDERED_TEST(load_factor_insert_tests,
-    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 #endif
diff --git a/test/unordered/minimal_allocator.cpp b/test/unordered/minimal_allocator.cpp
index 7099d573..968f11fb 100644
--- a/test/unordered/minimal_allocator.cpp
+++ b/test/unordered/minimal_allocator.cpp
@@ -3,60 +3,58 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/unordered/detail/implementation.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
 #include "../objects/test.hpp"
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/unordered/detail/implementation.hpp>
 
-template <class Tp> 
-struct SimpleAllocator
-{ 
+template <class Tp> struct SimpleAllocator
+{
     typedef Tp value_type;
 
-    SimpleAllocator()
-    {
-    }
+    SimpleAllocator() {}
 
-    template <class T> SimpleAllocator(const SimpleAllocator<T>&)
-    {
-    }
+    template <class T> SimpleAllocator(const SimpleAllocator<T>&) {}
 
-    Tp *allocate(std::size_t n)
+    Tp* allocate(std::size_t n)
     {
         return static_cast<Tp*>(::operator new(n * sizeof(Tp)));
     }
 
-    void deallocate(Tp* p, std::size_t)
-    {
-        ::operator delete((void*) p);
-    }
+    void deallocate(Tp* p, std::size_t) { ::operator delete((void*)p); }
 };
 
-template <typename T>
-void test_simple_allocator()
+template <typename T> void test_simple_allocator()
 {
     test::check_instances check_;
 
-    typedef boost::unordered::detail::allocator_traits<
-        SimpleAllocator<T> > traits;
+    typedef boost::unordered::detail::allocator_traits<SimpleAllocator<T> >
+        traits;
 
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type,
+        SimpleAllocator<T> >::value));
 
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::value_type, T>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<typename traits::value_type, T>::value));
 
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::pointer, T* >::value));
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_pointer, T const*>::value));
-    //BOOST_STATIC_ASSERT((boost::is_same<typename traits::void_pointer, void* >::value));
-    //BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_void_pointer, void const*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::pointer, T*>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<typename traits::const_pointer, T const*>::value));
+    // BOOST_STATIC_ASSERT((boost::is_same<typename traits::void_pointer, void*
+    // >::value));
+    // BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_void_pointer,
+    // void const*>::value));
 
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::difference_type,
+        std::ptrdiff_t>::value));
 
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
     BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type,
         std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type, std::size_t>::value));
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<typename traits::size_type, std::size_t>::value));
 #endif
 
     BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
@@ -69,18 +67,18 @@ void test_simple_allocator()
     SimpleAllocator<T> a;
 
     T* ptr1 = traits::allocate(a, 1);
-    //T* ptr2 = traits::allocate(a, 1, static_cast<void const*>(ptr1));
-    
+    // T* ptr2 = traits::allocate(a, 1, static_cast<void const*>(ptr1));
+
     traits::construct(a, ptr1, T(10));
-    //traits::construct(a, ptr2, T(30), ptr1);
+    // traits::construct(a, ptr2, T(30), ptr1);
 
     BOOST_TEST(*ptr1 == T(10));
-    //BOOST_TEST(*ptr2 == T(30));
+    // BOOST_TEST(*ptr2 == T(30));
 
     traits::destroy(a, ptr1);
-    //traits::destroy(a, ptr2);
+    // traits::destroy(a, ptr2);
 
-    //traits::deallocate(a, ptr2, 1);
+    // traits::deallocate(a, ptr2, 1);
     traits::deallocate(a, ptr1, 1);
 
     traits::max_size(a);
diff --git a/test/unordered/move_tests.cpp b/test/unordered/move_tests.cpp
index ed5b4aa7..aa2420e9 100644
--- a/test/unordered/move_tests.cpp
+++ b/test/unordered/move_tests.cpp
@@ -19,390 +19,357 @@
 #include "../helpers/invariants.hpp"
 
 #if defined(BOOST_MSVC)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 #endif
 
-namespace move_tests
-{
-    test::seed_t initialize_seed(98624);
-#if defined(BOOST_UNORDERED_USE_MOVE) || !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+namespace move_tests {
+test::seed_t initialize_seed(98624);
+#if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
+    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #define BOOST_UNORDERED_TEST_MOVING 1
 #else
 #define BOOST_UNORDERED_TEST_MOVING 0
 #endif
 
-    template<class T>
-    T empty(T*) {
-        return T();
-    }
+template <class T> T empty(T*) { return T(); }
 
-    template<class T>
-    T create(test::random_values<T> const& v,
-            test::object_count& count) {
-        T x(v.begin(), v.end());
-        count = test::global_object_count;
-        return x;
-    }
+template <class T>
+T create(test::random_values<T> const& v, test::object_count& count)
+{
+    T x(v.begin(), v.end());
+    count = test::global_object_count;
+    return x;
+}
 
-    template<class T>
-    T create(test::random_values<T> const& v,
-            test::object_count& count,
-            BOOST_DEDUCED_TYPENAME T::hasher hf,
-            BOOST_DEDUCED_TYPENAME T::key_equal eq,
-            BOOST_DEDUCED_TYPENAME T::allocator_type al,
-            float mlf) {
-        T x(0, hf, eq, al);
-        x.max_load_factor(mlf);
-        x.insert(v.begin(), v.end());
-        count = test::global_object_count;
-        return x;
-    }
+template <class T>
+T create(test::random_values<T> const& v, test::object_count& count,
+    BOOST_DEDUCED_TYPENAME T::hasher hf, BOOST_DEDUCED_TYPENAME T::key_equal eq,
+    BOOST_DEDUCED_TYPENAME T::allocator_type al, float mlf)
+{
+    T x(0, hf, eq, al);
+    x.max_load_factor(mlf);
+    x.insert(v.begin(), v.end());
+    count = test::global_object_count;
+    return x;
+}
+
+template <class T>
+void move_construct_tests1(T* ptr, test::random_generator const& generator)
+{
+    BOOST_DEDUCED_TYPENAME T::hasher hf;
+    BOOST_DEDUCED_TYPENAME T::key_equal eq;
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
-    template <class T>
-    void move_construct_tests1(T* ptr, test::random_generator const& generator)
     {
-        BOOST_DEDUCED_TYPENAME T::hasher hf;
-        BOOST_DEDUCED_TYPENAME T::key_equal eq;
-        BOOST_DEDUCED_TYPENAME T::allocator_type al;
+        test::check_instances check_;
 
-        {
-            test::check_instances check_;
-
-            T y(empty(ptr));
-            BOOST_TEST(y.empty());
-            BOOST_TEST(test::equivalent(y.hash_function(), hf));
-            BOOST_TEST(test::equivalent(y.key_eq(), eq));
-            BOOST_TEST(test::equivalent(y.get_allocator(), al));
-            BOOST_TEST(y.max_load_factor() == 1.0);
-            test::check_equivalent_keys(y);
-        }
-
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v(1000, generator);
-            test::object_count count;
-            T y(create(v, count));
-#if defined(BOOST_HAS_NRVO)
-            BOOST_TEST(count == test::global_object_count);
-#endif
-            test::check_container(y, v);
-            test::check_equivalent_keys(y);
-        }
+        T y(empty(ptr));
+        BOOST_TEST(y.empty());
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+        BOOST_TEST(y.max_load_factor() == 1.0);
+        test::check_equivalent_keys(y);
     }
 
-    template <class T>
-    void move_assign_tests1(T*, test::random_generator const& generator)
     {
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v(500, generator);
-            test::object_count count;
-            T y;
-            y = create(v, count);
-#if BOOST_UNORDERED_TEST_MOVING && defined(BOOST_HAS_NRVO)
-            BOOST_TEST(count == test::global_object_count);
-#endif
-            test::check_container(y, v);
-            test::check_equivalent_keys(y);
-        }
-    }
-
-    template <class T>
-    void move_construct_tests2(T*, test::random_generator const& generator)
-    {
-        BOOST_DEDUCED_TYPENAME T::hasher hf(1);
-        BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
-        BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
-        BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+        test::check_instances check_;
 
+        test::random_values<T> v(1000, generator);
         test::object_count count;
-
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v(500, generator);
-            T y(create(v, count, hf, eq, al, 0.5));
+        T y(create(v, count));
 #if defined(BOOST_HAS_NRVO)
-            BOOST_TEST(count == test::global_object_count);
+        BOOST_TEST(count == test::global_object_count);
 #endif
-            test::check_container(y, v);
-            BOOST_TEST(test::equivalent(y.hash_function(), hf));
-            BOOST_TEST(test::equivalent(y.key_eq(), eq));
-            BOOST_TEST(test::equivalent(y.get_allocator(), al));
-            BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required.
-            test::check_equivalent_keys(y);
-        }
-
-        {
-            test::check_instances check_;
-
-            // TODO: To do this correctly requires the fancy new allocator
-            // stuff.
-            test::random_values<T> v(500, generator);
-            T y(create(v, count, hf, eq, al, 2.0), al2);
-            BOOST_TEST(count != test::global_object_count);
-            test::check_container(y, v);
-            BOOST_TEST(test::equivalent(y.hash_function(), hf));
-            BOOST_TEST(test::equivalent(y.key_eq(), eq));
-            BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required.
-            test::check_equivalent_keys(y);
-        }
-
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v(25, generator);
-            T y(create(v, count, hf, eq, al, 1.0), al);
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            BOOST_TEST(count == test::global_object_count);
-#elif defined(BOOST_HAS_NRVO)
-            BOOST_TEST(
-                static_cast<std::size_t>(test::global_object_count.constructions
-                    - count.constructions) <=
-                (test::is_set<T>::value ? 1 : 2) *
-                    (test::has_unique_keys<T>::value ? 25 : v.size()));
-            BOOST_TEST(count.instances == test::global_object_count.instances);
-#else
-            BOOST_TEST(
-                static_cast<std::size_t>(test::global_object_count.constructions
-                    - count.constructions) <=
-                (test::is_set<T>::value ? 2 : 4) *
-                    (test::has_unique_keys<T>::value ? 25 : v.size()));
-            BOOST_TEST(count.instances == test::global_object_count.instances);
-#endif
-            test::check_container(y, v);
-            BOOST_TEST(test::equivalent(y.hash_function(), hf));
-            BOOST_TEST(test::equivalent(y.key_eq(), eq));
-            BOOST_TEST(test::equivalent(y.get_allocator(), al));
-            BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
-            test::check_equivalent_keys(y);
-        }
+        test::check_container(y, v);
+        test::check_equivalent_keys(y);
     }
+}
 
-    template <class T>
-    void move_assign_tests2(T*, test::random_generator const& generator)
+template <class T>
+void move_assign_tests1(T*, test::random_generator const& generator)
+{
     {
-        BOOST_DEDUCED_TYPENAME T::hasher hf(1);
-        BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
-        BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
-        BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-        typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+        test::check_instances check_;
 
-        {
-            test::random_values<T> v(500, generator);
-            test::random_values<T> v2(0, generator);
-            T y(v.begin(), v.end(), 0, hf, eq, al1);
-            test::object_count count;
-            y = create(v2, count, hf, eq, al2, 2.0);
-            BOOST_TEST(y.empty());
-            test::check_container(y, v2);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 2.0);
+        test::random_values<T> v(500, generator);
+        test::object_count count;
+        T y;
+        y = create(v, count);
+#if BOOST_UNORDERED_TEST_MOVING && defined(BOOST_HAS_NRVO)
+        BOOST_TEST(count == test::global_object_count);
+#endif
+        test::check_container(y, v);
+        test::check_equivalent_keys(y);
+    }
+}
+
+template <class T>
+void move_construct_tests2(T*, test::random_generator const& generator)
+{
+    BOOST_DEDUCED_TYPENAME T::hasher hf(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+
+    test::object_count count;
+
+    {
+        test::check_instances check_;
+
+        test::random_values<T> v(500, generator);
+        T y(create(v, count, hf, eq, al, 0.5));
+#if defined(BOOST_HAS_NRVO)
+        BOOST_TEST(count == test::global_object_count);
+#endif
+        test::check_container(y, v);
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+        BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required.
+        test::check_equivalent_keys(y);
+    }
+
+    {
+        test::check_instances check_;
+
+        // TODO: To do this correctly requires the fancy new allocator
+        // stuff.
+        test::random_values<T> v(500, generator);
+        T y(create(v, count, hf, eq, al, 2.0), al2);
+        BOOST_TEST(count != test::global_object_count);
+        test::check_container(y, v);
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required.
+        test::check_equivalent_keys(y);
+    }
+
+    {
+        test::check_instances check_;
+
+        test::random_values<T> v(25, generator);
+        T y(create(v, count, hf, eq, al, 1.0), al);
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        BOOST_TEST(count == test::global_object_count);
+#elif defined(BOOST_HAS_NRVO)
+        BOOST_TEST(
+            static_cast<std::size_t>(test::global_object_count.constructions -
+                                     count.constructions) <=
+            (test::is_set<T>::value ? 1 : 2) *
+                (test::has_unique_keys<T>::value ? 25 : v.size()));
+        BOOST_TEST(count.instances == test::global_object_count.instances);
+#else
+        BOOST_TEST(
+            static_cast<std::size_t>(test::global_object_count.constructions -
+                                     count.constructions) <=
+            (test::is_set<T>::value ? 2 : 4) *
+                (test::has_unique_keys<T>::value ? 25 : v.size()));
+        BOOST_TEST(count.instances == test::global_object_count.instances);
+#endif
+        test::check_container(y, v);
+        BOOST_TEST(test::equivalent(y.hash_function(), hf));
+        BOOST_TEST(test::equivalent(y.key_eq(), eq));
+        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+        BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
+        test::check_equivalent_keys(y);
+    }
+}
+
+template <class T>
+void move_assign_tests2(T*, test::random_generator const& generator)
+{
+    BOOST_DEDUCED_TYPENAME T::hasher hf(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
+    {
+        test::random_values<T> v(500, generator);
+        test::random_values<T> v2(0, generator);
+        T y(v.begin(), v.end(), 0, hf, eq, al1);
+        test::object_count count;
+        y = create(v2, count, hf, eq, al2, 2.0);
+        BOOST_TEST(y.empty());
+        test::check_container(y, v2);
+        test::check_equivalent_keys(y);
+        BOOST_TEST(y.max_load_factor() == 2.0);
 
 #if defined(BOOST_HAS_NRVO)
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
-#endif
+        if (BOOST_UNORDERED_TEST_MOVING
+                ? (bool)allocator_type::is_propagate_on_move
+                : (bool)allocator_type::is_propagate_on_assign) {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        } else {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al1));
         }
-
-        {
-            test::random_values<T> v(500, generator);
-            test::object_count count;
-            T y(0, hf, eq, al1);
-            y = create(v, count, hf, eq, al2, 0.5);
-#if defined(BOOST_HAS_NRVO)
-            if (BOOST_UNORDERED_TEST_MOVING &&
-                    allocator_type::is_propagate_on_move)
-            {
-                BOOST_TEST(count == test::global_object_count);
-            }
 #endif
-            test::check_container(y, v);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 0.5);
+    }
+
+    {
+        test::random_values<T> v(500, generator);
+        test::object_count count;
+        T y(0, hf, eq, al1);
+        y = create(v, count, hf, eq, al2, 0.5);
+#if defined(BOOST_HAS_NRVO)
+        if (BOOST_UNORDERED_TEST_MOVING &&
+            allocator_type::is_propagate_on_move) {
+            BOOST_TEST(count == test::global_object_count);
+        }
+#endif
+        test::check_container(y, v);
+        test::check_equivalent_keys(y);
+        BOOST_TEST(y.max_load_factor() == 0.5);
 
 #if defined(BOOST_HAS_NRVO)
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
+        if (BOOST_UNORDERED_TEST_MOVING
+                ? (bool)allocator_type::is_propagate_on_move
+                : (bool)allocator_type::is_propagate_on_assign) {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        } else {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+        }
 #endif
+    }
+
+    {
+        test::check_instances check_;
+
+        test::random_values<T> v(500, generator);
+        T y(0, hf, eq, al1);
+
+        T x(0, hf, eq, al2);
+        x.max_load_factor(0.25);
+        x.insert(v.begin(), v.end());
+
+        test::object_count count = test::global_object_count;
+        y = boost::move(x);
+        if (BOOST_UNORDERED_TEST_MOVING &&
+            allocator_type::is_propagate_on_move) {
+            BOOST_TEST(count == test::global_object_count);
         }
+        test::check_container(y, v);
+        test::check_equivalent_keys(y);
+        BOOST_TEST(y.max_load_factor() == 0.25);
 
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v(500, generator);
-            T y(0, hf, eq, al1);
-
-            T x(0, hf, eq, al2);
-            x.max_load_factor(0.25);
-            x.insert(v.begin(), v.end());
-
-            test::object_count count = test::global_object_count;
-            y = boost::move(x);
-            if (BOOST_UNORDERED_TEST_MOVING &&
-                    allocator_type::is_propagate_on_move)
-            {
-                BOOST_TEST(count == test::global_object_count);
-            }
-            test::check_container(y, v);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 0.25);
-
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
-        }
-
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v1(1000, generator);
-            test::random_values<T> v2(200, generator);
-
-            T x(0, hf, eq, al2);
-            x.max_load_factor(0.5);
-            x.insert(v2.begin(), v2.end());
-
-            test::object_count count1 = test::global_object_count;
-
-            T y(v1.begin(), v1.end(), 0, hf, eq, al1);
-            y = boost::move(x);
-
-            test::object_count count2 = test::global_object_count;
-
-            if (BOOST_UNORDERED_TEST_MOVING &&
-                    allocator_type::is_propagate_on_move)
-            {
-                BOOST_TEST(count1.instances ==
-                    test::global_object_count.instances);
-                BOOST_TEST(count2.constructions ==
-                    test::global_object_count.constructions);
-            }
-
-            test::check_container(y, v2);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 0.5);
-
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
+        if (BOOST_UNORDERED_TEST_MOVING
+                ? (bool)allocator_type::is_propagate_on_move
+                : (bool)allocator_type::is_propagate_on_assign) {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        } else {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al1));
         }
     }
 
-    boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        std::allocator<test::object> >* test_map_std_alloc;
+    {
+        test::check_instances check_;
 
-    boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_set;
-    boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_multiset;
-    boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_map;
-    boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_multimap;
+        test::random_values<T> v1(1000, generator);
+        test::random_values<T> v2(200, generator);
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
+        T x(0, hf, eq, al2);
+        x.max_load_factor(0.5);
+        x.insert(v2.begin(), v2.end());
+
+        test::object_count count1 = test::global_object_count;
+
+        T y(v1.begin(), v1.end(), 0, hf, eq, al1);
+        y = boost::move(x);
+
+        test::object_count count2 = test::global_object_count;
+
+        if (BOOST_UNORDERED_TEST_MOVING &&
+            allocator_type::is_propagate_on_move) {
+            BOOST_TEST(count1.instances == test::global_object_count.instances);
+            BOOST_TEST(count2.constructions ==
+                       test::global_object_count.constructions);
+        }
+
+        test::check_container(y, v2);
+        test::check_equivalent_keys(y);
+        BOOST_TEST(y.max_load_factor() == 0.5);
+
+        if (BOOST_UNORDERED_TEST_MOVING
+                ? (bool)allocator_type::is_propagate_on_move
+                : (bool)allocator_type::is_propagate_on_assign) {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        } else {
+            BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+        }
+    }
+}
+
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    std::allocator<test::object> >* test_map_std_alloc;
+
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_set;
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
     test_set_prop_move;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
     test_multiset_prop_move;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
     test_map_prop_move;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::propagate_move> >*
     test_multimap_prop_move;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_set_no_prop_move;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_multiset_no_prop_move;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_map_no_prop_move;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_multimap_no_prop_move;
 
-    using test::default_generator;
-    using test::generate_collisions;
-    using test::limited_range;
+using test::default_generator;
+using test::generate_collisions;
+using test::limited_range;
 
-    UNORDERED_TEST(move_construct_tests1, (
-            (test_map_std_alloc)
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
-    )
-    UNORDERED_TEST(move_assign_tests1, (
-            (test_map_std_alloc)
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
-    )
-    UNORDERED_TEST(move_construct_tests2, (
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
-    )
-    UNORDERED_TEST(move_assign_tests2, (
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
-    )
+UNORDERED_TEST(move_construct_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+        test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(
+        test_multimap_prop_move)(test_set_no_prop_move)(
+        test_multiset_no_prop_move)(test_map_no_prop_move)(
+        test_multimap_no_prop_move))(
+                   (default_generator)(generate_collisions)(limited_range)))
+UNORDERED_TEST(move_assign_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+        test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(
+        test_multimap_prop_move)(test_set_no_prop_move)(
+        test_multiset_no_prop_move)(test_map_no_prop_move)(
+        test_multimap_no_prop_move))(
+                   (default_generator)(generate_collisions)(limited_range)))
+UNORDERED_TEST(move_construct_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
+        test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
+        test_set_no_prop_move)(test_multiset_no_prop_move)(
+        test_map_no_prop_move)(test_multimap_no_prop_move))(
+                   (default_generator)(generate_collisions)(limited_range)))
+UNORDERED_TEST(move_assign_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
+        test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
+        test_set_no_prop_move)(test_multiset_no_prop_move)(
+        test_map_no_prop_move)(test_multimap_no_prop_move))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/noexcept_tests.cpp b/test/unordered/noexcept_tests.cpp
index bf4421a1..cadf8b70 100644
--- a/test/unordered/noexcept_tests.cpp
+++ b/test/unordered/noexcept_tests.cpp
@@ -12,139 +12,159 @@
 
 #include "../helpers/test.hpp"
 
-namespace noexcept_tests
+namespace noexcept_tests {
+// Test the noexcept is set correctly for the move constructor.
+
+struct hash_possible_exception : boost::hash<int>
 {
-    // Test the noexcept is set correctly for the move constructor.
- 
-    struct hash_possible_exception : boost::hash<int>
-    {
-        hash_possible_exception(hash_possible_exception const&) {}
-    };
+    hash_possible_exception(hash_possible_exception const&) {}
+};
 
-    struct equal_to_possible_exception : std::equal_to<int>
-    {
-        equal_to_possible_exception(equal_to_possible_exception const&) {}
-    };
+struct equal_to_possible_exception : std::equal_to<int>
+{
+    equal_to_possible_exception(equal_to_possible_exception const&) {}
+};
 
-    // Test that the move constructor does actually move without throwing
-    // an exception when it claims to.
+// Test that the move constructor does actually move without throwing
+// an exception when it claims to.
 
-    struct test_exception {};
+struct test_exception
+{
+};
 
-    bool throwing_test_exception = false;
-    void test_throw(char const* name) {
-        if (throwing_test_exception) {
-            std::cerr << "Throw exception in: " << name << std::endl;
-            throw test_exception();
-        }
-    }
-
-    class hash_nothrow_move : boost::hash<int>
-    {
-        BOOST_COPYABLE_AND_MOVABLE(hash_nothrow_move)
-
-        typedef boost::hash<int> base;
-    public:
-        hash_nothrow_move(BOOST_RV_REF(hash_nothrow_move))
-            BOOST_NOEXCEPT {}
-
-        hash_nothrow_move() { test_throw("Constructor"); }
-        hash_nothrow_move(hash_nothrow_move const&) { test_throw("Copy"); }
-        hash_nothrow_move& operator=(BOOST_COPY_ASSIGN_REF(hash_nothrow_move))
-        { test_throw("Assign"); return *this; }
-        hash_nothrow_move& operator=(BOOST_RV_REF(hash_nothrow_move))
-        { test_throw("Move Assign"); return *this; }
-        std::size_t operator()(int x) const
-        { test_throw("Operator"); return static_cast<base const&>(*this)(x); }
-    };
-
-    class equal_to_nothrow_move : std::equal_to<int>
-    {
-        BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow_move)
-
-        typedef std::equal_to<int> base;
-    public:
-        equal_to_nothrow_move(BOOST_RV_REF(equal_to_nothrow_move))
-            BOOST_NOEXCEPT {}
-        equal_to_nothrow_move() { test_throw("Constructor"); }
-        equal_to_nothrow_move(equal_to_nothrow_move const&)
-        { test_throw("Copy"); }
-        equal_to_nothrow_move& operator=(BOOST_COPY_ASSIGN_REF(equal_to_nothrow_move))
-        { test_throw("Assign"); return *this; }
-        equal_to_nothrow_move& operator=(BOOST_RV_REF(equal_to_nothrow_move))
-        { test_throw("Move Assign"); return *this; }
-        std::size_t operator()(int x, int y) const
-        { test_throw("Operator"); return static_cast<base const&>(*this)(x, y); }
-    };
-
-    bool have_is_nothrow_move = false;
-
-    UNORDERED_AUTO_TEST(check_is_nothrow_move)
-    {
-        BOOST_TEST(!boost::is_nothrow_move_constructible<hash_possible_exception>::value);
-        have_is_nothrow_move = boost::is_nothrow_move_constructible<hash_nothrow_move>::value;
-
-        // Copied from boost::is_nothrow_move_constructible implementation
-        // to make sure this does actually detect it when expected.
-        //
-        // The type trait is also available when BOOST_IS_NOTHROW_MOVE_CONSTRUCT
-        // is defined (for some versions of Visual C++?) but detects 'throw()',
-        // not noexcept.
-#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
-        BOOST_TEST(have_is_nothrow_move);
-#endif
-    }
-
-    UNORDERED_AUTO_TEST(test_noexcept)
-    {
-        if (have_is_nothrow_move) {
-            BOOST_TEST((boost::is_nothrow_move_constructible<
-                        boost::unordered_set<int> >::value));
-            BOOST_TEST((boost::is_nothrow_move_constructible<
-                        boost::unordered_multiset<int> >::value));
-            BOOST_TEST((boost::is_nothrow_move_constructible<
-                        boost::unordered_map<int, int> >::value));
-            BOOST_TEST((boost::is_nothrow_move_constructible<
-                        boost::unordered_multimap<int, int> >::value));
-        }
-
-        BOOST_TEST((!boost::is_nothrow_move_constructible<
-                    boost::unordered_set<int, hash_possible_exception>
-                >::value));
-        BOOST_TEST((!boost::is_nothrow_move_constructible<
-                    boost::unordered_multiset<int, boost::hash<int>,
-                    equal_to_possible_exception>
-                >::value));
-    }
-
-    UNORDERED_AUTO_TEST(test_no_throw_when_noexcept)
-    {
-        typedef boost::unordered_set<int,
-                hash_nothrow_move, equal_to_nothrow_move> throwing_set;
-
-        if (have_is_nothrow_move)
-        {
-            BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
-
-            throwing_test_exception = false;
-
-            throwing_set x1;
-            x1.insert(10);
-            x1.insert(50);
-
-            try {
-                throwing_test_exception = true;
-
-                throwing_set x2 = boost::move(x1);
-                BOOST_TEST(x2.size() == 2);
-                BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
-            } catch(test_exception) {
-                BOOST_TEST(false);
-            }
-
-            throwing_test_exception = false;
-        }
+bool throwing_test_exception = false;
+void test_throw(char const* name)
+{
+    if (throwing_test_exception) {
+        std::cerr << "Throw exception in: " << name << std::endl;
+        throw test_exception();
     }
 }
 
+class hash_nothrow_move : boost::hash<int>
+{
+    BOOST_COPYABLE_AND_MOVABLE(hash_nothrow_move)
+
+    typedef boost::hash<int> base;
+
+  public:
+    hash_nothrow_move(BOOST_RV_REF(hash_nothrow_move)) BOOST_NOEXCEPT {}
+
+    hash_nothrow_move() { test_throw("Constructor"); }
+    hash_nothrow_move(hash_nothrow_move const&) { test_throw("Copy"); }
+    hash_nothrow_move& operator=(BOOST_COPY_ASSIGN_REF(hash_nothrow_move))
+    {
+        test_throw("Assign");
+        return *this;
+    }
+    hash_nothrow_move& operator=(BOOST_RV_REF(hash_nothrow_move))
+    {
+        test_throw("Move Assign");
+        return *this;
+    }
+    std::size_t operator()(int x) const
+    {
+        test_throw("Operator");
+        return static_cast<base const&>(*this)(x);
+    }
+};
+
+class equal_to_nothrow_move : std::equal_to<int>
+{
+    BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow_move)
+
+    typedef std::equal_to<int> base;
+
+  public:
+    equal_to_nothrow_move(BOOST_RV_REF(equal_to_nothrow_move)) BOOST_NOEXCEPT {}
+    equal_to_nothrow_move() { test_throw("Constructor"); }
+    equal_to_nothrow_move(equal_to_nothrow_move const&) { test_throw("Copy"); }
+    equal_to_nothrow_move& operator=(
+        BOOST_COPY_ASSIGN_REF(equal_to_nothrow_move))
+    {
+        test_throw("Assign");
+        return *this;
+    }
+    equal_to_nothrow_move& operator=(BOOST_RV_REF(equal_to_nothrow_move))
+    {
+        test_throw("Move Assign");
+        return *this;
+    }
+    std::size_t operator()(int x, int y) const
+    {
+        test_throw("Operator");
+        return static_cast<base const&>(*this)(x, y);
+    }
+};
+
+bool have_is_nothrow_move = false;
+
+UNORDERED_AUTO_TEST(check_is_nothrow_move)
+{
+    BOOST_TEST(
+        !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
+    have_is_nothrow_move =
+        boost::is_nothrow_move_constructible<hash_nothrow_move>::value;
+
+// Copied from boost::is_nothrow_move_constructible implementation
+// to make sure this does actually detect it when expected.
+//
+// The type trait is also available when BOOST_IS_NOTHROW_MOVE_CONSTRUCT
+// is defined (for some versions of Visual C++?) but detects 'throw()',
+// not noexcept.
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) &&     \
+    !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
+    BOOST_TEST(have_is_nothrow_move);
+#endif
+}
+
+UNORDERED_AUTO_TEST(test_noexcept)
+{
+    if (have_is_nothrow_move) {
+        BOOST_TEST((boost::is_nothrow_move_constructible<
+            boost::unordered_set<int> >::value));
+        BOOST_TEST((boost::is_nothrow_move_constructible<
+            boost::unordered_multiset<int> >::value));
+        BOOST_TEST((boost::is_nothrow_move_constructible<
+            boost::unordered_map<int, int> >::value));
+        BOOST_TEST((boost::is_nothrow_move_constructible<
+            boost::unordered_multimap<int, int> >::value));
+    }
+
+    BOOST_TEST((!boost::is_nothrow_move_constructible<
+                boost::unordered_set<int, hash_possible_exception> >::value));
+    BOOST_TEST(
+        (!boost::is_nothrow_move_constructible<boost::unordered_multiset<int,
+                boost::hash<int>, equal_to_possible_exception> >::value));
+}
+
+UNORDERED_AUTO_TEST(test_no_throw_when_noexcept)
+{
+    typedef boost::unordered_set<int, hash_nothrow_move, equal_to_nothrow_move>
+        throwing_set;
+
+    if (have_is_nothrow_move) {
+        BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
+
+        throwing_test_exception = false;
+
+        throwing_set x1;
+        x1.insert(10);
+        x1.insert(50);
+
+        try {
+            throwing_test_exception = true;
+
+            throwing_set x2 = boost::move(x1);
+            BOOST_TEST(x2.size() == 2);
+            BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
+        } catch (test_exception) {
+            BOOST_TEST(false);
+        }
+
+        throwing_test_exception = false;
+    }
+}
+}
+
 RUN_TESTS()
diff --git a/test/unordered/rehash_tests.cpp b/test/unordered/rehash_tests.cpp
index 0c3d5828..ee670ace 100644
--- a/test/unordered/rehash_tests.cpp
+++ b/test/unordered/rehash_tests.cpp
@@ -16,8 +16,7 @@
 #include "../helpers/metafunctions.hpp"
 #include "../objects/test.hpp"
 
-namespace rehash_tests
-{
+namespace rehash_tests {
 
 test::seed_t initialize_seed(2974);
 
@@ -25,12 +24,11 @@ template <class X>
 bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
 {
     return static_cast<double>(x.bucket_count()) >=
-        static_cast<double>(x.size()) / x.max_load_factor() &&
-        x.bucket_count() >= n;
+               static_cast<double>(x.size()) / x.max_load_factor() &&
+           x.bucket_count() >= n;
 }
 
-template <class X>
-void rehash_empty_test1(X*)
+template <class X> void rehash_empty_test1(X*)
 {
     X x;
 
@@ -44,8 +42,7 @@ void rehash_empty_test1(X*)
     BOOST_TEST(postcondition(x, 10000000));
 }
 
-template <class X>
-void rehash_empty_test2(X*, test::random_generator generator)
+template <class X> void rehash_empty_test2(X*, test::random_generator generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -60,14 +57,13 @@ void rehash_empty_test2(X*, test::random_generator generator)
     tracker.compare(x);
 
     BOOST_TEST(postcondition(x, 10000));
-    
+
     x.rehash(10000000);
     tracker.compare(x);
     BOOST_TEST(postcondition(x, 10000000));
 }
 
-template <class X>
-void rehash_empty_test3(X*, test::random_generator generator)
+template <class X> void rehash_empty_test3(X*, test::random_generator generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -84,31 +80,33 @@ void rehash_empty_test3(X*, test::random_generator generator)
     BOOST_TEST(postcondition(x, 0));
 }
 
-template <class X>
-void rehash_test1(X*, test::random_generator generator)
+template <class X> void rehash_test1(X*, test::random_generator generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
     tracker.insert_range(v.begin(), v.end());
     X x(v.begin(), v.end());
 
-    x.rehash(0); BOOST_TEST(postcondition(x, 0));
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
     tracker.compare(x);
 
     x.max_load_factor(0.25);
-    x.rehash(0); BOOST_TEST(postcondition(x, 0));
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
     tracker.compare(x);
 
     x.max_load_factor(50.0);
-    x.rehash(0); BOOST_TEST(postcondition(x, 0));
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
     tracker.compare(x);
 
-    x.rehash(1000); BOOST_TEST(postcondition(x, 1000));
+    x.rehash(1000);
+    BOOST_TEST(postcondition(x, 1000));
     tracker.compare(x);
 }
 
-template <class X>
-void reserve_empty_test1(X*)
+template <class X> void reserve_empty_test1(X*)
 {
     X x;
 
@@ -121,8 +119,7 @@ void reserve_empty_test1(X*)
     BOOST_TEST(x.bucket_count() >= 10000000);
 }
 
-template <class X>
-void reserve_empty_test2(X*)
+template <class X> void reserve_empty_test2(X*)
 {
     X x;
     x.max_load_factor(0.25);
@@ -136,21 +133,20 @@ void reserve_empty_test2(X*)
     BOOST_TEST(x.bucket_count() >= 40000000);
 }
 
-template <class X>
-void reserve_test1(X*, test::random_generator generator)
+template <class X> void reserve_test1(X*, test::random_generator generator)
 {
-    for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
-    {
-        for (std::size_t i = 1; i < 2000; i += i < 50 ? 1 : 13)
-        {
+    for (int random_mlf = 0; random_mlf < 2; ++random_mlf) {
+        for (std::size_t i = 1; i < 2000; i += i < 50 ? 1 : 13) {
             test::random_values<X> v(i, generator);
 
             test::ordered<X> tracker;
             tracker.insert_range(v.begin(), v.end());
 
             X x;
-            x.max_load_factor(random_mlf ?
-                static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
+            x.max_load_factor(
+                random_mlf
+                    ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
+                    : 1.0f);
             x.reserve(test::has_unique_keys<X>::value ? i : v.size());
 
             // Insert an element before the range insert, otherwise there are
@@ -168,28 +164,26 @@ void reserve_test1(X*, test::random_generator generator)
     }
 }
 
-template <class X>
-void reserve_test2(X*, test::random_generator generator)
+template <class X> void reserve_test2(X*, test::random_generator generator)
 {
-    for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
-    {
-        for (std::size_t i = 0; i < 2000; i += i < 50 ? 1 : 13)
-        {
+    for (int random_mlf = 0; random_mlf < 2; ++random_mlf) {
+        for (std::size_t i = 0; i < 2000; i += i < 50 ? 1 : 13) {
             test::random_values<X> v(i, generator);
 
             test::ordered<X> tracker;
             tracker.insert_range(v.begin(), v.end());
 
             X x;
-            x.max_load_factor(random_mlf ?
-                static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
+            x.max_load_factor(
+                random_mlf
+                    ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
+                    : 1.0f);
 
             x.reserve(test::has_unique_keys<X>::value ? i : v.size());
 
             std::size_t bucket_count = x.bucket_count();
             for (typename test::random_values<X>::iterator it = v.begin();
-                    it != v.end(); ++it)
-            {
+                 it != v.end(); ++it) {
                 x.insert(*it);
             }
 
@@ -200,11 +194,9 @@ void reserve_test2(X*, test::random_generator generator)
 }
 
 boost::unordered_set<int>* int_set_ptr;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset_ptr;
-boost::unordered_map<test::movable, test::movable,
-    test::hash, test::equal_to,
+boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_map_ptr;
 boost::unordered_multimap<int, int>* int_multimap_ptr;
 
@@ -213,35 +205,26 @@ using test::generate_collisions;
 using test::limited_range;
 
 UNORDERED_TEST(rehash_empty_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
 UNORDERED_TEST(rehash_empty_test2,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+                   (default_generator)(generate_collisions)(limited_range)))
 UNORDERED_TEST(rehash_empty_test3,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+                   (default_generator)(generate_collisions)(limited_range)))
 UNORDERED_TEST(rehash_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+                   (default_generator)(generate_collisions)(limited_range)))
 UNORDERED_TEST(reserve_empty_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
 UNORDERED_TEST(reserve_empty_test2,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
 UNORDERED_TEST(reserve_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+                   (default_generator)(generate_collisions)(limited_range)))
 UNORDERED_TEST(reserve_test2,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/simple_tests.cpp b/test/unordered/simple_tests.cpp
index 940b031e..05d5523d 100644
--- a/test/unordered/simple_tests.cpp
+++ b/test/unordered/simple_tests.cpp
@@ -17,8 +17,7 @@
 #include <algorithm>
 #include "../helpers/equivalent.hpp"
 
-template <class X>
-void simple_test(X const& a)
+template <class X> void simple_test(X const& a)
 {
     test::unordered_equivalence_tester<X> equivalent(a);
 
@@ -74,9 +73,8 @@ void simple_test(X const& a)
     }
 
     {
-        BOOST_TEST(a.size() ==
-            static_cast<BOOST_DEDUCED_TYPENAME X::size_type>(
-                std::distance(a.begin(), a.end())));
+        BOOST_TEST(a.size() == static_cast<BOOST_DEDUCED_TYPENAME X::size_type>(
+                                   std::distance(a.begin(), a.end())));
     }
 
     {
@@ -95,38 +93,40 @@ UNORDERED_AUTO_TEST(simple_tests)
     using namespace std;
     srand(14878);
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout << "Test unordered_set.\n";
     boost::unordered_set<int> set;
     simple_test(set);
 
-    set.insert(1); set.insert(2); set.insert(1456);
+    set.insert(1);
+    set.insert(2);
+    set.insert(1456);
     simple_test(set);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout << "Test unordered_multiset.\n";
     boost::unordered_multiset<int> multiset;
     simple_test(multiset);
-    
-    for(int i1 = 0; i1 < 1000; ++i1) {
+
+    for (int i1 = 0; i1 < 1000; ++i1) {
         int count = rand() % 10, index = rand();
-        for(int j = 0; j < count; ++j)
+        for (int j = 0; j < count; ++j)
             multiset.insert(index);
     }
     simple_test(multiset);
-    
-    std::cout<<"Test unordered_map.\n";
+
+    std::cout << "Test unordered_map.\n";
     boost::unordered_map<int, int> map;
 
-    for(int i2 = 0; i2 < 1000; ++i2) {
+    for (int i2 = 0; i2 < 1000; ++i2) {
         map.insert(std::pair<const int, int>(rand(), rand()));
     }
     simple_test(map);
 
-    std::cout<<"Test unordered_multimap.\n";
+    std::cout << "Test unordered_multimap.\n";
     boost::unordered_multimap<int, int> multimap;
 
-    for(int i3 = 0; i3 < 1000; ++i3) {
+    for (int i3 = 0; i3 < 1000; ++i3) {
         int count = rand() % 10, index = rand();
-        for(int j = 0; j < count; ++j)
+        for (int j = 0; j < count; ++j)
             multimap.insert(std::pair<const int, int>(index, rand()));
     }
     simple_test(multimap);
diff --git a/test/unordered/swap_tests.cpp b/test/unordered/swap_tests.cpp
index 93a8f583..9c6e4656 100644
--- a/test/unordered/swap_tests.cpp
+++ b/test/unordered/swap_tests.cpp
@@ -21,16 +21,14 @@
 #include "../helpers/invariants.hpp"
 
 #if defined(BOOST_MSVC)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 #endif
 
-namespace swap_tests
-{
+namespace swap_tests {
 
 test::seed_t initialize_seed(783472);
 
-template <class X>
-void swap_test_impl(X& x1, X& x2)
+template <class X> void swap_test_impl(X& x1, X& x2)
 {
     test::ordered<X> tracker1 = test::create_ordered(x1);
     test::ordered<X> tracker2 = test::create_ordered(x2);
@@ -41,8 +39,7 @@ void swap_test_impl(X& x1, X& x2)
     tracker2.compare(x1);
 }
 
-template <class X>
-void swap_tests1(X*, test::random_generator generator)
+template <class X> void swap_tests1(X*, test::random_generator generator)
 {
     {
         test::check_instances check_;
@@ -54,7 +51,7 @@ void swap_tests1(X*, test::random_generator generator)
     {
         test::check_instances check_;
 
-        X x,y;
+        X x, y;
         swap_test_impl(x, y);
     }
 
@@ -77,8 +74,7 @@ void swap_tests1(X*, test::random_generator generator)
     }
 }
 
-template <class X>
-void swap_tests2(X* ptr, test::random_generator generator)
+template <class X> void swap_tests2(X* ptr, test::random_generator generator)
 {
     swap_tests1(ptr, generator);
 
@@ -123,8 +119,7 @@ void swap_tests2(X* ptr, test::random_generator generator)
         X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
 
         if (allocator_type::is_propagate_on_swap ||
-            x.get_allocator() == y.get_allocator())
-        {
+            x.get_allocator() == y.get_allocator()) {
             swap_test_impl(x, y);
         }
     }
@@ -141,67 +136,53 @@ void swap_tests2(X* ptr, test::random_generator generator)
             allocator_type(2));
 
         if (allocator_type::is_propagate_on_swap ||
-            x.get_allocator() == y.get_allocator())
-        {
+            x.get_allocator() == y.get_allocator()) {
             swap_test_impl(x, y);
             swap_test_impl(x, y);
         }
     }
 }
 
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        std::allocator<test::object> >* test_map_std_alloc;
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_multimap;
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_set_prop_swap;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_multiset_prop_swap;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_map_prop_swap;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_multimap_prop_swap;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_set_no_prop_swap;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_multiset_no_prop_swap;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_map_no_prop_swap;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_multimap_no_prop_swap;
 
-template <typename T>
-bool is_propagate(T*)
+template <typename T> bool is_propagate(T*)
 {
     return T::allocator_type::is_propagate_on_swap;
 }
@@ -217,22 +198,19 @@ UNORDERED_AUTO_TEST(check_traits)
     BOOST_TEST(!is_propagate(test_set_no_prop_swap));
 }
 
-UNORDERED_TEST(swap_tests1, (
-        (test_map_std_alloc)
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
-        (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
-UNORDERED_TEST(swap_tests2, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
-        (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(swap_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+        test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(
+        test_multimap_prop_swap)(test_set_no_prop_swap)(
+        test_multiset_no_prop_swap)(test_map_no_prop_swap)(
+        test_multimap_no_prop_swap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 
+UNORDERED_TEST(swap_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_swap)(
+        test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)(
+        test_set_no_prop_swap)(test_multiset_no_prop_swap)(
+        test_map_no_prop_swap)(test_multimap_no_prop_swap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 RUN_TESTS()
diff --git a/test/unordered/unnecessary_copy_tests.cpp b/test/unordered/unnecessary_copy_tests.cpp
index 5978b1a2..7d17dfcf 100644
--- a/test/unordered/unnecessary_copy_tests.cpp
+++ b/test/unordered/unnecessary_copy_tests.cpp
@@ -13,101 +13,100 @@
 #include <iostream>
 #include "../helpers/test.hpp"
 
-namespace unnecessary_copy_tests
+namespace unnecessary_copy_tests {
+struct count_copies
 {
-    struct count_copies
+  private:
+    BOOST_COPYABLE_AND_MOVABLE(count_copies)
+  public:
+    static int copies;
+    static int moves;
+    static int id_count;
+
+    count_copies() : tag_(0), id_(++id_count)
     {
-    private:
-        BOOST_COPYABLE_AND_MOVABLE(count_copies)
-    public:
-        static int copies;
-        static int moves;
-        static int id_count;
-
-        count_copies() : tag_(0), id_(++id_count) {
-            ++copies;
-            trace_op("Default construct");
-        }
-
-        explicit count_copies(int tag) : tag_(tag), id_(++id_count) {
-            ++copies;
-            trace_op("Tag construct");
-        }
-
-        // This bizarre constructor is an attempt to confuse emplace.
-        //
-        // unordered_map<count_copies, count_copies> x:
-        // x.emplace(count_copies(1), count_copies(2));
-        // x.emplace(count_copies(1), count_copies(2), count_copies(3));
-        //
-        // The first emplace should use the single argument constructor twice.
-        // The second emplace should use the single argument contructor for
-        // the key, and this constructor for the value.
-        count_copies(count_copies const&, count_copies const& x)
-            : tag_(x.tag_), id_(++id_count)
-        {
-            ++copies;
-            trace_op("Pair construct");
-        }
-
-        count_copies(count_copies const& x) : tag_(x.tag_), id_(++id_count)
-        {
-            ++copies;
-            trace_op("Copy construct");
-        }
-
-        count_copies(BOOST_RV_REF(count_copies) x) :
-            tag_(x.tag_), id_(++id_count)
-        {
-            x.tag_ = -1; ++moves;
-            trace_op("Move construct");
-        }
-
-        count_copies& operator=(BOOST_COPY_ASSIGN_REF(count_copies) p) // Copy assignment
-        {
-            tag_ = p.tag_;
-            ++copies;
-            trace_op("Copy assign");
-            return *this;
-        }
-
-        count_copies& operator=(BOOST_RV_REF(count_copies) p) //Move assignment
-        {
-            tag_ = p.tag_;
-            ++moves;
-            trace_op("Move assign");
-            return *this;
-        }
-
-        ~count_copies() {
-            trace_op("Destruct");
-        }
-        
-        void trace_op(char const* str) {
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM << str << ": " << tag_
-                << " (#" << id_ << ")" <<std::endl;
-        }
-
-        int tag_;
-        int id_;
-    };
-
-    bool operator==(count_copies const& x, count_copies const& y) {
-        return x.tag_ == y.tag_;
+        ++copies;
+        trace_op("Default construct");
     }
 
-    template <class T>
-    T source() {
-        return T();
+    explicit count_copies(int tag) : tag_(tag), id_(++id_count)
+    {
+        ++copies;
+        trace_op("Tag construct");
     }
 
-    void reset() {
-        count_copies::copies = 0;
-        count_copies::moves = 0;
-
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << "\nReset\n" << std::endl;
+    // This bizarre constructor is an attempt to confuse emplace.
+    //
+    // unordered_map<count_copies, count_copies> x:
+    // x.emplace(count_copies(1), count_copies(2));
+    // x.emplace(count_copies(1), count_copies(2), count_copies(3));
+    //
+    // The first emplace should use the single argument constructor twice.
+    // The second emplace should use the single argument contructor for
+    // the key, and this constructor for the value.
+    count_copies(count_copies const&, count_copies const& x)
+        : tag_(x.tag_), id_(++id_count)
+    {
+        ++copies;
+        trace_op("Pair construct");
     }
+
+    count_copies(count_copies const& x) : tag_(x.tag_), id_(++id_count)
+    {
+        ++copies;
+        trace_op("Copy construct");
+    }
+
+    count_copies(BOOST_RV_REF(count_copies) x) : tag_(x.tag_), id_(++id_count)
+    {
+        x.tag_ = -1;
+        ++moves;
+        trace_op("Move construct");
+    }
+
+    count_copies& operator=(
+        BOOST_COPY_ASSIGN_REF(count_copies) p) // Copy assignment
+    {
+        tag_ = p.tag_;
+        ++copies;
+        trace_op("Copy assign");
+        return *this;
+    }
+
+    count_copies& operator=(BOOST_RV_REF(count_copies) p) // Move assignment
+    {
+        tag_ = p.tag_;
+        ++moves;
+        trace_op("Move assign");
+        return *this;
+    }
+
+    ~count_copies() { trace_op("Destruct"); }
+
+    void trace_op(char const* str)
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << str << ": " << tag_ << " (#" << id_
+                                       << ")" << std::endl;
+    }
+
+    int tag_;
+    int id_;
+};
+
+bool operator==(count_copies const& x, count_copies const& y)
+{
+    return x.tag_ == y.tag_;
+}
+
+template <class T> T source() { return T(); }
+
+void reset()
+{
+    count_copies::copies = 0;
+    count_copies::moves = 0;
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\nReset\n" << std::endl;
+}
 }
 
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
@@ -116,9 +115,10 @@ namespace boost
 namespace unnecessary_copy_tests
 #endif
 {
-    std::size_t hash_value(unnecessary_copy_tests::count_copies const& x) {
-        return static_cast<std::size_t>(x.tag_);
-    }
+std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
+{
+    return static_cast<std::size_t>(x.tag_);
+}
 }
 
 // Boost.Move doesn't seem to work very well on this compiler.
@@ -135,395 +135,408 @@ namespace unnecessary_copy_tests
 #define EXTRA_CONSTRUCT_COST 0
 #endif
 
-#define COPY_COUNT(n)                                                       \
-    if(::unnecessary_copy_tests::count_copies::copies != n) {               \
-        BOOST_ERROR("Wrong number of copies.");                             \
-        std::cerr                                                           \
-            << "Number of copies: "                                         \
-            << ::unnecessary_copy_tests::count_copies::copies               \
-            << " expecting: " << n << std::endl;                            \
+#define COPY_COUNT(n)                                                          \
+    if (::unnecessary_copy_tests::count_copies::copies != n) {                 \
+        BOOST_ERROR("Wrong number of copies.");                                \
+        std::cerr << "Number of copies: "                                      \
+                  << ::unnecessary_copy_tests::count_copies::copies            \
+                  << " expecting: " << n << std::endl;                         \
     }
-#define MOVE_COUNT(n)                                                       \
-    if(::unnecessary_copy_tests::count_copies::moves != n) {                \
-        BOOST_ERROR("Wrong number of moves.");                              \
-        std::cerr                                                           \
-            << "Number of moves: "                                          \
-            << ::unnecessary_copy_tests::count_copies::moves                \
-            << " expecting: " <<n << std::endl;                             \
+#define MOVE_COUNT(n)                                                          \
+    if (::unnecessary_copy_tests::count_copies::moves != n) {                  \
+        BOOST_ERROR("Wrong number of moves.");                                 \
+        std::cerr << "Number of moves: "                                       \
+                  << ::unnecessary_copy_tests::count_copies::moves             \
+                  << " expecting: " << n << std::endl;                         \
     }
-#define COPY_COUNT_RANGE(a, b)                                              \
-    if(::unnecessary_copy_tests::count_copies::copies < a ||                \
-            ::unnecessary_copy_tests::count_copies::copies > b) {           \
-        BOOST_ERROR("Wrong number of copies.");                             \
-        std::cerr                                                           \
-            << "Number of copies: "                                         \
-            << ::unnecessary_copy_tests::count_copies::copies               \
-            << " expecting: [" << a << ", " << b << "]" << std::endl;       \
+#define COPY_COUNT_RANGE(a, b)                                                 \
+    if (::unnecessary_copy_tests::count_copies::copies < a ||                  \
+        ::unnecessary_copy_tests::count_copies::copies > b) {                  \
+        BOOST_ERROR("Wrong number of copies.");                                \
+        std::cerr << "Number of copies: "                                      \
+                  << ::unnecessary_copy_tests::count_copies::copies            \
+                  << " expecting: [" << a << ", " << b << "]" << std::endl;    \
     }
-#define MOVE_COUNT_RANGE(a, b)                                              \
-    if(::unnecessary_copy_tests::count_copies::moves < a ||                 \
-            ::unnecessary_copy_tests::count_copies::moves > b) {            \
-        BOOST_ERROR("Wrong number of moves.");                              \
-        std::cerr                                                           \
-            << "Number of moves: "                                          \
-            << ::unnecessary_copy_tests::count_copies::moves                \
-            << " expecting: [" << a << ", " << b << "]" << std::endl;       \
+#define MOVE_COUNT_RANGE(a, b)                                                 \
+    if (::unnecessary_copy_tests::count_copies::moves < a ||                   \
+        ::unnecessary_copy_tests::count_copies::moves > b) {                   \
+        BOOST_ERROR("Wrong number of moves.");                                 \
+        std::cerr << "Number of moves: "                                       \
+                  << ::unnecessary_copy_tests::count_copies::moves             \
+                  << " expecting: [" << a << ", " << b << "]" << std::endl;    \
     }
-#define COPY_COUNT_EXTRA(a, b)                                              \
-    COPY_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
-#define MOVE_COUNT_EXTRA(a, b)                                              \
-    MOVE_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
+#define COPY_COUNT_EXTRA(a, b) COPY_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
+#define MOVE_COUNT_EXTRA(a, b) MOVE_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
 
-namespace unnecessary_copy_tests
+namespace unnecessary_copy_tests {
+int count_copies::copies;
+int count_copies::moves;
+int count_copies::id_count;
+
+template <class T> void unnecessary_copy_insert_test(T*)
 {
-    int count_copies::copies;
-    int count_copies::moves;
-    int count_copies::id_count;
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    reset();
+    x.insert(a);
+    COPY_COUNT(1);
+}
 
-    template <class T>
-    void unnecessary_copy_insert_test(T*)
-    {
-        T x;
-        BOOST_DEDUCED_TYPENAME T::value_type a;
-        reset();
-        x.insert(a);
-        COPY_COUNT(1);
-    }
+boost::unordered_set<count_copies>* set;
+boost::unordered_multiset<count_copies>* multiset;
+boost::unordered_map<int, count_copies>* map;
+boost::unordered_multimap<int, count_copies>* multimap;
 
-    boost::unordered_set<count_copies>* set;
-    boost::unordered_multiset<count_copies>* multiset;
-    boost::unordered_map<int, count_copies>* map;
-    boost::unordered_multimap<int, count_copies>* multimap;
+UNORDERED_TEST(unnecessary_copy_insert_test, ((set)(multiset)(map)(multimap)))
 
-    UNORDERED_TEST(unnecessary_copy_insert_test,
-            ((set)(multiset)(map)(multimap)))
+template <class T> void unnecessary_copy_emplace_test(T*)
+{
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    x.emplace(a);
+    COPY_COUNT(2);
+}
 
-    template <class T>
-    void unnecessary_copy_emplace_test(T*)
-    {
-        reset();
-        T x;
-        BOOST_DEDUCED_TYPENAME T::value_type a;
-        COPY_COUNT(1);
-        x.emplace(a);
-        COPY_COUNT(2);
-    }
-
-    template <class T>
-    void unnecessary_copy_emplace_rvalue_test(T*)
-    {
-        reset();
-        T x;
-        x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
+template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
+{
+    reset();
+    T x;
+    x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        COPY_COUNT(1);
+    COPY_COUNT(1);
 #else
-        COPY_COUNT(2);
+    COPY_COUNT(2);
 #endif
-    }
+}
 
-    UNORDERED_TEST(unnecessary_copy_emplace_test,
-            ((set)(multiset)(map)(multimap)))
-    UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
-            ((set)(multiset)(map)(multimap)))
+UNORDERED_TEST(unnecessary_copy_emplace_test, ((set)(multiset)(map)(multimap)))
+UNORDERED_TEST(
+    unnecessary_copy_emplace_rvalue_test, ((set)(multiset)(map)(multimap)))
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <class T>
-    void unnecessary_copy_emplace_std_move_test(T*)
-    {
-        reset();
-        T x;
-        BOOST_DEDUCED_TYPENAME T::value_type a;
-        COPY_COUNT(1); MOVE_COUNT(0);
-        x.emplace(std::move(a));
-        COPY_COUNT(1); MOVE_COUNT(1);
-    }
+template <class T> void unnecessary_copy_emplace_std_move_test(T*)
+{
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+    x.emplace(std::move(a));
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
+}
 
-    UNORDERED_TEST(unnecessary_copy_emplace_std_move_test,
-            ((set)(multiset)(map)(multimap)))
+UNORDERED_TEST(
+    unnecessary_copy_emplace_std_move_test, ((set)(multiset)(map)(multimap)))
 #endif
 
-    template <class T>
-    void unnecessary_copy_emplace_boost_move_test(T*)
-    {
-        reset();
-        T x;
-        BOOST_DEDUCED_TYPENAME T::value_type a;
-        COPY_COUNT(1); MOVE_COUNT_EXTRA(0, 1);
-        x.emplace(boost::move(a));
+template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
+{
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT_EXTRA(0, 1);
+    x.emplace(boost::move(a));
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        COPY_COUNT(1); MOVE_COUNT(1);
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
 #else
-        // Since std::pair isn't movable, move only works for sets.
-        COPY_COUNT_RANGE(1, 2); MOVE_COUNT_RANGE(0, 1);
+    // Since std::pair isn't movable, move only works for sets.
+    COPY_COUNT_RANGE(1, 2);
+    MOVE_COUNT_RANGE(0, 1);
 #endif
-    }
+}
 
-    UNORDERED_TEST(unnecessary_copy_emplace_boost_move_test,
-            ((set)(multiset)(map)(multimap)))
+UNORDERED_TEST(
+    unnecessary_copy_emplace_boost_move_test, ((set)(multiset)(map)(multimap)))
 
-    template <class T>
-    void unnecessary_copy_emplace_boost_move_set_test(T*)
-    {
-        reset();
-        T x;
-        BOOST_DEDUCED_TYPENAME T::value_type a;
-        COPY_COUNT(1); MOVE_COUNT(0);
-        x.emplace(boost::move(a));
-        COPY_COUNT(1); MOVE_COUNT(1);
-    }
+template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
+{
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+    x.emplace(boost::move(a));
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
+}
 
-    UNORDERED_TEST(unnecessary_copy_emplace_boost_move_set_test,
-            ((set)(multiset)))
+UNORDERED_TEST(unnecessary_copy_emplace_boost_move_set_test, ((set)(multiset)))
 
-    template <class T>
-    void unnecessary_copy_emplace_boost_move_map_test(T*)
-    {
-        reset();
-        T x;
-        COPY_COUNT(0); MOVE_COUNT(0);
-        BOOST_DEDUCED_TYPENAME T::value_type a;
-        COPY_COUNT(1); MOVE_COUNT_EXTRA(0, 1);
-        x.emplace(boost::move(a));
+template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
+{
+    reset();
+    T x;
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT_EXTRA(0, 1);
+    x.emplace(boost::move(a));
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        COPY_COUNT(2); MOVE_COUNT_EXTRA(0, 1);
+    COPY_COUNT(2);
+    MOVE_COUNT_EXTRA(0, 1);
 #else
-        COPY_COUNT(1); MOVE_COUNT(1);
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
 #endif
-    }
+}
 
-    UNORDERED_TEST(unnecessary_copy_emplace_boost_move_map_test,
-            ((map)(multimap)))
+UNORDERED_TEST(unnecessary_copy_emplace_boost_move_map_test, ((map)(multimap)))
 
-    UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
-    {
-        // When calling 'source' the object is moved on some compilers, but not
-        // others. So count that here to adjust later.
+UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
+{
+    // When calling 'source' the object is moved on some compilers, but not
+    // others. So count that here to adjust later.
 
-        reset();
-        source<count_copies>();
-        int source_cost = ::unnecessary_copy_tests::count_copies::moves;
+    reset();
+    source<count_copies>();
+    int source_cost = ::unnecessary_copy_tests::count_copies::moves;
 
-        //
+    //
 
-        reset();
-        boost::unordered_set<count_copies> x;
-        count_copies a;
-        x.insert(a);
-        COPY_COUNT(2); MOVE_COUNT(0);
+    reset();
+    boost::unordered_set<count_copies> x;
+    count_copies a;
+    x.insert(a);
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
 
-        //
-        // 0 arguments
-        // 
+//
+// 0 arguments
+//
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-        // The container will have to create a copy in order to compare with
-        // the existing element.
-        reset();
-        x.emplace();
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
+    // The container will have to create a copy in order to compare with
+    // the existing element.
+    reset();
+    x.emplace();
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) ||                             \
     !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        // source_cost doesn't make much sense here, but it seems to fit.
-        COPY_COUNT(1); MOVE_COUNT(source_cost);
+    // source_cost doesn't make much sense here, but it seems to fit.
+    COPY_COUNT(1);
+    MOVE_COUNT(source_cost);
 #else
-        COPY_COUNT(1); MOVE_COUNT(1 + source_cost);
+    COPY_COUNT(1);
+    MOVE_COUNT(1 + source_cost);
 #endif
 #endif
 
-        //
-        // 1 argument
-        // 
+    //
+    // 1 argument
+    //
 
-        // Emplace should be able to tell that there already is an element
-        // without creating a new one.
-        reset();
-        x.emplace(a);
-        COPY_COUNT(0); MOVE_COUNT(0);
+    // Emplace should be able to tell that there already is an element
+    // without creating a new one.
+    reset();
+    x.emplace(a);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 
-        // A new object is created by source, but it shouldn't be moved or
-        // copied.
-        reset();
-        x.emplace(source<count_copies>());
-        COPY_COUNT(1); MOVE_COUNT(source_cost);
+    // A new object is created by source, but it shouldn't be moved or
+    // copied.
+    reset();
+    x.emplace(source<count_copies>());
+    COPY_COUNT(1);
+    MOVE_COUNT(source_cost);
 
-        // No move should take place.
-        reset();
-        x.emplace(boost::move(a));
+    // No move should take place.
+    reset();
+    x.emplace(boost::move(a));
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        COPY_COUNT(0); MOVE_COUNT(0);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 #else
-        COPY_COUNT(0); MOVE_COUNT(1);
+    COPY_COUNT(0);
+    MOVE_COUNT(1);
 #endif
 
-        // Use a new value for cases where a did get moved...
-        count_copies b;
+    // Use a new value for cases where a did get moved...
+    count_copies b;
 
-        // The container will have to create a copy in order to compare with
-        // the existing element.
-        reset();
-        x.emplace(b.tag_);
-        COPY_COUNT(1); MOVE_COUNT(0);
+    // The container will have to create a copy in order to compare with
+    // the existing element.
+    reset();
+    x.emplace(b.tag_);
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
 
-        //
-        // 2 arguments
-        //
+    //
+    // 2 arguments
+    //
 
-        // The container will have to create b copy in order to compare with
-        // the existing element.
-        //
-        // Note to self: If copy_count == 0 it's an error not an optimization.
-        // TODO: Devise a better test.
+    // The container will have to create b copy in order to compare with
+    // the existing element.
+    //
+    // Note to self: If copy_count == 0 it's an error not an optimization.
+    // TODO: Devise a better test.
 
-        reset();
+    reset();
 
-        x.emplace(b, b);
-        COPY_COUNT(1); MOVE_COUNT(0);
-    }
+    x.emplace(b, b);
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+}
 
-    UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
-    {
-        // When calling 'source' the object is moved on some compilers, but not
-        // others. So count that here to adjust later.
+UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
+{
+    // When calling 'source' the object is moved on some compilers, but not
+    // others. So count that here to adjust later.
 
-        reset();
-        source<count_copies>();
-        int source_cost = ::unnecessary_copy_tests::count_copies::moves;
+    reset();
+    source<count_copies>();
+    int source_cost = ::unnecessary_copy_tests::count_copies::moves;
 
-        reset();
-        source<std::pair<count_copies, count_copies> >();
-        int source_pair_cost = ::unnecessary_copy_tests::count_copies::moves;
+    reset();
+    source<std::pair<count_copies, count_copies> >();
+    int source_pair_cost = ::unnecessary_copy_tests::count_copies::moves;
 
-        //
+    //
 
-        reset();
-        boost::unordered_map<count_copies, count_copies> x;
-        // TODO: Run tests for pairs without const etc.
-        std::pair<count_copies const, count_copies> a;
-        x.emplace(a);
-        COPY_COUNT_EXTRA(4, 1); MOVE_COUNT_EXTRA(0, 1);
+    reset();
+    boost::unordered_map<count_copies, count_copies> x;
+    // TODO: Run tests for pairs without const etc.
+    std::pair<count_copies const, count_copies> a;
+    x.emplace(a);
+    COPY_COUNT_EXTRA(4, 1);
+    MOVE_COUNT_EXTRA(0, 1);
 
-        //
-        // 0 arguments
-        //
+//
+// 0 arguments
+//
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-        // COPY_COUNT(1) would be okay here.
-        reset();
-        x.emplace();
-#   if BOOST_WORKAROUND(BOOST_MSVC, == 1700)
-        // This is a little odd, Visual C++ 11 seems to move the pair, which
-        // results in one copy (for the const key) and one move (for the
-        // non-const mapped value). Since 'emplace(boost::move(a))' (see below)
-        // has the normal result, it must be some odd consequence of how
-        // Visual C++ 11 handles calling move for default arguments.
-        COPY_COUNT(3); MOVE_COUNT(1);
-#   else
-        COPY_COUNT_EXTRA(2, 1); MOVE_COUNT_EXTRA(0, 1);
-#   endif
+    // COPY_COUNT(1) would be okay here.
+    reset();
+    x.emplace();
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1700)
+    // This is a little odd, Visual C++ 11 seems to move the pair, which
+    // results in one copy (for the const key) and one move (for the
+    // non-const mapped value). Since 'emplace(boost::move(a))' (see below)
+    // has the normal result, it must be some odd consequence of how
+    // Visual C++ 11 handles calling move for default arguments.
+    COPY_COUNT(3);
+    MOVE_COUNT(1);
+#else
+    COPY_COUNT_EXTRA(2, 1);
+    MOVE_COUNT_EXTRA(0, 1);
+#endif
 #endif
 
-        reset();
-        x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(),
-                boost::make_tuple());
-        COPY_COUNT(2); MOVE_COUNT(0);
+    reset();
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+        boost::make_tuple());
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
 
+    //
+    // 1 argument
+    //
 
-        //
-        // 1 argument
-        //
+    reset();
+    x.emplace(a);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 
-        reset();
-        x.emplace(a);
-        COPY_COUNT(0); MOVE_COUNT(0);
+    // A new object is created by source, but it shouldn't be moved or
+    // copied.
+    reset();
+    x.emplace(source<std::pair<count_copies, count_copies> >());
+    COPY_COUNT(2);
+    MOVE_COUNT(source_pair_cost);
 
-        // A new object is created by source, but it shouldn't be moved or
-        // copied.
-        reset();
-        x.emplace(source<std::pair<count_copies, count_copies> >());
-        COPY_COUNT(2); MOVE_COUNT(source_pair_cost);
-
-#if !(defined(__GNUC__) && __cplusplus < 199900L) && \
+#if !(defined(__GNUC__) && __cplusplus < 199900L) &&                           \
     !(defined(_MSC_VER) && _MSC_VER < 1600)
-        count_copies part;
-        reset();
-        std::pair<count_copies const&, count_copies const&> a_ref(part, part);
-        x.emplace(a_ref);
-        COPY_COUNT(2); MOVE_COUNT(0);
+    count_copies part;
+    reset();
+    std::pair<count_copies const&, count_copies const&> a_ref(part, part);
+    x.emplace(a_ref);
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
 
 #endif
 
-        // No move should take place.
-        // (since a is already in the container)
-        reset();
-        x.emplace(boost::move(a));
-        COPY_COUNT(0); MOVE_COUNT(0);
+    // No move should take place.
+    // (since a is already in the container)
+    reset();
+    x.emplace(boost::move(a));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 
-        //
-        // 2 arguments
-        //
+    //
+    // 2 arguments
+    //
 
-        std::pair<count_copies const, count_copies> b;
+    std::pair<count_copies const, count_copies> b;
 
-        reset();
-        x.emplace(b.first, b.second);
-        COPY_COUNT(0); MOVE_COUNT(0);
+    reset();
+    x.emplace(b.first, b.second);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 
-        reset();
-        x.emplace(source<count_copies>(), source<count_copies>());
-        COPY_COUNT(2); MOVE_COUNT(source_cost * 2);
+    reset();
+    x.emplace(source<count_copies>(), source<count_copies>());
+    COPY_COUNT(2);
+    MOVE_COUNT(source_cost * 2);
 
-        // source<count_copies> creates a single copy.
-        reset();
-        x.emplace(b.first, source<count_copies>());
-        COPY_COUNT(1); MOVE_COUNT(source_cost);
+    // source<count_copies> creates a single copy.
+    reset();
+    x.emplace(b.first, source<count_copies>());
+    COPY_COUNT(1);
+    MOVE_COUNT(source_cost);
 
-        reset();
-        x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
-        COPY_COUNT(2); MOVE_COUNT(0);        
+    reset();
+    x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
+
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+        boost::make_tuple(boost::ref(b.first)),
+        boost::make_tuple(boost::ref(b.second)));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 
-        reset();
-        x.emplace(boost::unordered::piecewise_construct,
-                boost::make_tuple(boost::ref(b.first)),
-                boost::make_tuple(boost::ref(b.second)));
-        COPY_COUNT(0); MOVE_COUNT(0);
-        
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) || defined(BOOST_HAS_TR1_TUPLE)
 
-        reset();
-        x.emplace(boost::unordered::piecewise_construct,
-                std::make_tuple(std::ref(b.first)),
-                std::make_tuple(std::ref(b.second)));
-        COPY_COUNT(0); MOVE_COUNT(0);
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+        std::make_tuple(std::ref(b.first)),
+        std::make_tuple(std::ref(b.second)));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 
-        std::pair<count_copies const, count_copies> move_source_trial;
-        reset();
-        std::make_tuple(std::move(move_source_trial.first));
-        std::make_tuple(std::move(move_source_trial.second));
-        int tuple_move_cost = ::unnecessary_copy_tests::count_copies::moves;
-        int tuple_copy_cost = ::unnecessary_copy_tests::count_copies::copies;
+    std::pair<count_copies const, count_copies> move_source_trial;
+    reset();
+    std::make_tuple(std::move(move_source_trial.first));
+    std::make_tuple(std::move(move_source_trial.second));
+    int tuple_move_cost = ::unnecessary_copy_tests::count_copies::moves;
+    int tuple_copy_cost = ::unnecessary_copy_tests::count_copies::copies;
 
-        std::pair<count_copies const, count_copies> move_source;
-        reset();
-        x.emplace(boost::unordered::piecewise_construct,
-                std::make_tuple(std::move(move_source.first)),
-                std::make_tuple(std::move(move_source.second)));
-        COPY_COUNT(tuple_copy_cost);
-        MOVE_COUNT(tuple_move_cost);
+    std::pair<count_copies const, count_copies> move_source;
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+        std::make_tuple(std::move(move_source.first)),
+        std::make_tuple(std::move(move_source.second)));
+    COPY_COUNT(tuple_copy_cost);
+    MOVE_COUNT(tuple_move_cost);
 
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && \
-    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ < 6) && \
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) &&                                      \
+    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ < 6) &&             \
     !(defined(BOOST_MSVC) && BOOST_MSVC < 1700)
-        reset();
-        x.emplace(boost::unordered::piecewise_construct,
-                std::forward_as_tuple(b.first),
-                std::forward_as_tuple(b.second));
-        COPY_COUNT(0); MOVE_COUNT(0);
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+        std::forward_as_tuple(b.first), std::forward_as_tuple(b.second));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
 #endif
 
 #endif
-
-    }
+}
 }
 
 RUN_TESTS()