diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..3ecfb3f0
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,7 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+
+[*.?pp]
+indent_size = 2
diff --git a/_clang-format b/_clang-format
index 5ca4ced9..b1522cf4 100644
--- a/_clang-format
+++ b/_clang-format
@@ -11,8 +11,9 @@ BasedOnStyle: LLVM
 
 # Basic settings
 ColumnLimit: 80
-ContinuationIndentWidth: 4
-IndentWidth: 4
+NamespaceIndentation: All
+ContinuationIndentWidth: 2
+IndentWidth: 2
 UseTab: Never
 Language: Cpp
 Standard: Cpp03
diff --git a/include/boost/unordered/detail/fwd.hpp b/include/boost/unordered/detail/fwd.hpp
index 2e0c6307..7f25cfc1 100644
--- a/include/boost/unordered/detail/fwd.hpp
+++ b/include/boost/unordered/detail/fwd.hpp
@@ -43,17 +43,17 @@
 #endif
 
 namespace boost {
-namespace unordered {
+  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
-}
+  }
 }
 
 #endif
diff --git a/include/boost/unordered/detail/implementation.hpp b/include/boost/unordered/detail/implementation.hpp
index 5750a4c6..5b6b23d3 100644
--- a/include/boost/unordered/detail/implementation.hpp
+++ b/include/boost/unordered/detail/implementation.hpp
@@ -144,7 +144,7 @@
 // Otherwise allocators aren't used for construction/destruction
 
 #if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT &&                                \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && BOOST_UNORDERED_TUPLE_ARGS
+  !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && BOOST_UNORDERED_TUPLE_ARGS
 #if BOOST_COMP_SUNPRO && BOOST_LIB_STD_GNU
 // Sun C++ std::pair piecewise construction doesn't seem to be exception safe.
 // (At least for Sun C++ 12.5 using libstdc++).
@@ -153,7 +153,7 @@
 // Piecewise construction in GCC 4.6 doesn't work for uncopyable types.
 #define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
 #elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0 &&                             \
-    !defined(BOOST_NO_SFINAE_EXPR)
+  !defined(BOOST_NO_SFINAE_EXPR)
 #define BOOST_UNORDERED_CXX11_CONSTRUCTION 1
 #elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
 #define BOOST_UNORDERED_CXX11_CONSTRUCTION 1
@@ -177,7 +177,7 @@
 // Wrapper around various depreaction attributes.
 
 #if defined(__has_cpp_attribute) &&                                            \
-    (!defined(__cplusplus) || __cplusplus >= 201402)
+  (!defined(__cplusplus) || __cplusplus >= 201402)
 #if __has_cpp_attribute(deprecated) && !defined(BOOST_UNORDERED_DEPRECATED)
 #define BOOST_UNORDERED_DEPRECATED(msg) [[deprecated(msg)]]
 #endif
@@ -196,71 +196,73 @@
 #endif
 
 namespace boost {
-namespace unordered {
-namespace iterator_detail {
-template <typename Node> struct iterator;
-template <typename Node> struct c_iterator;
-template <typename Node> struct l_iterator;
-template <typename Node> struct cl_iterator;
-}
-}
+  namespace unordered {
+    namespace iterator_detail {
+      template <typename Node> struct iterator;
+      template <typename Node> struct c_iterator;
+      template <typename Node> struct l_iterator;
+      template <typename Node> struct cl_iterator;
+    }
+  }
 }
 
 namespace boost {
-namespace unordered {
-namespace detail {
+  namespace unordered {
+    namespace detail {
 
-template <typename Types> struct table;
-template <typename NodePointer> struct bucket;
-struct ptr_bucket;
+      template <typename Types> struct table;
+      template <typename NodePointer> struct bucket;
+      struct ptr_bucket;
 
-template <typename A, typename T> struct node;
-template <typename T> struct ptr_node;
+      template <typename A, typename T> struct node;
+      template <typename T> struct ptr_node;
 
-static const float minimum_max_load_factor = 1e-3f;
-static const std::size_t default_bucket_count = 11;
+      static const float minimum_max_load_factor = 1e-3f;
+      static const std::size_t default_bucket_count = 11;
 
-struct move_tag
-{
-};
+      struct move_tag
+      {
+      };
 
-struct empty_emplace
-{
-};
+      struct empty_emplace
+      {
+      };
 
-struct no_key
-{
-    no_key() {}
-    template <class T> no_key(T const&) {}
-};
+      struct no_key
+      {
+        no_key() {}
+        template <class T> no_key(T const&) {}
+      };
 
-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
@@ -274,194 +276,198 @@ struct disable_if_forward
     (1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul) \
     (50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \
     (1610612741ul)(3221225473ul)(4294967291ul)
-// clang-format on
+      // 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 !BOOST_UNORDERED_SUN_WORKAROUNDS1
-    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 !BOOST_UNORDERED_SUN_WORKAROUNDS1
-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;
-}
+      // 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
+      ////////////////////////////////////////////////////////////////////////////
+      // 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, 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 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);
-}
+      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
+      ////////////////////////////////////////////////////////////////////////////
+      // 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)) {}
+      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; }
-};
+        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)) {}
+      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_;
-};
+        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>,
+      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;
+      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;
+        typedef T1 first_type;
+        typedef T2 second_type;
 
-    first_type& first() { return static_cast<base1*>(this)->get(); }
+        first_type& first() { return static_cast<base1*>(this)->get(); }
 
-    first_type const& first() const
-    {
-        return static_cast<base1 const*>(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& second() { return static_cast<base2*>(this)->get(); }
 
-    second_type const& second() const
-    {
-        return static_cast<base2 const*>(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)
-    {
-    }
+        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 const& x) : base1(x.first()), base2(x.second()) {}
 
-    compressed(compressed& x, move_tag m)
-        : base1(x.first(), m), base2(x.second(), m)
-    {
-    }
+        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 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 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());
-    }
+        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&);
+      };
 
-////////////////////////////////////////////////////////////////////////////
-// pair_traits
-//
-// Used to get the types from a pair without instantiating it.
+      ////////////////////////////////////////////////////////////////////////////
+      // pair_traits
+      //
+      // Used to get the types from a pair without instantiating it.
 
-template <typename Pair> struct pair_traits
-{
-    typedef typename Pair::first_type first_type;
-    typedef typename Pair::second_type second_type;
-};
+      template <typename Pair> struct pair_traits
+      {
+        typedef typename Pair::first_type first_type;
+        typedef typename Pair::second_type second_type;
+      };
 
-template <typename T1, typename T2> struct pair_traits<std::pair<T1, T2> >
-{
-    typedef T1 first_type;
-    typedef T2 second_type;
-};
+      template <typename T1, typename T2> struct pair_traits<std::pair<T1, T2> >
+      {
+        typedef T1 first_type;
+        typedef T2 second_type;
+      };
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -471,75 +477,79 @@ template <typename T1, typename T2> struct pair_traits<std::pair<T1, T2> >
 // will be default-initialized.
 #endif
 
-////////////////////////////////////////////////////////////////////////////
-// 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&);
+      };
 
-// Get a pointer from a smart pointer, a bit simpler than pointer_traits
-// as we already know the pointer type that we want.
-template <typename T> struct pointer
-{
-    template <typename Ptr> static T* get(Ptr const& x)
-    {
-        return static_cast<T*>(x.operator->());
-    }
+      // Get a pointer from a smart pointer, a bit simpler than pointer_traits
+      // as we already know the pointer type that we want.
+      template <typename T> struct pointer
+      {
+        template <typename Ptr> static T* get(Ptr const& x)
+        {
+          return static_cast<T*>(x.operator->());
+        }
 
-    template <typename T2> static T* get(T2* x) { return static_cast<T*>(x); }
-};
+        template <typename T2> static T* get(T2* x)
+        {
+          return static_cast<T*>(x);
+        }
+      };
 
 ////////////////////////////////////////////////////////////////////////////
 // emplace_args
@@ -562,104 +572,102 @@ template <typename T> struct pointer
 #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);            \
-    BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, 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);                                                  \
-    BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, 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
-{
-    BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
+      template <typename A0> struct emplace_args1
+      {
+        BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
 
-    explicit emplace_args1(Arg0 b0) : a0(b0) {}
-};
+        explicit emplace_args1(Arg0 b0) : a0(b0) {}
+      };
 
-template <typename A0>
-inline emplace_args1<A0> create_emplace_args(BOOST_FWD_REF(A0) b0)
-{
-    emplace_args1<A0> e(b0);
-    return e;
-}
+      template <typename A0>
+      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
-{
-    BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
-    BOOST_UNORDERED_EARGS_MEMBER(1, 1, _)
+      template <typename A0, typename A1> struct emplace_args2
+      {
+        BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
+        BOOST_UNORDERED_EARGS_MEMBER(1, 1, _)
 
-    emplace_args2(Arg0 b0, Arg1 b1) : a0(b0), a1(b1) {}
-};
+        emplace_args2(Arg0 b0, Arg1 b1) : a0(b0), a1(b1) {}
+      };
 
-template <typename A0, typename A1>
-inline emplace_args2<A0, A1> create_emplace_args(
-    BOOST_FWD_REF(A0) b0, BOOST_FWD_REF(A1) b1)
-{
-    emplace_args2<A0, A1> e(b0, b1);
-    return e;
-}
+      template <typename A0, typename A1>
+      inline emplace_args2<A0, A1> create_emplace_args(
+        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
-{
-    BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
-    BOOST_UNORDERED_EARGS_MEMBER(1, 1, _)
-    BOOST_UNORDERED_EARGS_MEMBER(1, 2, _)
+      template <typename A0, typename A1, typename A2> struct emplace_args3
+      {
+        BOOST_UNORDERED_EARGS_MEMBER(1, 0, _)
+        BOOST_UNORDERED_EARGS_MEMBER(1, 1, _)
+        BOOST_UNORDERED_EARGS_MEMBER(1, 2, _)
 
-    emplace_args3(Arg0 b0, Arg1 b1, Arg2 b2) : a0(b0), a1(b1), a2(b2) {}
-};
+        emplace_args3(Arg0 b0, Arg1 b1, Arg2 b2) : a0(b0), a1(b1), a2(b2) {}
+      };
 
-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)
-{
-    emplace_args3<A0, A1, A2> e(b0, b1, b2);
-    return e;
-}
+      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)
+      {
+        emplace_args3<A0, A1, A2> e(b0, b1, b2);
+        return e;
+      }
 
 #define BOOST_UNORDERED_FWD_PARAM(z, n, a)                                     \
-    BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(a, n)
+  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))
+  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))
+  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)                                       \
+  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, _)                  \
     {                                                                          \
-        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;                                                              \
-    }
+  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_UNORDERED_EARGS(1, 4, _)
-BOOST_UNORDERED_EARGS(1, 5, _)
-BOOST_UNORDERED_EARGS(1, 6, _)
-BOOST_UNORDERED_EARGS(1, 7, _)
-BOOST_UNORDERED_EARGS(1, 8, _)
-BOOST_UNORDERED_EARGS(1, 9, _)
-BOOST_PP_REPEAT_FROM_TO(
-    10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT), BOOST_UNORDERED_EARGS, _)
+      BOOST_UNORDERED_EARGS(1, 4, _)
+      BOOST_UNORDERED_EARGS(1, 5, _)
+      BOOST_UNORDERED_EARGS(1, 6, _)
+      BOOST_UNORDERED_EARGS(1, 7, _)
+      BOOST_UNORDERED_EARGS(1, 8, _)
+      BOOST_UNORDERED_EARGS(1, 9, _)
+      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+        BOOST_UNORDERED_EARGS, _)
 
 #undef BOOST_UNORDERED_DEFINE_EMPLACE_ARGS
 #undef BOOST_UNORDERED_EARGS_MEMBER
@@ -679,22 +687,23 @@ BOOST_PP_REPEAT_FROM_TO(
 
 #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
 
@@ -706,9 +715,9 @@ typedef boost::unordered::detail::integral_constant<bool, false> false_type;
 #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)
@@ -726,94 +735,93 @@ template <class T> inline void destroy(T* x) { x->~T(); }
 
 #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))
+  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))
+  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);                              \
+  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)         \
-        };                                                                     \
-    }
+    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);                                            \
+  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 <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))
+  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))
+  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 BOOST_PP_CAT(has_, name)                                              \
+  {                                                                            \
+    struct impl                                                                \
     {                                                                          \
-        struct impl                                                            \
-        {                                                                      \
-            struct base_mixin                                                  \
-            {                                                                  \
-                int name;                                                      \
-            };                                                                 \
-            struct base : public T, public base_mixin                          \
-            {                                                                  \
-            };                                                                 \
+      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);                              \
+      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 = sizeof(choice2::type) == sizeof(test<base>(choose()))          \
+      };                                                                       \
+    };                                                                         \
                                                                                \
-        enum                                                                   \
-        {                                                                      \
-            value = impl::value                                                \
-        };                                                                     \
-    }
+    enum                                                                       \
+    {                                                                          \
+      value = impl::value                                                      \
+    };                                                                         \
+  }
 
 #endif
-}
-}
+    }
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -829,415 +837,428 @@ template <typename T> struct identity
 #include <boost/utility/enable_if.hpp>
 
 namespace boost {
-namespace unordered {
-namespace detail {
+  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 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);
+      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
-    {
-        value = (1 == sizeof(test<Alloc>(choose())))
-    };
-
-    struct fallback
-    {
-        template <typename U> struct rebind
+        enum
         {
-            typedef typename rebind_alloc<Alloc, T>::type other;
+          value = (1 == sizeof(test<Alloc>(choose())))
         };
-    };
 
-    typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE then<
-        Alloc, fallback>::type::BOOST_NESTED_TEMPLATE rebind<T>::other type;
-};
+        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;
+      };
 
 #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 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;                                                   \
+    };                                                                         \
                                                                                \
-        template <typename X>                                                  \
-        static choice1::type test(choice1, typename X::tname* = 0);            \
+    enum                                                                       \
+    {                                                                          \
+      value = (1 == sizeof(test<Tp>(choose())))                                \
+    };                                                                         \
                                                                                \
-        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<Tp, DefaultWrap>::type::tname type;                                 \
+  }
 
 #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 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;                                                   \
+    };                                                                         \
                                                                                \
-        template <typename X>                                                  \
-        static typename boost::unordered::detail::sfinae<typename X::tname,    \
-            choice1>::type test(choice1);                                      \
+    enum                                                                       \
+    {                                                                          \
+      value = (1 == sizeof(test<Tp>(choose())))                                \
+    };                                                                         \
                                                                                \
-        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;                           \
-    }
+    typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE      \
+      then<Tp, DefaultWrap>::type::tname type;                                 \
+  }
 
 #endif
 
 #define BOOST_UNORDERED_DEFAULT_TYPE(T, tname, arg)                            \
-    typename default_type_##tname<T, arg>::type
+  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)
 
-template <typename T>
-BOOST_UNORDERED_HAS_FUNCTION(
-    select_on_container_copy_construction, U const, (), 0);
+      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);
+      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);
+      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);
+      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);
+      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(select_on_container_copy_construction);
 
-template <typename T> BOOST_UNORDERED_HAS_MEMBER(max_size);
+      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(construct);
 
-template <typename T, typename ValueType> BOOST_UNORDERED_HAS_MEMBER(destroy);
+      template <typename T, typename ValueType>
+      BOOST_UNORDERED_HAS_MEMBER(destroy);
 
 #endif
 
-namespace func {
+      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::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 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& 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)();
-}
+        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.
+      } // namespace func.
 
-template <typename Alloc> struct allocator_traits
-{
-    typedef Alloc allocator_type;
-    typedef typename Alloc::value_type value_type;
+      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;
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(
+          Alloc, pointer, value_type*) pointer;
 
-    template <typename T>
-    struct pointer_to_other : boost::pointer_to_other<pointer, T>
-    {
-    };
+        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, 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, 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, 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_CXX11_CONSTRUCTION
 
-    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)
 
-    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
 
-    // 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<
+        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,
+              boost::is_same<T, value_type>::value,
             void*>::type = 0)
-    {
-        a.construct(p, x);
-    }
+        {
+          a.construct(p, x);
+        }
 
-    template <typename T>
-    static void construct(Alloc&, T* p, T const& x,
-        typename boost::disable_if_c<
+        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,
+              boost::is_same<T, value_type>::value,
             void*>::type = 0)
-    {
-        new (static_cast<void*>(p)) T(x);
-    }
+        {
+          new (static_cast<void*>(p)) T(x);
+        }
 
-    template <typename T>
-    static void destroy(Alloc& a, T* p,
-        typename boost::enable_if_c<
+        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,
+              boost::is_same<T, value_type>::value,
             void*>::type = 0)
-    {
-        a.destroy(p);
-    }
+        {
+          a.destroy(p);
+        }
 
-    template <typename T>
-    static void destroy(Alloc&, T* p,
-        typename boost::disable_if_c<
+        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,
+              boost::is_same<T, value_type>::value,
             void*>::type = 0)
-    {
-        boost::unordered::detail::func::destroy(p);
-    }
+        {
+          boost::unordered::detail::func::destroy(p);
+        }
 
 #endif
 
-    static size_type max_size(const Alloc& a)
-    {
-        return boost::unordered::detail::func::call_max_size<size_type>(a);
-    }
+        static size_type max_size(const Alloc& a)
+        {
+          return boost::unordered::detail::func::call_max_size<size_type>(a);
+        }
 
-    // Allocator propagation on construction
+        // Allocator propagation on construction
 
-    static Alloc select_on_container_copy_construction(Alloc const& rhs)
-    {
-        return boost::unordered::detail::func::
+        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 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;
-};
-}
-}
+        // 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
@@ -1252,20 +1273,21 @@ template <typename Alloc> struct allocator_traits
 #include <memory>
 
 namespace boost {
-namespace unordered {
-namespace detail {
+  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;
+      };
+    }
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1277,21 +1299,21 @@ template <typename Alloc, typename T> struct rebind_wrap
 #include <boost/container/allocator_traits.hpp>
 
 namespace boost {
-namespace unordered {
-namespace detail {
+  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
@@ -1305,9 +1327,9 @@ struct rebind_wrap : boost::container::allocator_traits<
 // piecewise construction etc.
 
 namespace boost {
-namespace unordered {
-namespace detail {
-namespace func {
+  namespace unordered {
+    namespace detail {
+      namespace func {
 
 ////////////////////////////////////////////////////////////////////////////
 // construct_value
@@ -1318,39 +1340,39 @@ namespace func {
 #if BOOST_UNORDERED_CXX11_CONSTRUCTION
 
 #define BOOST_UNORDERED_CALL_CONSTRUCT1(Traits, alloc, address, a0)            \
-    Traits::construct(alloc, address, a0)
+  Traits::construct(alloc, address, a0)
 #define BOOST_UNORDERED_CALL_DESTROY(Traits, alloc, x) Traits::destroy(alloc, x)
 
 #elif !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-template <typename T, typename... Args>
-inline void construct_value(T* address, BOOST_FWD_REF(Args)... args)
-{
-    new ((void*)address) T(boost::forward<Args>(args)...);
-}
+        template <typename T, typename... Args>
+        inline void construct_value(T* address, BOOST_FWD_REF(Args)... args)
+        {
+          new ((void*)address) T(boost::forward<Args>(args)...);
+        }
 
 #define BOOST_UNORDERED_CALL_CONSTRUCT1(Traits, alloc, address, a0)            \
-    boost::unordered::detail::func::construct_value(address, a0)
+  boost::unordered::detail::func::construct_value(address, a0)
 #define BOOST_UNORDERED_CALL_DESTROY(Traits, alloc, x)                         \
-    boost::unordered::detail::func::destroy(x)
+  boost::unordered::detail::func::destroy(x)
 
 #else
 
-template <typename T> inline void construct_value(T* address)
-{
-    new ((void*)address) T();
-}
+        template <typename T> inline void construct_value(T* address)
+        {
+          new ((void*)address) T();
+        }
 
-template <typename T, typename A0>
-inline void construct_value(T* address, BOOST_FWD_REF(A0) a0)
-{
-    new ((void*)address) T(boost::forward<A0>(a0));
-}
+        template <typename T, typename A0>
+        inline void construct_value(T* address, BOOST_FWD_REF(A0) a0)
+        {
+          new ((void*)address) T(boost::forward<A0>(a0));
+        }
 
 #define BOOST_UNORDERED_CALL_CONSTRUCT1(Traits, alloc, address, a0)            \
-    boost::unordered::detail::func::construct_value(address, a0)
+  boost::unordered::detail::func::construct_value(address, a0)
 #define BOOST_UNORDERED_CALL_DESTROY(Traits, alloc, x)                         \
-    boost::unordered::detail::func::destroy(x)
+  boost::unordered::detail::func::destroy(x)
 
 #endif
 
@@ -1360,14 +1382,14 @@ inline void construct_value(T* address, BOOST_FWD_REF(A0) a0)
 // Used to emulate piecewise construction.
 
 #define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(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_));  \
-    }
+  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)
 
@@ -1376,22 +1398,22 @@ inline void construct_value(T* address, BOOST_FWD_REF(A0) a0)
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-template <typename Alloc, typename T>
-void construct_from_tuple(Alloc&, T* ptr, boost::tuple<>)
-{
-    new ((void*)ptr) T();
-}
+        template <typename Alloc, typename T>
+        void construct_from_tuple(Alloc&, T* ptr, boost::tuple<>)
+        {
+          new ((void*)ptr) T();
+        }
 
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 1, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 2, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 3, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 4, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 5, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 6, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 7, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 8, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 9, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 10, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 1, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 2, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 3, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 4, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 5, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 6, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 7, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 8, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 9, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 10, boost)
 
 #endif
 
@@ -1399,21 +1421,21 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 10, boost)
 
 #if !BOOST_UNORDERED_CXX11_CONSTRUCTION && BOOST_UNORDERED_TUPLE_ARGS
 
-template <typename Alloc, typename T>
-void construct_from_tuple(Alloc&, T* ptr, std::tuple<>)
-{
-    new ((void*)ptr) T();
-}
+        template <typename Alloc, typename T>
+        void construct_from_tuple(Alloc&, T* ptr, std::tuple<>)
+        {
+          new ((void*)ptr) T();
+        }
 
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 1, std)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 2, std)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 3, std)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 4, std)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 5, std)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 1, std)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 2, std)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 3, std)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 4, std)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 5, std)
 
 #if BOOST_UNORDERED_TUPLE_ARGS >= 6
-BOOST_PP_REPEAT_FROM_TO(6, BOOST_PP_INC(BOOST_UNORDERED_TUPLE_ARGS),
-    BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE, std)
+        BOOST_PP_REPEAT_FROM_TO(6, BOOST_PP_INC(BOOST_UNORDERED_TUPLE_ARGS),
+          BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE, std)
 #endif
 
 #endif
@@ -1430,509 +1452,530 @@ BOOST_PP_REPEAT_FROM_TO(6, BOOST_PP_INC(BOOST_UNORDERED_TUPLE_ARGS),
 
 #if BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-template <int N> struct length
-{
-};
+        template <int N> struct length
+        {
+        };
 
 #define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(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_));  \
-    }
+  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)
 
-template <typename Alloc, typename T>
-void construct_from_tuple_impl(
-    boost::unordered::detail::func::length<0>, Alloc&, T* ptr, boost::tuple<>)
-{
-    new ((void*)ptr) T();
-}
+        template <typename Alloc, typename T>
+        void construct_from_tuple_impl(
+          boost::unordered::detail::func::length<0>, Alloc&, T* ptr,
+          boost::tuple<>)
+        {
+          new ((void*)ptr) T();
+        }
 
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 1, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 2, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 3, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 4, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 5, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 6, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 7, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 8, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 9, boost)
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 10, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 1, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 2, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 3, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 4, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 5, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 6, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 7, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 8, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 9, boost)
+        BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(1, 10, boost)
 
-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);
+        }
 
 #undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
 #undef BOOST_UNORDERED_GET_TUPLE_ARG
 
 #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 BOOST_UNORDERED_CXX11_CONSTRUCTION
 
-////////////////////////////////////////////////////////////////////////////
-// Construct from variadic parameters
+        ////////////////////////////////////////////////////////////////////////////
+        // Construct from variadic parameters
 
-template <typename Alloc, typename T, typename... Args>
-inline void construct_from_args(
-    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 construct_from_args(
+          Alloc& alloc, T* address, BOOST_FWD_REF(Args)... args)
+        {
+          boost::unordered::detail::allocator_traits<Alloc>::construct(
+            alloc, address, boost::forward<Args>(args)...);
+        }
 
-// For backwards compatibility, implement a special case for
-// piecewise_construct with boost::tuple
+        // For backwards compatibility, implement a special case for
+        // piecewise_construct with boost::tuple
 
-template <typename A0> struct detect_boost_tuple
-{
-    template <typename T0, typename T1, typename T2, typename T3, typename T4,
-        typename T5, typename T6, typename T7, typename T8, typename T9>
-    static choice1::type test(
-        choice1, boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> const&);
+        template <typename A0> struct detect_boost_tuple
+        {
+          template <typename T0, typename T1, typename T2, typename T3,
+            typename T4, typename T5, typename T6, typename T7, typename T8,
+            typename T9>
+          static choice1::type test(choice1,
+            boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> const&);
 
-    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>()))
+          };
+        };
 
-// Special case for piecewise_construct
+        // Special case for piecewise_construct
 
-template <typename Alloc, typename A, typename B, typename A0, typename A1,
-    typename A2>
-inline typename boost::enable_if_c<use_piecewise<A0>::value &&
-                                       detect_boost_tuple<A1>::value &&
-                                       detect_boost_tuple<A2>::value,
-    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::addressof(address->first), boost::forward<A1>(a1));
-    BOOST_TRY
-    {
-        boost::unordered::detail::func::construct_from_tuple(
-            alloc, boost::addressof(address->second), boost::forward<A2>(a2));
-    }
-    BOOST_CATCH(...)
-    {
-        boost::unordered::detail::func::destroy(
-            boost::addressof(address->first));
-        BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-}
+        template <typename Alloc, typename A, typename B, typename A0,
+          typename A1, typename A2>
+        inline typename boost::enable_if_c<use_piecewise<A0>::value &&
+                                             detect_boost_tuple<A1>::value &&
+                                             detect_boost_tuple<A2>::value,
+          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::addressof(address->first), boost::forward<A1>(a1));
+          BOOST_TRY
+          {
+            boost::unordered::detail::func::construct_from_tuple(
+              alloc, boost::addressof(address->second), boost::forward<A2>(a2));
+          }
+          BOOST_CATCH(...)
+          {
+            boost::unordered::detail::func::destroy(
+              boost::addressof(address->first));
+            BOOST_RETHROW
+          }
+          BOOST_CATCH_END
+        }
 
 #elif !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-////////////////////////////////////////////////////////////////////////////
-// Construct from variadic parameters
+        ////////////////////////////////////////////////////////////////////////////
+        // Construct from variadic parameters
 
-template <typename Alloc, typename T, typename... Args>
-inline void construct_from_args(Alloc&, T* address, BOOST_FWD_REF(Args)... args)
-{
-    new ((void*)address) T(boost::forward<Args>(args)...);
-}
+        template <typename Alloc, typename T, typename... Args>
+        inline void construct_from_args(
+          Alloc&, T* address, BOOST_FWD_REF(Args)... args)
+        {
+          new ((void*)address) T(boost::forward<Args>(args)...);
+        }
 
-// Special case for piecewise_construct
+        // Special case for piecewise_construct
 
-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::addressof(address->first), boost::forward<A1>(a1));
-    BOOST_TRY
-    {
-        boost::unordered::detail::func::construct_from_tuple(
-            alloc, boost::addressof(address->second), boost::forward<A2>(a2));
-    }
-    BOOST_CATCH(...)
-    {
-        boost::unordered::detail::func::destroy(
-            boost::addressof(address->first));
-        BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-}
+        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::addressof(address->first), boost::forward<A1>(a1));
+          BOOST_TRY
+          {
+            boost::unordered::detail::func::construct_from_tuple(
+              alloc, boost::addressof(address->second), boost::forward<A2>(a2));
+          }
+          BOOST_CATCH(...)
+          {
+            boost::unordered::detail::func::destroy(
+              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>
+        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));
-}
+        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,                                        \
+    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_UNORDERED_CONSTRUCT_IMPL(1, 4, _)
-BOOST_UNORDERED_CONSTRUCT_IMPL(1, 5, _)
-BOOST_UNORDERED_CONSTRUCT_IMPL(1, 6, _)
-BOOST_UNORDERED_CONSTRUCT_IMPL(1, 7, _)
-BOOST_UNORDERED_CONSTRUCT_IMPL(1, 8, _)
-BOOST_UNORDERED_CONSTRUCT_IMPL(1, 9, _)
-BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
-    BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+        BOOST_UNORDERED_CONSTRUCT_IMPL(1, 4, _)
+        BOOST_UNORDERED_CONSTRUCT_IMPL(1, 5, _)
+        BOOST_UNORDERED_CONSTRUCT_IMPL(1, 6, _)
+        BOOST_UNORDERED_CONSTRUCT_IMPL(1, 7, _)
+        BOOST_UNORDERED_CONSTRUCT_IMPL(1, 8, _)
+        BOOST_UNORDERED_CONSTRUCT_IMPL(1, 9, _)
+        BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+          BOOST_UNORDERED_CONSTRUCT_IMPL, _)
 
 #undef BOOST_UNORDERED_CONSTRUCT_IMPL
 
-// Construct with piecewise_construct
+        // Construct with piecewise_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)
-{
-    boost::unordered::detail::func::construct_from_tuple(
-        alloc, boost::addressof(address->first), args.a1);
-    BOOST_TRY
-    {
-        boost::unordered::detail::func::construct_from_tuple(
-            alloc, boost::addressof(address->second), args.a2);
-    }
-    BOOST_CATCH(...)
-    {
-        boost::unordered::detail::func::destroy(
-            boost::addressof(address->first));
-        BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-}
+        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::addressof(address->first), args.a1);
+          BOOST_TRY
+          {
+            boost::unordered::detail::func::construct_from_tuple(
+              alloc, boost::addressof(address->second), args.a2);
+          }
+          BOOST_CATCH(...)
+          {
+            boost::unordered::detail::func::destroy(
+              boost::addressof(address->first));
+            BOOST_RETHROW
+          }
+          BOOST_CATCH_END
+        }
 
 #endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
-}
-}
-}
+      }
+    }
+  }
 }
 
 namespace boost {
-namespace unordered {
-namespace detail {
+  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
+      {
+        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_;
+        node_allocator& alloc_;
+        node_pointer node_;
 
-    node_constructor(node_allocator& n) : alloc_(n), node_() {}
+        node_constructor(node_allocator& n) : alloc_(n), node_() {}
 
-    ~node_constructor();
+        ~node_constructor();
 
-    void create_node();
+        void create_node();
 
-    // no throw
-    node_pointer release()
-    {
-        BOOST_ASSERT(node_);
-        node_pointer p = node_;
-        node_ = node_pointer();
-        return p;
-    }
+        // no throw
+        node_pointer release()
+        {
+          BOOST_ASSERT(node_);
+          node_pointer p = node_;
+          node_ = node_pointer();
+          return p;
+        }
 
-    void reclaim(node_pointer p)
-    {
+        void reclaim(node_pointer p)
+        {
+          BOOST_ASSERT(!node_);
+          node_ = p;
+          BOOST_UNORDERED_CALL_DESTROY(
+            node_allocator_traits, 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_) {
+          boost::unordered::detail::func::destroy(pointer<node>::get(node_));
+          node_allocator_traits::deallocate(alloc_, node_, 1);
+        }
+      }
+
+      template <typename Alloc> void node_constructor<Alloc>::create_node()
+      {
         BOOST_ASSERT(!node_);
-        node_ = p;
-        BOOST_UNORDERED_CALL_DESTROY(
+        node_ = node_allocator_traits::allocate(alloc_, 1);
+        new (pointer<void>::get(node_)) node();
+      }
+
+      template <typename NodeAlloc> struct node_tmp
+      {
+        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
+          node_allocator_traits;
+        typedef typename node_allocator_traits::pointer node_pointer;
+        typedef typename node_allocator_traits::value_type node;
+
+        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_pointer p = node_;
+          node_ = node_pointer();
+          return p;
+        }
+      };
+
+      template <typename Alloc> node_tmp<Alloc>::~node_tmp()
+      {
+        if (node_) {
+          BOOST_UNORDERED_CALL_DESTROY(
             node_allocator_traits, alloc_, node_->value_ptr());
+          boost::unordered::detail::func::destroy(pointer<node>::get(node_));
+          node_allocator_traits::deallocate(alloc_, node_, 1);
+        }
+      }
     }
-
-  private:
-    node_constructor(node_constructor const&);
-    node_constructor& operator=(node_constructor const&);
-};
-
-template <typename Alloc> node_constructor<Alloc>::~node_constructor()
-{
-    if (node_) {
-        boost::unordered::detail::func::destroy(pointer<node>::get(node_));
-        node_allocator_traits::deallocate(alloc_, node_, 1);
-    }
-}
-
-template <typename Alloc> void node_constructor<Alloc>::create_node()
-{
-    BOOST_ASSERT(!node_);
-    node_ = node_allocator_traits::allocate(alloc_, 1);
-    new (pointer<void>::get(node_)) node();
-}
-
-template <typename NodeAlloc> struct node_tmp
-{
-    typedef boost::unordered::detail::allocator_traits<NodeAlloc>
-        node_allocator_traits;
-    typedef typename node_allocator_traits::pointer node_pointer;
-    typedef typename node_allocator_traits::value_type node;
-
-    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_pointer p = node_;
-        node_ = node_pointer();
-        return p;
-    }
-};
-
-template <typename Alloc> node_tmp<Alloc>::~node_tmp()
-{
-    if (node_) {
-        BOOST_UNORDERED_CALL_DESTROY(
-            node_allocator_traits, alloc_, node_->value_ptr());
-        boost::unordered::detail::func::destroy(pointer<node>::get(node_));
-        node_allocator_traits::deallocate(alloc_, node_, 1);
-    }
-}
-}
-}
+  }
 }
 
 namespace boost {
-namespace unordered {
-namespace detail {
-namespace func {
+  namespace unordered {
+    namespace detail {
+      namespace func {
 
-// Some nicer construct_node functions, might try to
-// improve implementation later.
+        // 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, 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_CALL_CONSTRUCT1(
-        boost::unordered::detail::allocator_traits<Alloc>, alloc,
-        a.node_->value_ptr(), boost::forward<U>(x));
-    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_CALL_CONSTRUCT1(
+            boost::unordered::detail::allocator_traits<Alloc>, alloc,
+            a.node_->value_ptr(), boost::forward<U>(x));
+          return a.release();
+        }
 
 #if BOOST_UNORDERED_CXX11_CONSTRUCTION
 
-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::allocator_traits<Alloc>::construct(alloc,
-        a.node_->value_ptr(), std::piecewise_construct,
-        std::forward_as_tuple(boost::forward<Key>(k)), std::forward_as_tuple());
-    return a.release();
-}
+        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::allocator_traits<Alloc>::construct(alloc,
+            a.node_->value_ptr(), std::piecewise_construct,
+            std::forward_as_tuple(boost::forward<Key>(k)),
+            std::forward_as_tuple());
+          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)
-{
-    node_constructor<Alloc> a(alloc);
-    a.create_node();
-    boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
-        a.node_->value_ptr(), std::piecewise_construct,
-        std::forward_as_tuple(boost::forward<Key>(k)),
-        std::forward_as_tuple(boost::forward<Mapped>(m)));
-    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)
+        {
+          node_constructor<Alloc> a(alloc);
+          a.create_node();
+          boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
+            a.node_->value_ptr(), std::piecewise_construct,
+            std::forward_as_tuple(boost::forward<Key>(k)),
+            std::forward_as_tuple(boost::forward<Mapped>(m)));
+          return a.release();
+        }
 
-template <typename Alloc, typename Key, typename... Args>
-inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
-construct_node_pair_from_args(
-    Alloc& alloc, BOOST_FWD_REF(Key) k, BOOST_FWD_REF(Args)... args)
-{
-    node_constructor<Alloc> a(alloc);
-    a.create_node();
+        template <typename Alloc, typename Key, typename... Args>
+        inline
+          typename boost::unordered::detail::allocator_traits<Alloc>::pointer
+          construct_node_pair_from_args(
+            Alloc& alloc, BOOST_FWD_REF(Key) k, BOOST_FWD_REF(Args)... args)
+        {
+          node_constructor<Alloc> a(alloc);
+          a.create_node();
 #if !(BOOST_COMP_CLANG && BOOST_COMP_CLANG < BOOST_VERSION_NUMBER(3, 8, 0) &&  \
       defined(BOOST_LIBSTDCXX11))
-    boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
-        a.node_->value_ptr(), std::piecewise_construct,
-        std::forward_as_tuple(boost::forward<Key>(k)),
-        std::forward_as_tuple(boost::forward<Args>(args)...));
+          boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
+            a.node_->value_ptr(), std::piecewise_construct,
+            std::forward_as_tuple(boost::forward<Key>(k)),
+            std::forward_as_tuple(boost::forward<Args>(args)...));
 #else
-    // It doesn't seem to be possible to construct a tuple with 3 variadic
-    // rvalue reference members when using older versions of clang with
-    // libstdc++, so just use std::make_tuple instead of std::forward_as_tuple.
-    boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
-        a.node_->value_ptr(), std::piecewise_construct,
-        std::forward_as_tuple(boost::forward<Key>(k)),
-        std::make_tuple(boost::forward<Args>(args)...));
+          // It doesn't seem to be possible to construct a tuple with 3 variadic
+          // rvalue reference members when using older versions of clang with
+          // libstdc++, so just use std::make_tuple instead of
+          // std::forward_as_tuple.
+          boost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
+            a.node_->value_ptr(), std::piecewise_construct,
+            std::forward_as_tuple(boost::forward<Key>(k)),
+            std::make_tuple(boost::forward<Args>(args)...));
 #endif
-    return a.release();
-}
+          return a.release();
+        }
 
 #else
 
-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::construct_value(
-        boost::addressof(a.node_->value_ptr()->first), boost::forward<Key>(k));
-    BOOST_TRY
-    {
-        boost::unordered::detail::func::construct_value(
-            boost::addressof(a.node_->value_ptr()->second));
-    }
-    BOOST_CATCH(...)
-    {
-        boost::unordered::detail::func::destroy(
-            boost::addressof(a.node_->value_ptr()->first));
-        BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-    return a.release();
-}
+        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::construct_value(
+            boost::addressof(a.node_->value_ptr()->first),
+            boost::forward<Key>(k));
+          BOOST_TRY
+          {
+            boost::unordered::detail::func::construct_value(
+              boost::addressof(a.node_->value_ptr()->second));
+          }
+          BOOST_CATCH(...)
+          {
+            boost::unordered::detail::func::destroy(
+              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)
-{
-    node_constructor<Alloc> a(alloc);
-    a.create_node();
-    boost::unordered::detail::func::construct_value(
-        boost::addressof(a.node_->value_ptr()->first), boost::forward<Key>(k));
-    BOOST_TRY
-    {
-        boost::unordered::detail::func::construct_value(
-            boost::addressof(a.node_->value_ptr()->second),
-            boost::forward<Mapped>(m));
-    }
-    BOOST_CATCH(...)
-    {
-        boost::unordered::detail::func::destroy(
-            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)
+        {
+          node_constructor<Alloc> a(alloc);
+          a.create_node();
+          boost::unordered::detail::func::construct_value(
+            boost::addressof(a.node_->value_ptr()->first),
+            boost::forward<Key>(k));
+          BOOST_TRY
+          {
+            boost::unordered::detail::func::construct_value(
+              boost::addressof(a.node_->value_ptr()->second),
+              boost::forward<Mapped>(m));
+          }
+          BOOST_CATCH(...)
+          {
+            boost::unordered::detail::func::destroy(
+              boost::addressof(a.node_->value_ptr()->first));
+            BOOST_RETHROW
+          }
+          BOOST_CATCH_END
+          return a.release();
+        }
 
-template <typename Alloc, typename Key, BOOST_UNORDERED_EMPLACE_TEMPLATE>
-inline typename boost::unordered::detail::allocator_traits<Alloc>::pointer
-construct_node_pair_from_args(
-    Alloc& alloc, BOOST_FWD_REF(Key) k, BOOST_UNORDERED_EMPLACE_ARGS)
-{
-    node_constructor<Alloc> a(alloc);
-    a.create_node();
-    boost::unordered::detail::func::construct_value(
-        boost::addressof(a.node_->value_ptr()->first), boost::forward<Key>(k));
-    BOOST_TRY
-    {
-        boost::unordered::detail::func::construct_from_args(alloc,
-            boost::addressof(a.node_->value_ptr()->second),
-            BOOST_UNORDERED_EMPLACE_FORWARD);
-    }
-    BOOST_CATCH(...)
-    {
-        boost::unordered::detail::func::destroy(
-            boost::addressof(a.node_->value_ptr()->first));
-        BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-    return a.release();
-}
+        template <typename Alloc, typename Key,
+          BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        inline
+          typename boost::unordered::detail::allocator_traits<Alloc>::pointer
+          construct_node_pair_from_args(
+            Alloc& alloc, BOOST_FWD_REF(Key) k, BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+          node_constructor<Alloc> a(alloc);
+          a.create_node();
+          boost::unordered::detail::func::construct_value(
+            boost::addressof(a.node_->value_ptr()->first),
+            boost::forward<Key>(k));
+          BOOST_TRY
+          {
+            boost::unordered::detail::func::construct_from_args(alloc,
+              boost::addressof(a.node_->value_ptr()->second),
+              BOOST_UNORDERED_EMPLACE_FORWARD);
+          }
+          BOOST_CATCH(...)
+          {
+            boost::unordered::detail::func::destroy(
+              boost::addressof(a.node_->value_ptr()->first));
+            BOOST_RETHROW
+          }
+          BOOST_CATCH_END
+          return a.release();
+        }
 
 #endif
-}
-}
-}
+      }
+    }
+  }
 }
 
 #if defined(BOOST_MSVC)
@@ -1944,677 +1987,682 @@ construct_node_pair_from_args(
 // 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 unordered {
+    namespace iterator_detail {
 
-////////////////////////////////////////////////////////////////////////////
-// Iterators
-//
-// all no throw
+      ////////////////////////////////////////////////////////////////////////////
+      // Iterators
+      //
+      // all no throw
 
-template <typename Node>
-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>
+      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>
-    friend struct boost::unordered::iterator_detail::cl_iterator;
+        template <typename Node2>
+        friend struct boost::unordered::iterator_detail::cl_iterator;
 
-  private:
+      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:
-    typedef typename Node::value_type value_type;
+      public:
+        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)
-    {
-    }
+        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(); }
 
-    value_type* operator->() const { return ptr_->value_ptr(); }
+        value_type* operator->() const { return ptr_->value_ptr(); }
 
-    l_iterator& operator++()
-    {
-        ptr_ = static_cast<node_pointer>(ptr_->next_);
-        if (ptr_ && ptr_->get_bucket() != bucket_)
+        l_iterator& operator++()
+        {
+          ptr_ = static_cast<node_pointer>(ptr_->next_);
+          if (ptr_ && ptr_->get_bucket() != bucket_)
             ptr_ = node_pointer();
-        return *this;
-    }
+          return *this;
+        }
 
-    l_iterator operator++(int)
-    {
-        l_iterator tmp(*this);
-        ++(*this);
-        return tmp;
-    }
+        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_;
+        }
 
-    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>
-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>;
+      template <typename Node>
+      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>;
 
-  private:
-    typedef typename Node::node_pointer node_pointer;
-    node_pointer ptr_;
-    std::size_t bucket_;
-    std::size_t bucket_count_;
+      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;
+      public:
+        typedef typename Node::value_type value_type;
 
-    cl_iterator() BOOST_NOEXCEPT : ptr_() {}
+        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(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> const& x)
-        BOOST_NOEXCEPT : ptr_(x.ptr_),
-                         bucket_(x.bucket_),
-                         bucket_count_(x.bucket_count_)
-    {
-    }
+        cl_iterator(
+          boost::unordered::iterator_detail::l_iterator<Node> 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(); }
 
-    value_type const* operator->() const { return ptr_->value_ptr(); }
+        value_type const* operator->() const { return ptr_->value_ptr(); }
 
-    cl_iterator& operator++()
-    {
-        ptr_ = static_cast<node_pointer>(ptr_->next_);
-        if (ptr_ && ptr_->get_bucket() != bucket_)
+        cl_iterator& operator++()
+        {
+          ptr_ = static_cast<node_pointer>(ptr_->next_);
+          if (ptr_ && ptr_->get_bucket() != bucket_)
             ptr_ = node_pointer();
-        return *this;
-    }
+          return *this;
+        }
 
-    cl_iterator operator++(int)
-    {
-        cl_iterator tmp(*this);
-        ++(*this);
-        return tmp;
-    }
+        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_;
+        }
 
-    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&>
-{
+      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::iterator_detail::c_iterator;
+        template <typename> friend struct boost::unordered::detail::table;
 
-  private:
+      private:
 #endif
-    typedef typename Node::node_pointer node_pointer;
-    node_pointer node_;
+        typedef typename Node::node_pointer node_pointer;
+        node_pointer node_;
 
-  public:
-    typedef typename Node::value_type value_type;
+      public:
+        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))
-    {
-    }
+        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(); }
 
-    value_type* operator->() const { return node_->value_ptr(); }
+        value_type* operator->() const { return node_->value_ptr(); }
 
-    iterator& operator++()
-    {
-        node_ = static_cast<node_pointer>(node_->next_);
-        return *this;
-    }
+        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;
-    }
+        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_;
+        }
 
-    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>;
+      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;
 
-  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:
-    typedef typename Node::value_type value_type;
+      public:
+        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))
-    {
+        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_;
+        }
+      };
     }
-
-    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 {
+  namespace unordered {
+    namespace detail {
 
-///////////////////////////////////////////////////////////////////
-//
-// Node Holder
-//
-// Temporary store for nodes. Deletes any that aren't used.
+      ///////////////////////////////////////////////////////////////////
+      //
+      // 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;
+      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_;
+        node_constructor<NodeAlloc> constructor_;
+        node_pointer nodes_;
 
-  public:
-    template <typename Table>
-    explicit node_holder(Table& b) : constructor_(b.node_alloc()), nodes_()
-    {
-        if (b.size_) {
+      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;
+          }
         }
-    }
 
-    ~node_holder();
+        ~node_holder();
 
-    node_pointer pop_node()
-    {
-        node_pointer n = nodes_;
-        nodes_ = static_cast<node_pointer>(nodes_->next_);
-        n->next_ = link_pointer();
-        return n;
-    }
+        node_pointer pop_node()
+        {
+          node_pointer n = nodes_;
+          nodes_ = static_cast<node_pointer>(nodes_->next_);
+          n->next_ = link_pointer();
+          return n;
+        }
 
-    template <typename T> inline node_pointer copy_of(T const& v)
-    {
-        if (nodes_) {
+        template <typename T> inline node_pointer copy_of(T const& v)
+        {
+          if (nodes_) {
             constructor_.reclaim(pop_node());
-        } else {
+          } else {
             constructor_.create_node();
-        }
-        BOOST_UNORDERED_CALL_CONSTRUCT1(node_allocator_traits,
+          }
+          BOOST_UNORDERED_CALL_CONSTRUCT1(node_allocator_traits,
             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();
+          return constructor_.release();
         }
-        BOOST_UNORDERED_CALL_CONSTRUCT1(node_allocator_traits,
+
+        template <typename T> inline node_pointer move_copy_of(T& v)
+        {
+          if (nodes_) {
+            constructor_.reclaim(pop_node());
+          } else {
+            constructor_.create_node();
+          }
+          BOOST_UNORDERED_CALL_CONSTRUCT1(node_allocator_traits,
             constructor_.alloc_, constructor_.node_->value_ptr(),
             boost::move(v));
-        return constructor_.release();
-    }
+          return constructor_.release();
+        }
 
-    iterator begin() const { return iterator(nodes_); }
-};
+        iterator begin() const { return iterator(nodes_); }
+      };
 
-template <typename Alloc> node_holder<Alloc>::~node_holder()
-{
-    while (nodes_) {
-        node_pointer p = nodes_;
-        nodes_ = static_cast<node_pointer>(p->next_);
+      template <typename Alloc> node_holder<Alloc>::~node_holder()
+      {
+        while (nodes_) {
+          node_pointer p = nodes_;
+          nodes_ = static_cast<node_pointer>(p->next_);
 
-        BOOST_UNORDERED_CALL_DESTROY(
+          BOOST_UNORDERED_CALL_DESTROY(
             node_allocator_traits, constructor_.alloc_, p->value_ptr());
-        boost::unordered::detail::func::destroy(pointer<node>::get(p));
-        node_allocator_traits::deallocate(constructor_.alloc_, p, 1);
-    }
-}
+          boost::unordered::detail::func::destroy(pointer<node>::get(p));
+          node_allocator_traits::deallocate(constructor_.alloc_, p, 1);
+        }
+      }
 
-///////////////////////////////////////////////////////////////////
-//
-// Bucket
+      ///////////////////////////////////////////////////////////////////
+      //
+      // Bucket
 
-template <typename NodePointer> struct bucket
-{
-    typedef NodePointer link_pointer;
-    link_pointer next_;
+      template <typename NodePointer> struct bucket
+      {
+        typedef NodePointer link_pointer;
+        link_pointer next_;
 
-    bucket() : next_() {}
-    bucket(link_pointer n) : next_(n) {}
+        bucket() : next_() {}
+        bucket(link_pointer n) : next_(n) {}
 
-    link_pointer first_from_start() { return next_; }
+        link_pointer first_from_start() { return next_; }
 
-    enum
-    {
-        extra_node = true
-    };
-};
+        enum
+        {
+          extra_node = true
+        };
+      };
 
-struct ptr_bucket
-{
-    typedef ptr_bucket* link_pointer;
-    link_pointer next_;
+      struct ptr_bucket
+      {
+        typedef ptr_bucket* link_pointer;
+        link_pointer next_;
 
-    ptr_bucket() : next_(0) {}
-    ptr_bucket(link_pointer n) : next_(n) {}
+        ptr_bucket() : next_(0) {}
+        ptr_bucket(link_pointer n) : next_(n) {}
 
-    link_pointer first_from_start() { return this; }
+        link_pointer first_from_start() { return this; }
 
-    enum
-    {
-        extra_node = false
-    };
-};
+        enum
+        {
+          extra_node = false
+        };
+      };
 
-///////////////////////////////////////////////////////////////////
-//
-// Hash Policy
+      ///////////////////////////////////////////////////////////////////
+      //
+      // Hash Policy
 
-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);
-    }
+      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);
+        }
 
-    static inline SizeT to_bucket(SizeT bucket_count, SizeT hash)
-    {
-        return hash % bucket_count;
-    }
+        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash)
+        {
+          return hash % bucket_count;
+        }
 
-    static inline SizeT new_bucket_count(SizeT min)
-    {
-        return boost::unordered::detail::next_prime(min);
-    }
+        static inline SizeT new_bucket_count(SizeT min)
+        {
+          return boost::unordered::detail::next_prime(min);
+        }
 
-    static inline SizeT prev_bucket_count(SizeT max)
-    {
-        return boost::unordered::detail::prev_prime(max);
-    }
-};
+        static inline SizeT prev_bucket_count(SizeT max)
+        {
+          return boost::unordered::detail::prev_prime(max);
+        }
+      };
 
-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 <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;
+        }
 
-    static inline SizeT to_bucket(SizeT bucket_count, SizeT hash)
-    {
-        return hash & (bucket_count - 1);
-    }
+        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)
+        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;
-    }
+          --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;
-    }
-};
+        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 <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 <> struct pick_policy_impl<64, 2>
+      {
+        typedef mix64_policy<std::size_t> type;
+      };
 
-template <typename T>
-struct pick_policy2 : pick_policy_impl<std::numeric_limits<std::size_t>::digits,
-                          std::numeric_limits<std::size_t>::radix>
-{
-};
+      template <typename T>
+      struct pick_policy2
+        : 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.
+      // 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_policy2<int>
-{
-    typedef prime_policy<std::size_t> type;
-};
+      template <> struct pick_policy2<int>
+      {
+        typedef prime_policy<std::size_t> type;
+      };
 
-template <> struct pick_policy2<unsigned int>
-{
-    typedef prime_policy<std::size_t> type;
-};
+      template <> struct pick_policy2<unsigned int>
+      {
+        typedef prime_policy<std::size_t> type;
+      };
 
-template <> struct pick_policy2<long>
-{
-    typedef prime_policy<std::size_t> type;
-};
+      template <> struct pick_policy2<long>
+      {
+        typedef prime_policy<std::size_t> type;
+      };
 
-template <> struct pick_policy2<unsigned long>
-{
-    typedef prime_policy<std::size_t> type;
-};
+      template <> struct pick_policy2<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_policy2<boost::long_long_type>
-{
-    typedef prime_policy<std::size_t> type;
-};
+      template <> struct pick_policy2<boost::long_long_type>
+      {
+        typedef prime_policy<std::size_t> type;
+      };
 
-template <> struct pick_policy2<boost::ulong_long_type>
-{
-    typedef prime_policy<std::size_t> type;
-};
+      template <> struct pick_policy2<boost::ulong_long_type>
+      {
+        typedef prime_policy<std::size_t> type;
+      };
 #endif
 
-template <typename T>
-struct pick_policy : pick_policy2<typename boost::remove_cv<T>::type>
-{
-};
+      template <typename T>
+      struct pick_policy : pick_policy2<typename boost::remove_cv<T>::type>
+      {
+      };
 
-////////////////////////////////////////////////////////////////////////////
-// 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
-{
-  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;
+      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&);
+      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 compressed<H, P> function_pair;
 
-    typedef typename boost::aligned_storage<sizeof(function_pair),
-        boost::alignment_of<function_pair>::value>::type aligned_function;
+        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];
+        bool current_; // The currently active functions.
+        aligned_function funcs_[2];
 
-    function_pair const& current() const
-    {
-        return *static_cast<function_pair const*>(
+        function_pair const& current() const
+        {
+          return *static_cast<function_pair const*>(
             static_cast<void const*>(funcs_[current_].address()));
-    }
+        }
 
-    function_pair& current()
-    {
-        return *static_cast<function_pair*>(
+        function_pair& current()
+        {
+          return *static_cast<function_pair*>(
             static_cast<void*>(funcs_[current_].address()));
-    }
+        }
 
-    void construct(bool which, H const& hf, P const& eq)
-    {
-        new ((void*)&funcs_[which]) function_pair(hf, eq);
-    }
+        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 =
+        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);
-    }
+        {
+          new ((void*)&funcs_[which]) function_pair(f);
+        }
 
-    void construct(
-        bool which, function_pair& f, boost::unordered::detail::true_type)
-    {
-        new ((void*)&funcs_[which])
+        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(
+        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;
+      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(H const& hf, P const& eq) : current_(false)
+        {
+          construct(current_, hf, eq);
+        }
 
-    functions(functions const& bf) : current_(false)
-    {
-        construct(current_, bf.current());
-    }
+        functions(functions const& bf) : current_(false)
+        {
+          construct(current_, bf.current());
+        }
 
-    functions(functions& bf, boost::unordered::detail::move_tag)
-        : 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_); }
+        ~functions() { this->destroy(current_); }
 
-    H const& hash_function() const { return current().first(); }
+        H const& hash_function() const { return current().first(); }
 
-    P const& key_eq() const { return current().second(); }
-};
+        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&);
+      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;
+        typedef functions<H, P> functions_type;
 
-    functions_type& functions_;
-    bool tmp_functions_;
+        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);
-    }
+      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_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_); }
+        ~set_hash_functions() { functions_.destroy(tmp_functions_); }
 
-    void commit()
-    {
-        functions_.current_ = tmp_functions_;
-        tmp_functions_ = !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&);
+      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;
+        typedef functions<H, P> functions_type;
 
-    functions_type& functions_;
-    H hash_;
-    P pred_;
+        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)
-    {
-    }
+      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())
-    {
-    }
+        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_);
-    }
-};
+        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
@@ -2623,26 +2671,26 @@ template <class H, class P> class set_hash_functions<H, P, true>
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #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>,
+      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
+  typename boost::unordered::detail::rv_ref<T>::type
 #endif
 
 #if defined(BOOST_MSVC)
@@ -2650,524 +2698,540 @@ struct rv_ref
 #pragma warning(disable : 4127) // conditional expression is constant
 #endif
 
-////////////////////////////////////////////////////////////////////////////
-// convert double to std::size_t
+      ////////////////////////////////////////////////////////////////////////////
+      // convert double to std::size_t
 
-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);
-}
+      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.
+      // The space used to store values in a node.
 
-template <typename ValueType> struct value_base
-{
-    typedef ValueType value_type;
+      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_;
+        typename boost::aligned_storage<sizeof(value_type),
+          boost::alignment_of<value_type>::value>::type data_;
 
-    value_base() : data_() {}
+        value_base() : data_() {}
 
-    void* address() { return this; }
+        void* address() { return this; }
 
-    value_type& value() { return *(ValueType*)this; }
+        value_type& value() { return *(ValueType*)this; }
 
-    value_type const& value() const { return *(ValueType const*)this; }
+        value_type const& value() const { return *(ValueType const*)this; }
 
-    value_type* value_ptr() { return (ValueType*)this; }
+        value_type* value_ptr() { return (ValueType*)this; }
 
-    value_type const* value_ptr() const { return (ValueType const*)this; }
+        value_type const* value_ptr() const { return (ValueType const*)this; }
 
-  private:
-    value_base& operator=(value_base const&);
-};
+      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&);
+      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::const_key_type const_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;
+      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::const_key_type const_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 boost::unordered::detail::functions<typename Types::hasher,
+          typename Types::key_equal>
+          functions;
+        typedef typename functions::set_hash_functions set_hash_functions;
 
-    typedef typename Types::value_allocator value_allocator;
-    typedef typename boost::unordered::detail::rebind_wrap<value_allocator,
-        node>::type node_allocator;
-    typedef typename boost::unordered::detail::rebind_wrap<value_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;
+        typedef typename Types::value_allocator value_allocator;
+        typedef typename boost::unordered::detail::rebind_wrap<value_allocator,
+          node>::type node_allocator;
+        typedef typename boost::unordered::detail::rebind_wrap<value_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;
 
-    typedef std::pair<iterator, bool> emplace_return;
+        typedef std::pair<iterator, bool> emplace_return;
 
-    ////////////////////////////////////////////////////////////////////////
-    // Members
+        ////////////////////////////////////////////////////////////////////////
+        // 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_;
+        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_;
 
-    ////////////////////////////////////////////////////////////////////////
-    // Data access
+        ////////////////////////////////////////////////////////////////////////
+        // Data access
 
-    static node_pointer get_node(c_iterator it) { return it.node_; }
+        static node_pointer get_node(c_iterator it) { return it.node_; }
 
-    static node_pointer next_node(link_pointer n)
-    {
-        return static_cast<node_pointer>(n->next_);
-    }
+        static node_pointer next_node(link_pointer n)
+        {
+          return static_cast<node_pointer>(n->next_);
+        }
 
-    static node_pointer next_for_find(link_pointer n)
-    {
-        node_pointer n2 = static_cast<node_pointer>(n);
-        do {
+        static node_pointer next_for_find(link_pointer n)
+        {
+          node_pointer n2 = static_cast<node_pointer>(n);
+          do {
             n2 = next_node(n2);
-        } while (n2 && !n2->is_first_in_group());
-        return n2;
-    }
+          } while (n2 && !n2->is_first_in_group());
+          return n2;
+        }
 
-    node_pointer next_group(node_pointer n) const
-    {
-        node_pointer n1 = n;
-        do {
+        node_pointer next_group(node_pointer n) const
+        {
+          node_pointer n1 = n;
+          do {
             n1 = next_node(n1);
-        } while (n1 && !n1->is_first_in_group());
-        return n1;
-    }
+          } while (n1 && !n1->is_first_in_group());
+          return n1;
+        }
 
-    std::size_t group_count(node_pointer n) const
-    {
-        std::size_t x = 0;
-        node_pointer it = n;
-        do {
+        std::size_t group_count(node_pointer n) const
+        {
+          std::size_t x = 0;
+          node_pointer it = n;
+          do {
             ++x;
             it = next_node(it);
-        } while (it && !it->is_first_in_group());
+          } while (it && !it->is_first_in_group());
 
-        return x;
-    }
+          return x;
+        }
 
-    std::size_t node_bucket(node_pointer n) const { return n->get_bucket(); }
+        std::size_t node_bucket(node_pointer n) const
+        {
+          return n->get_bucket();
+        }
 
-    bucket_allocator const& bucket_alloc() const { return allocators_.first(); }
+        bucket_allocator const& bucket_alloc() const
+        {
+          return allocators_.first();
+        }
 
-    node_allocator const& node_alloc() const { return allocators_.second(); }
+        node_allocator const& node_alloc() const
+        {
+          return allocators_.second();
+        }
 
-    bucket_allocator& bucket_alloc() { return allocators_.first(); }
+        bucket_allocator& bucket_alloc() { return allocators_.first(); }
 
-    node_allocator& node_alloc() { return allocators_.second(); }
+        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(
+        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);
-    }
+        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() 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_;
-    }
+        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() const
+        {
+          return size_ ? next_node(get_previous_start()) : node_pointer();
+        }
 
-    node_pointer begin(std::size_t bucket_index) const
-    {
-        if (!size_)
+        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();
-    }
+          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);
-    }
+        std::size_t hash_to_bucket(std::size_t hash_value) const
+        {
+          return policy::to_bucket(bucket_count_, hash_value);
+        }
 
-    std::size_t bucket_size(std::size_t index) const
-    {
-        node_pointer n = begin(index);
-        if (!n)
+        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 && node_bucket(n) == index) {
+          std::size_t count = 0;
+          while (n && node_bucket(n) == index) {
             ++count;
             n = next_node(n);
+          }
+
+          return count;
         }
 
-        return count;
-    }
+        ////////////////////////////////////////////////////////////////////////
+        // Load methods
 
-    ////////////////////////////////////////////////////////////////////////
-    // Load methods
+        void recalculate_max_load()
+        {
+          using namespace std;
 
-    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(
+          // 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 insert/emplace requirements:
-        //
-        // 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_(0), buckets_()
-    {
-    }
-
-    ////////////////////////////////////////////////////////////////////////
-    // Clear buckets and Create buckets
-    //
-    // IMPORTANT: If the container already contains any elements, the
-    //            buckets will not contain any links to them. This will
-    //            need to be dealt with, for example by:
-    //            - deleting them
-    //            - putting them in a 'node_holder' for future use
-    //              (as in assignment)
-    //            - placing them in buckets (see rehash_impl)
-
-    // Clear the bucket pointers.
-    void clear_buckets()
-    {
-        bucket_pointer end = get_bucket(bucket_count_);
-        for (bucket_pointer it = buckets_; it != end; ++it) {
-            it->next_ = node_pointer();
+                               : 0;
         }
-    }
 
-    // Create container buckets. If the container already contains any buckets
-    // the linked list will be transferred to the new buckets, but none
-    // of the bucket pointers will be set. See above note.
-    //
-    // Strong exception safety.
-    void create_buckets(std::size_t new_count)
-    {
-        link_pointer dummy_node;
+        void max_load_factor(float z)
+        {
+          BOOST_ASSERT(z > 0);
+          mlf_ = (std::max)(z, minimum_max_load_factor);
+          recalculate_max_load();
+        }
 
-        // Construct the new buckets and dummy node, and destroy the old buckets
-        if (buckets_) {
+        std::size_t min_buckets_for_size(std::size_t size) const
+        {
+          BOOST_ASSERT(mlf_ >= minimum_max_load_factor);
+
+          using namespace std;
+
+          // From insert/emplace requirements:
+          //
+          // 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_(0), buckets_()
+        {
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Clear buckets and Create buckets
+        //
+        // IMPORTANT: If the container already contains any elements, the
+        //            buckets will not contain any links to them. This will
+        //            need to be dealt with, for example by:
+        //            - deleting them
+        //            - putting them in a 'node_holder' for future use
+        //              (as in assignment)
+        //            - placing them in buckets (see rehash_impl)
+
+        // Clear the bucket pointers.
+        void clear_buckets()
+        {
+          bucket_pointer end = get_bucket(bucket_count_);
+          for (bucket_pointer it = buckets_; it != end; ++it) {
+            it->next_ = node_pointer();
+          }
+        }
+
+        // Create container buckets. If the container already contains any
+        // buckets
+        // the linked list will be transferred to the new buckets, but none
+        // of the bucket pointers will be set. See above note.
+        //
+        // Strong exception safety.
+        void create_buckets(std::size_t new_count)
+        {
+          link_pointer dummy_node;
+
+          // Construct the new buckets and dummy node, and destroy the old
+          // buckets
+          if (buckets_) {
             dummy_node =
-                (buckets_ + static_cast<std::ptrdiff_t>(bucket_count_))->next_;
-            bucket_pointer new_buckets = bucket_allocator_traits::allocate(
-                bucket_alloc(), new_count + 1);
+              (buckets_ + static_cast<std::ptrdiff_t>(bucket_count_))->next_;
+            bucket_pointer new_buckets =
+              bucket_allocator_traits::allocate(bucket_alloc(), new_count + 1);
             destroy_buckets();
             buckets_ = new_buckets;
-        } else if (bucket::extra_node) {
+          } else if (bucket::extra_node) {
             node_constructor a(node_alloc());
             a.create_node();
-            buckets_ = bucket_allocator_traits::allocate(
-                bucket_alloc(), new_count + 1);
+            buckets_ =
+              bucket_allocator_traits::allocate(bucket_alloc(), new_count + 1);
             dummy_node = a.release();
-        } else {
+          } else {
             dummy_node = link_pointer();
-            buckets_ = bucket_allocator_traits::allocate(
-                bucket_alloc(), new_count + 1);
-        }
+            buckets_ =
+              bucket_allocator_traits::allocate(bucket_alloc(), new_count + 1);
+          }
 
-        // nothrow from here...
-        bucket_count_ = new_count;
-        recalculate_max_load();
+          // nothrow from here...
+          bucket_count_ = new_count;
+          recalculate_max_load();
 
-        bucket_pointer end = buckets_ + static_cast<std::ptrdiff_t>(new_count);
-        for (bucket_pointer i = buckets_; i != end; ++i) {
+          bucket_pointer end =
+            buckets_ + static_cast<std::ptrdiff_t>(new_count);
+          for (bucket_pointer i = buckets_; i != end; ++i) {
             new (pointer<void>::get(i)) bucket();
+          }
+          new (pointer<void>::get(end)) bucket(dummy_node);
         }
-        new (pointer<void>::get(end)) bucket(dummy_node);
-    }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Swap and Move
+        ////////////////////////////////////////////////////////////////////////
+        // Swap and Move
 
-    void swap_allocators(table& other, false_type)
-    {
-        boost::unordered::detail::func::ignore_unused_variable_warning(other);
+        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());
-    }
+          // 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_);
-    }
+        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);
+        // 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,
+          // 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>());
+                                 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();
-    }
+          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_;
-        max_load_ = other.max_load_;
-        other.buckets_ = bucket_pointer();
-        other.size_ = 0;
-        other.max_load_ = 0;
-    }
+        // 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_;
+          max_load_ = other.max_load_;
+          other.buckets_ = bucket_pointer();
+          other.size_ = 0;
+          other.max_load_ = 0;
+        }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Delete/destruct
+        ////////////////////////////////////////////////////////////////////////
+        // Delete/destruct
 
-    ~table() { delete_buckets(); }
+        ~table() { delete_buckets(); }
 
-    void destroy_node(node_pointer n)
-    {
-        BOOST_UNORDERED_CALL_DESTROY(
+        void destroy_node(node_pointer n)
+        {
+          BOOST_UNORDERED_CALL_DESTROY(
             node_allocator_traits, node_alloc(), n->value_ptr());
-        boost::unordered::detail::func::destroy(pointer<node>::get(n));
-        node_allocator_traits::deallocate(node_alloc(), n, 1);
-    }
+          boost::unordered::detail::func::destroy(pointer<node>::get(n));
+          node_allocator_traits::deallocate(node_alloc(), n, 1);
+        }
 
-    void delete_buckets()
-    {
-        if (buckets_) {
+        void delete_buckets()
+        {
+          if (buckets_) {
             node_pointer n =
-                static_cast<node_pointer>(get_bucket(bucket_count_)->next_);
+              static_cast<node_pointer>(get_bucket(bucket_count_)->next_);
 
             if (bucket::extra_node) {
-                node_pointer next = next_node(n);
-                boost::unordered::detail::func::destroy(pointer<node>::get(n));
-                node_allocator_traits::deallocate(node_alloc(), n, 1);
-                n = next;
+              node_pointer next = next_node(n);
+              boost::unordered::detail::func::destroy(pointer<node>::get(n));
+              node_allocator_traits::deallocate(node_alloc(), n, 1);
+              n = next;
             }
 
             while (n) {
-                node_pointer next = next_node(n);
-                destroy_node(n);
-                n = next;
+              node_pointer next = next_node(n);
+              destroy_node(n);
+              n = next;
             }
 
             destroy_buckets();
             buckets_ = bucket_pointer();
             max_load_ = 0;
             size_ = 0;
+          }
         }
-    }
 
-    void destroy_buckets()
-    {
-        bucket_pointer end = get_bucket(bucket_count_ + 1);
-        for (bucket_pointer it = buckets_; it != end; ++it) {
+        void destroy_buckets()
+        {
+          bucket_pointer end = get_bucket(bucket_count_ + 1);
+          for (bucket_pointer it = buckets_; it != end; ++it) {
             boost::unordered::detail::func::destroy(pointer<bucket>::get(it));
+          }
+
+          bucket_allocator_traits::deallocate(
+            bucket_alloc(), buckets_, bucket_count_ + 1);
         }
 
-        bucket_allocator_traits::deallocate(
-            bucket_alloc(), buckets_, bucket_count_ + 1);
-    }
+        ////////////////////////////////////////////////////////////////////////
+        // Fix buckets after delete/extract
+        //
+        // (prev,next) should mark an open range of nodes in a single bucket
+        // which
+        // have either been unlinked, or are about to be.
 
-    ////////////////////////////////////////////////////////////////////////
-    // Fix buckets after delete/extract
-    //
-    // (prev,next) should mark an open range of nodes in a single bucket which
-    // have either been unlinked, or are about to be.
+        std::size_t fix_bucket(
+          std::size_t bucket_index, link_pointer prev, node_pointer next)
+        {
+          std::size_t bucket_index2 = bucket_index;
 
-    std::size_t fix_bucket(
-        std::size_t bucket_index, link_pointer prev, node_pointer next)
-    {
-        std::size_t bucket_index2 = bucket_index;
-
-        if (next) {
+          if (next) {
             bucket_index2 = node_bucket(next);
 
             // If next is in the same bucket, then there's nothing to do.
             if (bucket_index == bucket_index2) {
-                return bucket_index2;
+              return bucket_index2;
             }
 
             // Update the bucket containing next.
             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) {
+          // 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;
         }
 
-        return bucket_index2;
-    }
+        ////////////////////////////////////////////////////////////////////////
+        // Clear
 
-    ////////////////////////////////////////////////////////////////////////
-    // Clear
+        void clear_impl();
 
-    void clear_impl();
+        ////////////////////////////////////////////////////////////////////////
+        // Assignment
 
-    ////////////////////////////////////////////////////////////////////////
-    // Assignment
-
-    template <typename UniqueType>
-    void assign(table const& x, UniqueType is_unique)
-    {
-        if (this != &x) {
+        template <typename UniqueType>
+        void assign(table const& x, UniqueType is_unique)
+        {
+          if (this != &x) {
             assign(x, is_unique,
-                boost::unordered::detail::integral_constant<bool,
-                       allocator_traits<node_allocator>::
-                           propagate_on_container_copy_assignment::value>());
+              boost::unordered::detail::integral_constant<bool,
+                     allocator_traits<node_allocator>::
+                       propagate_on_container_copy_assignment::value>());
+          }
         }
-    }
 
-    template <typename UniqueType>
-    void assign(table const& x, UniqueType is_unique, false_type)
-    {
-        // Strong exception safety.
-        set_hash_functions new_func_this(*this, x);
-        mlf_ = x.mlf_;
-        recalculate_max_load();
+        template <typename UniqueType>
+        void assign(table const& x, UniqueType is_unique, false_type)
+        {
+          // Strong exception safety.
+          set_hash_functions new_func_this(*this, x);
+          mlf_ = x.mlf_;
+          recalculate_max_load();
 
-        if (x.size_ >= max_load_) {
+          if (x.size_ >= max_load_) {
             create_buckets(min_buckets_for_size(x.size_));
-        } else if (size_) {
+          } else if (size_) {
             clear_buckets();
+          }
+
+          new_func_this.commit();
+
+          assign_buckets(x, is_unique);
         }
 
-        new_func_this.commit();
-
-        assign_buckets(x, is_unique);
-    }
-
-    template <typename UniqueType>
-    void assign(table const& x, UniqueType is_unique, true_type)
-    {
-        if (node_alloc() == x.node_alloc()) {
+        template <typename UniqueType>
+        void assign(table const& x, UniqueType is_unique, true_type)
+        {
+          if (node_alloc() == x.node_alloc()) {
             allocators_.assign(x.allocators_);
             assign(x, is_unique, false_type());
-        } else {
+          } else {
             set_hash_functions new_func_this(*this, x);
 
             // Delete everything with current allocators before assigning
@@ -3182,492 +3246,493 @@ struct table : boost::unordered::detail::functions<typename Types::hasher,
 
             // Finally copy the elements.
             if (x.size_) {
-                copy_buckets(x, is_unique);
+              copy_buckets(x, is_unique);
             }
+          }
         }
-    }
 
-    template <typename UniqueType>
-    void move_assign(table& x, UniqueType is_unique)
-    {
-        if (this != &x) {
-            move_assign(
-                x, is_unique,
-                boost::unordered::detail::integral_constant<bool,
-                    allocator_traits<node_allocator>::
-                        propagate_on_container_move_assignment::value>());
+        template <typename UniqueType>
+        void move_assign(table& x, UniqueType is_unique)
+        {
+          if (this != &x) {
+            move_assign(x, is_unique,
+              boost::unordered::detail::integral_constant<bool,
+                          allocator_traits<node_allocator>::
+                            propagate_on_container_move_assignment::value>());
+          }
         }
-    }
 
-    template <typename UniqueType>
-    void move_assign(table& x, UniqueType, true_type)
-    {
-        delete_buckets();
-        set_hash_functions new_func_this(*this, x);
-        allocators_.move_assign(x.allocators_);
-        // No throw from here.
-        mlf_ = x.mlf_;
-        move_buckets_from(x);
-        new_func_this.commit();
-    }
+        template <typename UniqueType>
+        void move_assign(table& x, UniqueType, true_type)
+        {
+          delete_buckets();
+          set_hash_functions new_func_this(*this, x);
+          allocators_.move_assign(x.allocators_);
+          // No throw from here.
+          mlf_ = x.mlf_;
+          move_buckets_from(x);
+          new_func_this.commit();
+        }
 
-    template <typename UniqueType>
-    void move_assign(table& x, UniqueType is_unique, false_type)
-    {
-        if (node_alloc() == x.node_alloc()) {
+        template <typename UniqueType>
+        void move_assign(table& x, UniqueType is_unique, 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_;
             move_buckets_from(x);
             new_func_this.commit();
-        } else {
+          } else {
             set_hash_functions new_func_this(*this, x);
             mlf_ = x.mlf_;
             recalculate_max_load();
 
             if (x.size_ >= max_load_) {
-                create_buckets(min_buckets_for_size(x.size_));
+              create_buckets(min_buckets_for_size(x.size_));
             } else if (size_) {
-                clear_buckets();
+              clear_buckets();
             }
 
             new_func_this.commit();
 
             move_assign_buckets(x, is_unique);
+          }
         }
-    }
 
-    // Accessors
+        // Accessors
 
-    const_key_type& get_key(node_pointer n) const
-    {
-        return extractor::extract(n->value());
-    }
+        const_key_type& get_key(node_pointer n) const
+        {
+          return extractor::extract(n->value());
+        }
 
-    std::size_t hash(const_key_type& k) const
-    {
-        return policy::apply_hash(this->hash_function(), k);
-    }
+        std::size_t hash(const_key_type& k) const
+        {
+          return policy::apply_hash(this->hash_function(), k);
+        }
 
-    // Find Node
+        // Find Node
 
-    node_pointer find_node(std::size_t key_hash, const_key_type& k) const
-    {
-        return this->find_node_impl(key_hash, k, this->key_eq());
-    }
+        node_pointer find_node(std::size_t key_hash, const_key_type& k) const
+        {
+          return this->find_node_impl(key_hash, k, this->key_eq());
+        }
 
-    node_pointer find_node(const_key_type& k) const
-    {
-        return this->find_node_impl(hash(k), k, this->key_eq());
-    }
+        node_pointer find_node(const_key_type& k) const
+        {
+          return this->find_node_impl(hash(k), k, this->key_eq());
+        }
 
-    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);
+        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 (;;) {
+          for (;;) {
             if (!n)
-                return n;
+              return n;
 
             if (eq(k, this->get_key(n))) {
-                return n;
+              return n;
             } else if (this->node_bucket(n) != bucket_index) {
-                return node_pointer();
+              return node_pointer();
             }
 
             n = next_for_find(n);
+          }
         }
-    }
 
-    // Find the node before the key, so that it can be erased.
-    link_pointer find_previous_node(const_key_type& k, std::size_t bucket_index)
-    {
-        link_pointer prev = this->get_previous_start(bucket_index);
-        if (!prev) {
+        // Find the node before the key, so that it can be erased.
+        link_pointer find_previous_node(
+          const_key_type& k, std::size_t bucket_index)
+        {
+          link_pointer prev = this->get_previous_start(bucket_index);
+          if (!prev) {
             return prev;
-        }
+          }
 
-        for (;;) {
+          for (;;) {
             node_pointer n = next_node(prev);
             if (!n) {
-                return link_pointer();
+              return link_pointer();
             } else if (n->is_first_in_group()) {
-                if (node_bucket(n) != bucket_index) {
-                    return link_pointer();
-                } else if (this->key_eq()(k, this->get_key(n))) {
-                    return prev;
-                }
+              if (node_bucket(n) != bucket_index) {
+                return link_pointer();
+              } else if (this->key_eq()(k, this->get_key(n))) {
+                return prev;
+              }
             }
             prev = n;
+          }
         }
-    }
 
-    // Extract and erase
+        // Extract and erase
 
-    inline node_pointer extract_by_key(const_key_type& k)
-    {
-        if (!this->size_) {
+        inline node_pointer extract_by_key(const_key_type& k)
+        {
+          if (!this->size_) {
             return node_pointer();
-        }
-        std::size_t key_hash = this->hash(k);
-        std::size_t bucket_index = this->hash_to_bucket(key_hash);
-        link_pointer prev = this->find_previous_node(k, bucket_index);
-        if (!prev) {
+          }
+          std::size_t key_hash = this->hash(k);
+          std::size_t bucket_index = this->hash_to_bucket(key_hash);
+          link_pointer prev = this->find_previous_node(k, bucket_index);
+          if (!prev) {
             return node_pointer();
-        }
-        node_pointer n = next_node(prev);
-        node_pointer n2 = next_node(n);
-        if (n2) {
+          }
+          node_pointer n = next_node(prev);
+          node_pointer n2 = next_node(n);
+          if (n2) {
             n2->set_first_in_group();
+          }
+          prev->next_ = n2;
+          --this->size_;
+          this->fix_bucket(bucket_index, prev, n2);
+          n->next_ = link_pointer();
+
+          return n;
         }
-        prev->next_ = n2;
-        --this->size_;
-        this->fix_bucket(bucket_index, prev, n2);
-        n->next_ = link_pointer();
 
-        return n;
-    }
+        // Reserve and rehash
 
-    // Reserve and rehash
+        void reserve_for_insert(std::size_t);
+        void rehash(std::size_t);
+        void reserve(std::size_t);
+        void rehash_impl(std::size_t);
 
-    void reserve_for_insert(std::size_t);
-    void rehash(std::size_t);
-    void reserve(std::size_t);
-    void rehash_impl(std::size_t);
+        ////////////////////////////////////////////////////////////////////////
+        // Unique keys
 
-    ////////////////////////////////////////////////////////////////////////
-    // Unique keys
+        // equals
 
-    // equals
-
-    bool equals_unique(table const& other) const
-    {
-        if (this->size_ != other.size_)
+        bool equals_unique(table const& other) const
+        {
+          if (this->size_ != other.size_)
             return false;
 
-        for (node_pointer n1 = this->begin(); n1; n1 = next_node(n1)) {
+          for (node_pointer n1 = this->begin(); n1; n1 = next_node(n1)) {
             node_pointer n2 = other.find_node(other.get_key(n1));
 
             if (!n2 || n1->value() != n2->value())
-                return false;
+              return false;
+          }
+
+          return true;
         }
 
-        return true;
-    }
+        // Emplace/Insert
 
-    // Emplace/Insert
+        inline node_pointer add_node_unique(
+          node_pointer n, std::size_t key_hash)
+        {
+          std::size_t bucket_index = this->hash_to_bucket(key_hash);
+          bucket_pointer b = this->get_bucket(bucket_index);
 
-    inline node_pointer add_node_unique(node_pointer n, std::size_t key_hash)
-    {
-        std::size_t bucket_index = this->hash_to_bucket(key_hash);
-        bucket_pointer b = this->get_bucket(bucket_index);
+          // TODO: Do this need to set_first_in_group ?
+          n->bucket_info_ = bucket_index;
+          // n->set_first_in_group();
 
-        // TODO: Do this need to set_first_in_group ?
-        n->bucket_info_ = bucket_index;
-        // n->set_first_in_group();
-
-        if (!b->next_) {
+          if (!b->next_) {
             link_pointer start_node = this->get_previous_start();
 
             if (start_node->next_) {
-                this->get_bucket(node_bucket(next_node(start_node)))->next_ = n;
+              this->get_bucket(node_bucket(next_node(start_node)))->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_unique(
+          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_unique(b.release(), key_hash);
+        }
 
-    inline node_pointer resize_and_add_node_unique(
-        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_unique(b.release(), key_hash);
-    }
-
-    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-    iterator emplace_hint_unique(
-        c_iterator hint, const_key_type& k, BOOST_UNORDERED_EMPLACE_ARGS)
-    {
-        if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        iterator emplace_hint_unique(
+          c_iterator hint, const_key_type& k, BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+          if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
             return iterator(hint.node_);
-        } else {
+          } else {
             return emplace_unique(k, BOOST_UNORDERED_EMPLACE_FORWARD).first;
+          }
         }
-    }
 
-    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-    emplace_return emplace_unique(
-        const_key_type& k, BOOST_UNORDERED_EMPLACE_ARGS)
-    {
-        std::size_t key_hash = this->hash(k);
-        node_pointer pos = this->find_node(key_hash, k);
-        if (pos) {
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace_unique(
+          const_key_type& 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 {
+          } else {
             return emplace_return(
-                iterator(this->resize_and_add_node_unique(
-                    boost::unordered::detail::func::construct_node_from_args(
-                        this->node_alloc(), BOOST_UNORDERED_EMPLACE_FORWARD),
-                    key_hash)),
-                true);
+              iterator(this->resize_and_add_node_unique(
+                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_unique(
-        c_iterator hint, no_key, BOOST_UNORDERED_EMPLACE_ARGS)
-    {
-        node_tmp b(boost::unordered::detail::func::construct_node_from_args(
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        iterator emplace_hint_unique(
+          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());
-        const_key_type& k = this->get_key(b.node_);
-        if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
+          const_key_type& k = this->get_key(b.node_);
+          if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
             return iterator(hint.node_);
-        }
-        std::size_t key_hash = this->hash(k);
-        node_pointer pos = this->find_node(key_hash, k);
-        if (pos) {
+          }
+          std::size_t key_hash = this->hash(k);
+          node_pointer pos = this->find_node(key_hash, k);
+          if (pos) {
             return iterator(pos);
-        } else {
+          } else {
             return iterator(
-                this->resize_and_add_node_unique(b.release(), key_hash));
+              this->resize_and_add_node_unique(b.release(), key_hash));
+          }
         }
-    }
 
-    template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
-    emplace_return emplace_unique(no_key, BOOST_UNORDERED_EMPLACE_ARGS)
-    {
-        node_tmp b(boost::unordered::detail::func::construct_node_from_args(
+        template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return emplace_unique(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());
-        const_key_type& k = this->get_key(b.node_);
-        std::size_t key_hash = this->hash(k);
-        node_pointer pos = this->find_node(key_hash, k);
-        if (pos) {
+          const_key_type& k = this->get_key(b.node_);
+          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_unique(
-                                      b.release(), key_hash)),
-                true);
-        }
-    }
-
-    template <typename Key>
-    emplace_return try_emplace_unique(BOOST_FWD_REF(Key) k)
-    {
-        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 {
+          } else {
             return emplace_return(
-                iterator(this->resize_and_add_node_unique(
-                    boost::unordered::detail::func::construct_node_pair(
-                        this->node_alloc(), boost::forward<Key>(k)),
-                    key_hash)),
-                true);
+              iterator(this->resize_and_add_node_unique(b.release(), key_hash)),
+              true);
+          }
         }
-    }
 
-    template <typename Key>
-    iterator try_emplace_hint_unique(c_iterator hint, BOOST_FWD_REF(Key) k)
-    {
-        if (hint.node_ && this->key_eq()(hint->first, k)) {
+        template <typename Key>
+        emplace_return try_emplace_unique(BOOST_FWD_REF(Key) k)
+        {
+          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_unique(
+                boost::unordered::detail::func::construct_node_pair(
+                  this->node_alloc(), boost::forward<Key>(k)),
+                key_hash)),
+              true);
+          }
+        }
+
+        template <typename Key>
+        iterator try_emplace_hint_unique(c_iterator hint, BOOST_FWD_REF(Key) k)
+        {
+          if (hint.node_ && this->key_eq()(hint->first, k)) {
             return iterator(hint.node_);
-        } else {
+          } else {
             return try_emplace_unique(k).first;
+          }
         }
-    }
 
-    template <typename Key, BOOST_UNORDERED_EMPLACE_TEMPLATE>
-    emplace_return try_emplace_unique(
-        BOOST_FWD_REF(Key) k, BOOST_UNORDERED_EMPLACE_ARGS)
-    {
-        std::size_t key_hash = this->hash(k);
-        node_pointer pos = this->find_node(key_hash, k);
-        if (pos) {
+        template <typename Key, BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        emplace_return try_emplace_unique(
+          BOOST_FWD_REF(Key) 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 {
+          } else {
             return emplace_return(
-                iterator(this->resize_and_add_node_unique(
-                    boost::unordered::detail::func::
-                        construct_node_pair_from_args(this->node_alloc(),
-                            boost::forward<Key>(k),
-                            BOOST_UNORDERED_EMPLACE_FORWARD),
-                    key_hash)),
-                true);
+              iterator(this->resize_and_add_node_unique(
+                boost::unordered::detail::func::construct_node_pair_from_args(
+                  this->node_alloc(), boost::forward<Key>(k),
+                  BOOST_UNORDERED_EMPLACE_FORWARD),
+                key_hash)),
+              true);
+          }
         }
-    }
 
-    template <typename Key, BOOST_UNORDERED_EMPLACE_TEMPLATE>
-    iterator try_emplace_hint_unique(
-        c_iterator hint, BOOST_FWD_REF(Key) k, BOOST_UNORDERED_EMPLACE_ARGS)
-    {
-        if (hint.node_ && this->key_eq()(hint->first, k)) {
+        template <typename Key, BOOST_UNORDERED_EMPLACE_TEMPLATE>
+        iterator try_emplace_hint_unique(
+          c_iterator hint, BOOST_FWD_REF(Key) k, BOOST_UNORDERED_EMPLACE_ARGS)
+        {
+          if (hint.node_ && this->key_eq()(hint->first, k)) {
             return iterator(hint.node_);
-        } else {
+          } else {
             return try_emplace_unique(k, BOOST_UNORDERED_EMPLACE_FORWARD).first;
+          }
         }
-    }
 
-    template <typename Key, typename M>
-    emplace_return insert_or_assign_unique(
-        BOOST_FWD_REF(Key) k, BOOST_FWD_REF(M) obj)
-    {
-        std::size_t key_hash = this->hash(k);
-        node_pointer pos = this->find_node(key_hash, k);
+        template <typename Key, typename M>
+        emplace_return insert_or_assign_unique(
+          BOOST_FWD_REF(Key) k, BOOST_FWD_REF(M) obj)
+        {
+          std::size_t key_hash = this->hash(k);
+          node_pointer pos = this->find_node(key_hash, k);
 
-        if (pos) {
+          if (pos) {
             pos->value().second = boost::forward<M>(obj);
             return emplace_return(iterator(pos), false);
-        } else {
+          } else {
             return emplace_return(
-                iterator(this->resize_and_add_node_unique(
-                    boost::unordered::detail::func::construct_node_pair(
-                        this->node_alloc(), boost::forward<Key>(k),
-                        boost::forward<M>(obj)),
-                    key_hash)),
-                true);
+              iterator(this->resize_and_add_node_unique(
+                boost::unordered::detail::func::construct_node_pair(
+                  this->node_alloc(), boost::forward<Key>(k),
+                  boost::forward<M>(obj)),
+                key_hash)),
+              true);
+          }
         }
-    }
 
-    template <typename NodeType, typename InsertReturnType>
-    void move_insert_node_type_unique(NodeType& np, InsertReturnType& result)
-    {
-        if (np) {
+        template <typename NodeType, typename InsertReturnType>
+        void move_insert_node_type_unique(
+          NodeType& np, InsertReturnType& result)
+        {
+          if (np) {
             const_key_type& k = this->get_key(np.ptr_);
             std::size_t key_hash = this->hash(k);
             node_pointer pos = this->find_node(key_hash, k);
 
             if (pos) {
-                result.node = boost::move(np);
-                result.position = iterator(pos);
+              result.node = boost::move(np);
+              result.position = iterator(pos);
             } else {
-                this->reserve_for_insert(this->size_ + 1);
-                result.position =
-                    iterator(this->add_node_unique(np.ptr_, key_hash));
-                result.inserted = true;
-                np.ptr_ = node_pointer();
+              this->reserve_for_insert(this->size_ + 1);
+              result.position =
+                iterator(this->add_node_unique(np.ptr_, key_hash));
+              result.inserted = true;
+              np.ptr_ = node_pointer();
             }
+          }
         }
-    }
 
-    template <typename NodeType>
-    iterator move_insert_node_type_with_hint_unique(
-        c_iterator hint, NodeType& np)
-    {
-        if (!np) {
+        template <typename NodeType>
+        iterator move_insert_node_type_with_hint_unique(
+          c_iterator hint, NodeType& np)
+        {
+          if (!np) {
             return iterator();
-        }
-        const_key_type& k = this->get_key(np.ptr_);
-        if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
+          }
+          const_key_type& k = this->get_key(np.ptr_);
+          if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
             return iterator(hint.node_);
-        }
-        std::size_t key_hash = this->hash(k);
-        node_pointer pos = this->find_node(key_hash, k);
-        if (!pos) {
+          }
+          std::size_t key_hash = this->hash(k);
+          node_pointer pos = this->find_node(key_hash, k);
+          if (!pos) {
             this->reserve_for_insert(this->size_ + 1);
             pos = this->add_node_unique(np.ptr_, key_hash);
             np.ptr_ = node_pointer();
+          }
+          return iterator(pos);
         }
-        return iterator(pos);
-    }
 
-    template <typename Types2>
-    void merge_unique(boost::unordered::detail::table<Types2>& other)
-    {
-        typedef boost::unordered::detail::table<Types2> other_table;
-        BOOST_STATIC_ASSERT(
+        template <typename Types2>
+        void merge_unique(boost::unordered::detail::table<Types2>& other)
+        {
+          typedef boost::unordered::detail::table<Types2> other_table;
+          BOOST_STATIC_ASSERT(
             (boost::is_same<node, typename other_table::node>::value));
-        BOOST_ASSERT(this->node_alloc() == other.node_alloc());
+          BOOST_ASSERT(this->node_alloc() == other.node_alloc());
 
-        if (other.size_) {
+          if (other.size_) {
             link_pointer prev = other.get_previous_start();
 
             while (prev->next_) {
-                node_pointer n = other_table::next_node(prev);
-                const_key_type& k = this->get_key(n);
-                std::size_t key_hash = this->hash(k);
-                node_pointer pos = this->find_node(key_hash, k);
+              node_pointer n = other_table::next_node(prev);
+              const_key_type& k = this->get_key(n);
+              std::size_t key_hash = this->hash(k);
+              node_pointer pos = this->find_node(key_hash, k);
 
-                if (pos) {
-                    prev = n;
-                } else {
-                    this->reserve_for_insert(this->size_ + 1);
-                    node_pointer n2 = next_node(n);
-                    prev->next_ = n2;
-                    if (n2 && n->is_first_in_group()) {
-                        n2->set_first_in_group();
-                    }
-                    --other.size_;
-                    other.fix_bucket(other.node_bucket(n), prev, n2);
-                    this->add_node_unique(n, key_hash);
+              if (pos) {
+                prev = n;
+              } else {
+                this->reserve_for_insert(this->size_ + 1);
+                node_pointer n2 = next_node(n);
+                prev->next_ = n2;
+                if (n2 && n->is_first_in_group()) {
+                  n2->set_first_in_group();
                 }
+                --other.size_;
+                other.fix_bucket(other.node_bucket(n), prev, n2);
+                this->add_node_unique(n, key_hash);
+              }
             }
+          }
         }
-    }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Insert range methods
-    //
-    // if hash function throws, or inserting > 1 element, basic exception
-    // safety strong otherwise
+        ////////////////////////////////////////////////////////////////////////
+        // Insert range methods
+        //
+        // if hash function throws, or inserting > 1 element, basic exception
+        // safety strong otherwise
 
-    template <class InputIt>
-    void insert_range_unique(const_key_type& k, InputIt i, InputIt j)
-    {
-        insert_range_unique2(k, i, j);
+        template <class InputIt>
+        void insert_range_unique(const_key_type& k, InputIt i, InputIt j)
+        {
+          insert_range_unique2(k, i, j);
 
-        while (++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.
             insert_range_unique2(extractor::extract(*i), i, j);
+          }
         }
-    }
 
-    template <class InputIt>
-    void insert_range_unique2(const_key_type& 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);
+        template <class InputIt>
+        void insert_range_unique2(const_key_type& 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) {
+          if (!pos) {
             node_tmp b(boost::unordered::detail::func::construct_node(
-                           this->node_alloc(), *i),
-                this->node_alloc());
+                         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->reserve_for_insert(
+                this->size_ + boost::unordered::detail::insert_size(i, j));
             this->add_node_unique(b.release(), key_hash);
+          }
         }
-    }
 
-    template <class InputIt>
-    void insert_range_unique(no_key, InputIt i, InputIt j)
-    {
-        node_constructor a(this->node_alloc());
+        template <class InputIt>
+        void insert_range_unique(no_key, InputIt i, InputIt j)
+        {
+          node_constructor a(this->node_alloc());
 
-        do {
+          do {
             if (!a.node_) {
-                a.create_node();
+              a.create_node();
             }
             BOOST_UNORDERED_CALL_CONSTRUCT1(
-                node_allocator_traits, a.alloc_, a.node_->value_ptr(), *i);
+              node_allocator_traits, a.alloc_, a.node_->value_ptr(), *i);
             node_tmp b(a.release(), a.alloc_);
 
             const_key_type& k = this->get_key(b.node_);
@@ -3675,623 +3740,625 @@ struct table : boost::unordered::detail::functions<typename Types::hasher,
             node_pointer pos = this->find_node(key_hash, k);
 
             if (pos) {
-                a.reclaim(b.release());
+              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_unique(b.release(), key_hash);
+              // reserve has basic exception safety if the hash function
+              // throws, strong otherwise.
+              this->reserve_for_insert(this->size_ + 1);
+              this->add_node_unique(b.release(), key_hash);
             }
-        } while (++i != j);
-    }
-
-    ////////////////////////////////////////////////////////////////////////
-    // Extract
-
-    inline node_pointer extract_by_iterator_unique(c_iterator i)
-    {
-        node_pointer n = i.node_;
-        BOOST_ASSERT(n);
-        std::size_t bucket_index = this->node_bucket(n);
-        link_pointer prev = this->get_previous_start(bucket_index);
-        while (prev->next_ != n) {
-            prev = prev->next_;
+          } while (++i != j);
         }
-        node_pointer n2 = next_node(n);
-        prev->next_ = n2;
-        --this->size_;
-        this->fix_bucket(bucket_index, prev, n2);
-        n->next_ = link_pointer();
-        return n;
-    }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Erase
-    //
-    // no throw
+        ////////////////////////////////////////////////////////////////////////
+        // Extract
 
-    std::size_t erase_key_unique(const_key_type& k)
-    {
-        if (!this->size_)
+        inline node_pointer extract_by_iterator_unique(c_iterator i)
+        {
+          node_pointer n = i.node_;
+          BOOST_ASSERT(n);
+          std::size_t bucket_index = this->node_bucket(n);
+          link_pointer prev = this->get_previous_start(bucket_index);
+          while (prev->next_ != n) {
+            prev = prev->next_;
+          }
+          node_pointer n2 = next_node(n);
+          prev->next_ = n2;
+          --this->size_;
+          this->fix_bucket(bucket_index, prev, n2);
+          n->next_ = link_pointer();
+          return n;
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Erase
+        //
+        // no throw
+
+        std::size_t erase_key_unique(const_key_type& 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->find_previous_node(k, bucket_index);
-        if (!prev)
+          std::size_t key_hash = this->hash(k);
+          std::size_t bucket_index = this->hash_to_bucket(key_hash);
+          link_pointer prev = this->find_previous_node(k, bucket_index);
+          if (!prev)
             return 0;
-        node_pointer n = next_node(prev);
-        node_pointer n2 = next_node(n);
-        prev->next_ = n2;
-        --size_;
-        this->fix_bucket(bucket_index, prev, n2);
-        this->destroy_node(n);
-        return 1;
-    }
+          node_pointer n = next_node(prev);
+          node_pointer n2 = next_node(n);
+          prev->next_ = n2;
+          --size_;
+          this->fix_bucket(bucket_index, prev, n2);
+          this->destroy_node(n);
+          return 1;
+        }
 
-    void erase_nodes_unique(node_pointer i, node_pointer j)
-    {
-        std::size_t bucket_index = this->node_bucket(i);
+        void erase_nodes_unique(node_pointer i, node_pointer j)
+        {
+          std::size_t bucket_index = this->node_bucket(i);
 
-        // Find the node before i.
-        link_pointer prev = this->get_previous_start(bucket_index);
-        while (prev->next_ != i)
+          // Find the node before i.
+          link_pointer prev = this->get_previous_start(bucket_index);
+          while (prev->next_ != i)
             prev = prev->next_;
 
-        // Delete the nodes.
-        prev->next_ = j;
-        do {
+          // Delete the nodes.
+          prev->next_ = j;
+          do {
             node_pointer next = next_node(i);
             destroy_node(i);
             --size_;
             bucket_index = this->fix_bucket(bucket_index, prev, next);
             i = next;
-        } while (i != j);
-    }
+          } while (i != j);
+        }
 
-    ////////////////////////////////////////////////////////////////////////
-    // fill_buckets_unique
+        ////////////////////////////////////////////////////////////////////////
+        // fill_buckets_unique
 
-    void copy_buckets(table const& src, true_type)
-    {
-        this->create_buckets(this->bucket_count_);
+        void copy_buckets(table const& src, true_type)
+        {
+          this->create_buckets(this->bucket_count_);
 
-        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+          for (node_pointer n = src.begin(); n; n = next_node(n)) {
             std::size_t key_hash = this->hash(this->get_key(n));
             this->add_node_unique(
-                boost::unordered::detail::func::construct_node(
-                    this->node_alloc(), n->value()),
-                key_hash);
+              boost::unordered::detail::func::construct_node(
+                this->node_alloc(), n->value()),
+              key_hash);
+          }
         }
-    }
 
-    // TODO: Should be move_buckets_uniq
-    void move_buckets(table const& src)
-    {
-        this->create_buckets(this->bucket_count_);
+        // TODO: Should be move_buckets_uniq
+        void move_buckets(table const& src)
+        {
+          this->create_buckets(this->bucket_count_);
 
-        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+          for (node_pointer n = src.begin(); n; n = next_node(n)) {
             std::size_t key_hash = this->hash(this->get_key(n));
             this->add_node_unique(
-                boost::unordered::detail::func::construct_node(
-                    this->node_alloc(), boost::move(n->value())),
-                key_hash);
+              boost::unordered::detail::func::construct_node(
+                this->node_alloc(), boost::move(n->value())),
+              key_hash);
+          }
         }
-    }
 
-    void assign_buckets(table const& src, true_type)
-    {
-        node_holder<node_allocator> holder(*this);
-        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+        void assign_buckets(table const& src, true_type)
+        {
+          node_holder<node_allocator> holder(*this);
+          for (node_pointer n = src.begin(); n; n = next_node(n)) {
             std::size_t key_hash = this->hash(this->get_key(n));
             this->add_node_unique(holder.copy_of(n->value()), key_hash);
+          }
         }
-    }
 
-    void move_assign_buckets(table& src, true_type)
-    {
-        node_holder<node_allocator> holder(*this);
-        for (node_pointer n = src.begin(); n; n = next_node(n)) {
+        void move_assign_buckets(table& src, true_type)
+        {
+          node_holder<node_allocator> holder(*this);
+          for (node_pointer n = src.begin(); n; n = next_node(n)) {
             std::size_t key_hash = this->hash(this->get_key(n));
             this->add_node_unique(holder.move_copy_of(n->value()), key_hash);
+          }
         }
-    }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Equivalent keys
+        ////////////////////////////////////////////////////////////////////////
+        // Equivalent keys
 
-    // Equality
+        // Equality
 
-    bool equals_equiv(table const& other) const
-    {
-        if (this->size_ != other.size_)
+        bool equals_equiv(table const& other) const
+        {
+          if (this->size_ != other.size_)
             return false;
 
-        for (node_pointer n1 = this->begin(); n1;) {
+          for (node_pointer n1 = this->begin(); n1;) {
             node_pointer n2 = other.find_node(other.get_key(n1));
             if (!n2)
-                return false;
+              return false;
             node_pointer end1 = next_group(n1);
             node_pointer end2 = next_group(n2);
             if (!group_equals_equiv(n1, end1, n2, end2))
-                return false;
+              return false;
             n1 = end1;
+          }
+
+          return true;
         }
 
-        return true;
-    }
-
-    static bool group_equals_equiv(
-        node_pointer n1, node_pointer end1, node_pointer n2, node_pointer end2)
-    {
-        for (;;) {
+        static bool group_equals_equiv(node_pointer n1, node_pointer end1,
+          node_pointer n2, node_pointer end2)
+        {
+          for (;;) {
             if (n1->value() != n2->value())
-                break;
+              break;
 
             n1 = next_node(n1);
             n2 = next_node(n2);
 
             if (n1 == end1)
-                return n2 == end2;
+              return n2 == end2;
             if (n2 == end2)
-                return false;
-        }
+              return false;
+          }
 
-        for (node_pointer n1a = n1, n2a = n2;;) {
+          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)
+                break;
+              else
+                return false;
             }
 
             if (n2a == end2)
-                return false;
-        }
+              return false;
+          }
 
-        node_pointer start = n1;
-        for (; n1 != end1; n1 = next_node(n1)) {
+          node_pointer start = n1;
+          for (; n1 != end1; n1 = next_node(n1)) {
             value_type const& v = n1->value();
             if (!find_equiv(start, n1, v)) {
-                std::size_t matches = count_equal_equiv(n2, end2, v);
-                if (!matches)
-                    return false;
-                if (matches != 1 + count_equal_equiv(next_node(n1), end1, v))
-                    return false;
+              std::size_t matches = count_equal_equiv(n2, end2, v);
+              if (!matches)
+                return false;
+              if (matches != 1 + count_equal_equiv(next_node(n1), end1, v))
+                return false;
             }
+          }
+
+          return true;
         }
 
-        return true;
-    }
-
-    static bool find_equiv(
-        node_pointer n, node_pointer end, value_type const& v)
-    {
-        for (; n != end; n = next_node(n))
+        static bool find_equiv(
+          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;
-    }
+              return true;
+          return false;
+        }
 
-    static std::size_t count_equal_equiv(
-        node_pointer n, node_pointer end, value_type const& v)
-    {
-        std::size_t count = 0;
-        for (; n != end; n = next_node(n))
+        static std::size_t count_equal_equiv(
+          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;
-    }
+              ++count;
+          return count;
+        }
 
-    // Emplace/Insert
+        // Emplace/Insert
 
-    inline node_pointer add_node_equiv(
-        node_pointer n, std::size_t key_hash, node_pointer pos)
-    {
-        std::size_t bucket_index = this->hash_to_bucket(key_hash);
-        n->bucket_info_ = bucket_index;
+        inline node_pointer add_node_equiv(
+          node_pointer n, std::size_t key_hash, node_pointer pos)
+        {
+          std::size_t bucket_index = this->hash_to_bucket(key_hash);
+          n->bucket_info_ = bucket_index;
 
-        if (pos) {
+          if (pos) {
             n->reset_first_in_group();
             n->next_ = pos->next_;
             pos->next_ = n;
             if (n->next_) {
-                std::size_t next_bucket = this->node_bucket(next_node(n));
-                if (next_bucket != bucket_index) {
-                    this->get_bucket(next_bucket)->next_ = n;
-                }
+              std::size_t next_bucket = this->node_bucket(next_node(n));
+              if (next_bucket != bucket_index) {
+                this->get_bucket(next_bucket)->next_ = n;
+              }
             }
-        } else {
+          } else {
             // n->set_first_in_group();
             bucket_pointer b = this->get_bucket(bucket_index);
 
             if (!b->next_) {
-                link_pointer start_node = this->get_previous_start();
+              link_pointer start_node = this->get_previous_start();
 
-                if (start_node->next_) {
-                    this->get_bucket(this->node_bucket(next_node(start_node)))
-                        ->next_ = n;
-                }
+              if (start_node->next_) {
+                this->get_bucket(this->node_bucket(next_node(start_node)))
+                  ->next_ = n;
+              }
 
-                b->next_ = start_node;
-                n->next_ = start_node->next_;
-                start_node->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;
+              n->next_ = b->next_->next_;
+              b->next_->next_ = n;
             }
+          }
+          ++this->size_;
+          return n;
         }
-        ++this->size_;
-        return n;
-    }
 
-    inline node_pointer add_using_hint_equiv(node_pointer n, node_pointer hint)
-    {
-        n->bucket_info_ = hint->bucket_info_;
-        n->reset_first_in_group();
-        n->next_ = hint->next_;
-        hint->next_ = n;
-        if (n->next_) {
+        inline node_pointer add_using_hint_equiv(
+          node_pointer n, node_pointer hint)
+        {
+          n->bucket_info_ = hint->bucket_info_;
+          n->reset_first_in_group();
+          n->next_ = hint->next_;
+          hint->next_ = n;
+          if (n->next_) {
             std::size_t next_bucket = this->node_bucket(next_node(n));
             if (next_bucket != this->node_bucket(n)) {
-                this->get_bucket(next_bucket)->next_ = n;
+              this->get_bucket(next_bucket)->next_ = n;
             }
+          }
+          ++this->size_;
+          return n;
         }
-        ++this->size_;
-        return n;
-    }
 
-    iterator emplace_equiv(node_pointer n)
-    {
-        node_tmp a(n, this->node_alloc());
-        const_key_type& k = this->get_key(a.node_);
-        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_equiv(a.release(), key_hash, position));
-    }
+        iterator emplace_equiv(node_pointer n)
+        {
+          node_tmp a(n, this->node_alloc());
+          const_key_type& k = this->get_key(a.node_);
+          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_equiv(a.release(), key_hash, position));
+        }
 
-    iterator emplace_hint_equiv(c_iterator hint, node_pointer n)
-    {
-        node_tmp a(n, this->node_alloc());
-        const_key_type& k = this->get_key(a.node_);
-        if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
+        iterator emplace_hint_equiv(c_iterator hint, node_pointer n)
+        {
+          node_tmp a(n, this->node_alloc());
+          const_key_type& k = this->get_key(a.node_);
+          if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
             this->reserve_for_insert(this->size_ + 1);
             return iterator(
-                this->add_using_hint_equiv(a.release(), hint.node_));
-        } else {
+              this->add_using_hint_equiv(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_equiv(a.release(), key_hash, position));
+              this->add_node_equiv(a.release(), key_hash, position));
+          }
         }
-    }
 
-    void emplace_no_rehash_equiv(node_pointer n)
-    {
-        node_tmp a(n, this->node_alloc());
-        const_key_type& k = this->get_key(a.node_);
-        std::size_t key_hash = this->hash(k);
-        node_pointer position = this->find_node(key_hash, k);
-        this->add_node_equiv(a.release(), key_hash, position);
-    }
+        void emplace_no_rehash_equiv(node_pointer n)
+        {
+          node_tmp a(n, this->node_alloc());
+          const_key_type& k = this->get_key(a.node_);
+          std::size_t key_hash = this->hash(k);
+          node_pointer position = this->find_node(key_hash, k);
+          this->add_node_equiv(a.release(), key_hash, position);
+        }
 
-    template <typename NodeType>
-    iterator move_insert_node_type_equiv(NodeType& np)
-    {
-        iterator result;
+        template <typename NodeType>
+        iterator move_insert_node_type_equiv(NodeType& np)
+        {
+          iterator result;
 
-        if (np) {
+          if (np) {
             const_key_type& k = this->get_key(np.ptr_);
             std::size_t key_hash = this->hash(k);
             node_pointer pos = this->find_node(key_hash, k);
             this->reserve_for_insert(this->size_ + 1);
             result = iterator(this->add_node_equiv(np.ptr_, key_hash, pos));
             np.ptr_ = node_pointer();
+          }
+
+          return result;
         }
 
-        return result;
-    }
+        template <typename NodeType>
+        iterator move_insert_node_type_with_hint_equiv(
+          c_iterator hint, NodeType& np)
+        {
+          iterator result;
 
-    template <typename NodeType>
-    iterator move_insert_node_type_with_hint_equiv(
-        c_iterator hint, NodeType& np)
-    {
-        iterator result;
-
-        if (np) {
+          if (np) {
             const_key_type& k = this->get_key(np.ptr_);
 
             if (hint.node_ && this->key_eq()(k, this->get_key(hint.node_))) {
-                this->reserve_for_insert(this->size_ + 1);
-                result =
-                    iterator(this->add_using_hint_equiv(np.ptr_, hint.node_));
+              this->reserve_for_insert(this->size_ + 1);
+              result =
+                iterator(this->add_using_hint_equiv(np.ptr_, hint.node_));
             } else {
-                std::size_t key_hash = this->hash(k);
-                node_pointer pos = this->find_node(key_hash, k);
-                this->reserve_for_insert(this->size_ + 1);
-                result = iterator(this->add_node_equiv(np.ptr_, key_hash, pos));
+              std::size_t key_hash = this->hash(k);
+              node_pointer pos = this->find_node(key_hash, k);
+              this->reserve_for_insert(this->size_ + 1);
+              result = iterator(this->add_node_equiv(np.ptr_, key_hash, pos));
             }
             np.ptr_ = node_pointer();
+          }
+
+          return result;
         }
 
-        return result;
-    }
+        ////////////////////////////////////////////////////////////////////////
+        // 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_equiv(I i, I j,
-        typename boost::unordered::detail::enable_if_forward<I, void*>::type =
+        // if hash function throws, or inserting > 1 element, basic exception
+        // safety. Strong otherwise
+        template <class I>
+        void insert_range_equiv(I i, I j,
+          typename boost::unordered::detail::enable_if_forward<I, void*>::type =
             0)
-    {
-        if (i == j)
+        {
+          if (i == j)
             return;
 
-        std::size_t distance = static_cast<std::size_t>(std::distance(i, j));
-        if (distance == 1) {
+          std::size_t distance = static_cast<std::size_t>(std::distance(i, j));
+          if (distance == 1) {
             emplace_equiv(boost::unordered::detail::func::construct_node(
-                this->node_alloc(), *i));
-        } else {
+              this->node_alloc(), *i));
+          } else {
             // Only require basic exception safety here
             this->reserve_for_insert(this->size_ + distance);
 
             for (; i != j; ++i) {
-                emplace_no_rehash_equiv(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), *i));
+              emplace_no_rehash_equiv(
+                boost::unordered::detail::func::construct_node(
+                  this->node_alloc(), *i));
             }
+          }
         }
-    }
 
-    template <class I>
-    void insert_range_equiv(I i, I j,
-        typename boost::unordered::detail::disable_if_forward<I, void*>::type =
-            0)
-    {
-        for (; i != j; ++i) {
+        template <class I>
+        void insert_range_equiv(
+          I i, I j, typename boost::unordered::detail::disable_if_forward<I,
+                      void*>::type = 0)
+        {
+          for (; i != j; ++i) {
             emplace_equiv(boost::unordered::detail::func::construct_node(
-                this->node_alloc(), *i));
+              this->node_alloc(), *i));
+          }
         }
-    }
 
-    ////////////////////////////////////////////////////////////////////////
-    // Extract
+        ////////////////////////////////////////////////////////////////////////
+        // Extract
 
-    inline node_pointer extract_by_iterator_equiv(c_iterator n)
-    {
-        node_pointer i = n.node_;
-        BOOST_ASSERT(i);
-        node_pointer j(next_node(i));
-        std::size_t bucket_index = this->node_bucket(i);
+        inline node_pointer extract_by_iterator_equiv(c_iterator n)
+        {
+          node_pointer i = n.node_;
+          BOOST_ASSERT(i);
+          node_pointer j(next_node(i));
+          std::size_t bucket_index = this->node_bucket(i);
 
-        link_pointer prev = this->get_previous_start(bucket_index);
-        while (prev->next_ != i) {
+          link_pointer prev = this->get_previous_start(bucket_index);
+          while (prev->next_ != i) {
             prev = next_node(prev);
-        }
+          }
 
-        prev->next_ = j;
-        if (j && i->is_first_in_group()) {
+          prev->next_ = j;
+          if (j && i->is_first_in_group()) {
             j->set_first_in_group();
+          }
+          --this->size_;
+          this->fix_bucket(bucket_index, prev, j);
+          i->next_ = link_pointer();
+
+          return i;
         }
-        --this->size_;
-        this->fix_bucket(bucket_index, prev, j);
-        i->next_ = link_pointer();
 
-        return i;
-    }
+        ////////////////////////////////////////////////////////////////////////
+        // Erase
+        //
+        // no throw
 
-    ////////////////////////////////////////////////////////////////////////
-    // Erase
-    //
-    // no throw
-
-    std::size_t erase_key_equiv(const_key_type& k)
-    {
-        if (!this->size_)
+        std::size_t erase_key_equiv(const_key_type& 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->find_previous_node(k, bucket_index);
-        if (!prev)
+          std::size_t key_hash = this->hash(k);
+          std::size_t bucket_index = this->hash_to_bucket(key_hash);
+          link_pointer prev = this->find_previous_node(k, bucket_index);
+          if (!prev)
             return 0;
 
-        std::size_t deleted_count = 0;
-        node_pointer n = next_node(prev);
-        do {
+          std::size_t deleted_count = 0;
+          node_pointer n = next_node(prev);
+          do {
             node_pointer n2 = next_node(n);
             destroy_node(n);
             ++deleted_count;
             n = n2;
-        } while (n && !n->is_first_in_group());
-        size_ -= deleted_count;
-        prev->next_ = n;
-        this->fix_bucket(bucket_index, prev, n);
-        return deleted_count;
-    }
-
-    link_pointer erase_nodes_equiv(node_pointer i, node_pointer j)
-    {
-        std::size_t bucket_index = this->node_bucket(i);
-
-        link_pointer prev = this->get_previous_start(bucket_index);
-        while (prev->next_ != i) {
-            prev = next_node(prev);
+          } while (n && !n->is_first_in_group());
+          size_ -= deleted_count;
+          prev->next_ = n;
+          this->fix_bucket(bucket_index, prev, n);
+          return deleted_count;
         }
 
-        // Delete the nodes.
-        // Is it inefficient to call fix_bucket for every node?
-        bool includes_first = false;
-        prev->next_ = j;
-        do {
+        link_pointer erase_nodes_equiv(node_pointer i, node_pointer j)
+        {
+          std::size_t bucket_index = this->node_bucket(i);
+
+          link_pointer prev = this->get_previous_start(bucket_index);
+          while (prev->next_ != i) {
+            prev = next_node(prev);
+          }
+
+          // Delete the nodes.
+          // Is it inefficient to call fix_bucket for every node?
+          bool includes_first = false;
+          prev->next_ = j;
+          do {
             includes_first = includes_first || i->is_first_in_group();
             node_pointer next = next_node(i);
             destroy_node(i);
             --size_;
             bucket_index = this->fix_bucket(bucket_index, prev, next);
             i = next;
-        } while (i != j);
-        if (j && includes_first) {
+          } while (i != j);
+          if (j && includes_first) {
             j->set_first_in_group();
+          }
+
+          return prev;
         }
 
-        return prev;
-    }
+        ////////////////////////////////////////////////////////////////////////
+        // fill_buckets
 
-    ////////////////////////////////////////////////////////////////////////
-    // fill_buckets
+        void copy_buckets(table const& src, false_type)
+        {
+          this->create_buckets(this->bucket_count_);
 
-    void copy_buckets(table const& src, false_type)
-    {
-        this->create_buckets(this->bucket_count_);
-
-        for (node_pointer n = src.begin(); n;) {
+          for (node_pointer n = src.begin(); n;) {
             std::size_t key_hash = this->hash(this->get_key(n));
             node_pointer group_end(next_group(n));
             node_pointer pos = this->add_node_equiv(
+              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_equiv(
                 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_equiv(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), n->value()),
-                    key_hash, pos);
+                  this->node_alloc(), n->value()),
+                key_hash, pos);
             }
+          }
         }
-    }
 
-    void move_buckets_equiv(table const& src)
-    {
-        this->create_buckets(this->bucket_count_);
+        void move_buckets_equiv(table const& src)
+        {
+          this->create_buckets(this->bucket_count_);
 
-        for (node_pointer n = src.begin(); n;) {
+          for (node_pointer n = src.begin(); n;) {
             std::size_t key_hash = this->hash(this->get_key(n));
             node_pointer group_end(next_group(n));
             node_pointer pos = this->add_node_equiv(
+              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_equiv(
                 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_equiv(
-                    boost::unordered::detail::func::construct_node(
-                        this->node_alloc(), boost::move(n->value())),
-                    key_hash, pos);
+                  this->node_alloc(), boost::move(n->value())),
+                key_hash, pos);
             }
+          }
         }
-    }
 
-    void assign_buckets(table const& src, false_type)
-    {
-        node_holder<node_allocator> holder(*this);
-        for (node_pointer n = src.begin(); n;) {
+        void assign_buckets(table const& src, false_type)
+        {
+          node_holder<node_allocator> holder(*this);
+          for (node_pointer n = src.begin(); n;) {
             std::size_t key_hash = this->hash(this->get_key(n));
             node_pointer group_end(next_group(n));
             node_pointer pos = this->add_node_equiv(
-                holder.copy_of(n->value()), key_hash, node_pointer());
+              holder.copy_of(n->value()), key_hash, node_pointer());
             for (n = next_node(n); n != group_end; n = next_node(n)) {
-                this->add_node_equiv(holder.copy_of(n->value()), key_hash, pos);
+              this->add_node_equiv(holder.copy_of(n->value()), key_hash, pos);
             }
+          }
         }
-    }
 
-    void move_assign_buckets(table& src, false_type)
-    {
-        node_holder<node_allocator> holder(*this);
-        for (node_pointer n = src.begin(); n;) {
+        void move_assign_buckets(table& src, false_type)
+        {
+          node_holder<node_allocator> holder(*this);
+          for (node_pointer n = src.begin(); n;) {
             std::size_t key_hash = this->hash(this->get_key(n));
             node_pointer group_end(next_group(n));
             node_pointer pos = this->add_node_equiv(
-                holder.move_copy_of(n->value()), key_hash, node_pointer());
+              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_equiv(
-                    holder.move_copy_of(n->value()), key_hash, pos);
+              this->add_node_equiv(
+                holder.move_copy_of(n->value()), key_hash, pos);
             }
+          }
         }
-    }
-};
+      };
 
-////////////////////////////////////////////////////////////////////////////
-// Clear
+      ////////////////////////////////////////////////////////////////////////////
+      // Clear
 
-template <typename Types> inline void table<Types>::clear_impl()
-{
-    if (size_) {
-        bucket_pointer end = get_bucket(bucket_count_);
-        for (bucket_pointer it = buckets_; it != end; ++it) {
+      template <typename Types> inline void table<Types>::clear_impl()
+      {
+        if (size_) {
+          bucket_pointer end = get_bucket(bucket_count_);
+          for (bucket_pointer it = buckets_; it != end; ++it) {
             it->next_ = node_pointer();
-        }
+          }
 
-        link_pointer prev = end->first_from_start();
-        node_pointer n = next_node(prev);
-        prev->next_ = node_pointer();
-        size_ = 0;
+          link_pointer prev = end->first_from_start();
+          node_pointer n = next_node(prev);
+          prev->next_ = node_pointer();
+          size_ = 0;
 
-        while (n) {
+          while (n) {
             node_pointer next = next_node(n);
             destroy_node(n);
             n = next;
+          }
         }
-    }
-}
+      }
 
-////////////////////////////////////////////////////////////////////////////
-// Reserve & Rehash
+      ////////////////////////////////////////////////////////////////////////////
+      // 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)));
-    } else if (size > max_load_) {
-        std::size_t num_buckets =
+      // 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)));
+        } 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_)
+          if (num_buckets != bucket_count_)
             this->rehash_impl(num_buckets);
-    }
-}
+        }
+      }
 
-// if hash function throws, basic exception safety
-// strong otherwise.
+      // 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;
+      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,
+        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));
+              floor(static_cast<double>(size_) / static_cast<double>(mlf_))) +
+              1));
 
-        if (min_buckets != bucket_count_)
+          if (min_buckets != bucket_count_)
             this->rehash_impl(min_buckets);
-    }
-}
+        }
+      }
 
-template <typename Types>
-inline void table<Types>::rehash_impl(std::size_t num_buckets)
-{
-    BOOST_ASSERT(this->buckets_);
+      template <typename Types>
+      inline void table<Types>::rehash_impl(std::size_t num_buckets)
+      {
+        BOOST_ASSERT(this->buckets_);
 
-    this->create_buckets(num_buckets);
-    link_pointer prev = this->get_previous_start();
-    BOOST_TRY
-    {
-        while (prev->next_) {
+        this->create_buckets(num_buckets);
+        link_pointer prev = this->get_previous_start();
+        BOOST_TRY
+        {
+          while (prev->next_) {
             node_pointer n = next_node(prev);
             std::size_t key_hash = this->hash(this->get_key(n));
             std::size_t bucket_index = this->hash_to_bucket(key_hash);
@@ -4302,344 +4369,354 @@ inline void table<Types>::rehash_impl(std::size_t num_buckets)
             // Iterator through the rest of the group of equal nodes,
             // setting the bucket.
             for (;;) {
-                node_pointer next = next_node(n);
-                if (!next || next->is_first_in_group()) {
-                    break;
-                }
-                n = next;
-                n->bucket_info_ = bucket_index;
-                n->reset_first_in_group();
+              node_pointer next = next_node(n);
+              if (!next || next->is_first_in_group()) {
+                break;
+              }
+              n = next;
+              n->bucket_info_ = bucket_index;
+              n->reset_first_in_group();
             }
 
             // n is now the last node in the group
             bucket_pointer b = this->get_bucket(bucket_index);
             if (!b->next_) {
-                b->next_ = prev;
-                prev = n;
+              b->next_ = prev;
+              prev = n;
             } else {
-                link_pointer next = n->next_;
-                n->next_ = b->next_->next_;
-                b->next_->next_ = prev->next_;
-                prev->next_ = next;
+              link_pointer next = n->next_;
+              n->next_ = b->next_->next_;
+              b->next_->next_ = prev->next_;
+              prev->next_ = next;
             }
+          }
         }
-    }
-    BOOST_CATCH(...)
-    {
-        node_pointer n = next_node(prev);
-        prev->next_ = node_pointer();
-        while (n) {
+        BOOST_CATCH(...)
+        {
+          node_pointer n = next_node(prev);
+          prev->next_ = node_pointer();
+          while (n) {
             node_pointer next = next_node(n);
             destroy_node(n);
             --size_;
             n = next;
+          }
+          BOOST_RETHROW
         }
-        BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-}
+        BOOST_CATCH_END
+      }
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif
 
-////////////////////////////////////////////////////////////////////////
-// 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.
 
-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)
-    };
+        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;
-};
+        typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE
+          then<Key const&, no_key>::type type;
+      };
 
-template <class ValueType> struct set_extractor
-{
-    typedef ValueType value_type;
-    typedef ValueType key_type;
+      template <class ValueType> struct set_extractor
+      {
+        typedef ValueType value_type;
+        typedef ValueType key_type;
 
-    static key_type const& extract(value_type const& v) { return v; }
+        static key_type const& extract(value_type const& v) { return v; }
 
-    static key_type const& extract(BOOST_UNORDERED_RV_REF(value_type) v)
-    {
-        return v;
-    }
+        static key_type const& extract(BOOST_UNORDERED_RV_REF(value_type) v)
+        {
+          return v;
+        }
 
-    static no_key extract() { return no_key(); }
+        static no_key extract() { return no_key(); }
 
-    template <class Arg> static no_key extract(Arg const&) { 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();
-    }
+        template <class Arg1, class Arg2>
+        static no_key extract(Arg1 const&, Arg2 const&)
+        {
+          return no_key();
+        }
 #endif
-};
+      };
 
-template <class ValueType> struct map_extractor
-{
-    typedef ValueType value_type;
-    typedef typename boost::remove_const<typename boost::unordered::detail::
+      template <class ValueType> struct map_extractor
+      {
+        typedef ValueType value_type;
+        typedef typename boost::remove_const<typename boost::unordered::detail::
             pair_traits<ValueType>::first_type>::type key_type;
 
-    static key_type const& extract(value_type 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, 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 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 const, Second> const& v)
+        {
+          return v.first;
+        }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <class Second>
-    static key_type const& extract(
-        boost::rv<std::pair<key_type, Second> > const& v)
-    {
-        return v.first;
-    }
+        template <class Second>
+        static key_type const& extract(
+          boost::rv<std::pair<key_type, Second> > const& v)
+        {
+          return v.first;
+        }
 
-    template <class Second>
-    static key_type const& extract(
-        boost::rv<std::pair<key_type const, Second> > const& v)
-    {
-        return v.first;
-    }
+        template <class Second>
+        static key_type const& extract(
+          boost::rv<std::pair<key_type const, Second> > const& v)
+        {
+          return v.first;
+        }
 #endif
 
-    template <class Arg1>
-    static key_type const& extract(key_type const& k, Arg1 const&)
-    {
-        return k;
-    }
+        template <class Arg1>
+        static key_type const& extract(key_type const& k, Arg1 const&)
+        {
+          return k;
+        }
 
-    static no_key extract() { return no_key(); }
+        static no_key extract() { return no_key(); }
 
-    template <class Arg> static no_key extract(Arg 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();
-    }
+        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 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));       \
-    }
+  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();                                                       \
-    }                                                                          \
+  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));       \
-    }
+  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 BOOST_UNORDERED_TUPLE_ARGS
-    BOOST_UNORDERED_KEY_FROM_TUPLE(std::)
+        BOOST_UNORDERED_KEY_FROM_TUPLE(std::)
 #endif
 
 #undef BOOST_UNORDERED_KEY_FROM_TUPLE
-};
+      };
 
-////////////////////////////////////////////////////////////////////////
-// Unique nodes
+      ////////////////////////////////////////////////////////////////////////
+      // Unique nodes
 
-template <typename A, typename T>
-struct node : boost::unordered::detail::value_base<T>
-{
-    typedef typename ::boost::unordered::detail::rebind_wrap<A,
-        node<A, T> >::type allocator;
-    typedef typename ::boost::unordered::detail::allocator_traits<
-        allocator>::pointer node_pointer;
-    typedef node_pointer link_pointer;
-    typedef typename ::boost::unordered::detail::rebind_wrap<A,
-        bucket<node_pointer> >::type bucket_allocator;
-    typedef typename ::boost::unordered::detail::allocator_traits<
-        bucket_allocator>::pointer bucket_pointer;
+      template <typename A, typename T>
+      struct node : boost::unordered::detail::value_base<T>
+      {
+        typedef typename ::boost::unordered::detail::rebind_wrap<A,
+          node<A, T> >::type allocator;
+        typedef typename ::boost::unordered::detail::allocator_traits<
+          allocator>::pointer node_pointer;
+        typedef node_pointer link_pointer;
+        typedef typename ::boost::unordered::detail::rebind_wrap<A,
+          bucket<node_pointer> >::type bucket_allocator;
+        typedef typename ::boost::unordered::detail::allocator_traits<
+          bucket_allocator>::pointer bucket_pointer;
 
-    link_pointer next_;
-    std::size_t bucket_info_;
+        link_pointer next_;
+        std::size_t bucket_info_;
 
-    node() : next_(), bucket_info_(0) {}
+        node() : next_(), bucket_info_(0) {}
 
-    std::size_t get_bucket() const
-    {
-        return bucket_info_ & ((std::size_t)-1 >> 1);
-    }
+        std::size_t get_bucket() const
+        {
+          return bucket_info_ & ((std::size_t)-1 >> 1);
+        }
 
-    std::size_t is_first_in_group() const
-    {
-        return !(bucket_info_ & ~((std::size_t)-1 >> 1));
-    }
+        std::size_t is_first_in_group() const
+        {
+          return !(bucket_info_ & ~((std::size_t)-1 >> 1));
+        }
 
-    void set_first_in_group()
-    {
-        bucket_info_ = bucket_info_ & ((std::size_t)-1 >> 1);
-    }
+        void set_first_in_group()
+        {
+          bucket_info_ = bucket_info_ & ((std::size_t)-1 >> 1);
+        }
 
-    void reset_first_in_group()
-    {
-        bucket_info_ = bucket_info_ | ~((std::size_t)-1 >> 1);
-    }
+        void reset_first_in_group()
+        {
+          bucket_info_ = bucket_info_ | ~((std::size_t)-1 >> 1);
+        }
 
-  private:
-    node& operator=(node const&);
-};
+      private:
+        node& operator=(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;
-    typedef ptr_bucket* bucket_pointer;
+      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;
+        typedef ptr_bucket* bucket_pointer;
 
-    std::size_t bucket_info_;
-    boost::unordered::detail::value_base<T> value_base_;
+        std::size_t bucket_info_;
+        boost::unordered::detail::value_base<T> value_base_;
 
-    ptr_node() : bucket_base(), bucket_info_(0) {}
+        ptr_node() : bucket_base(), bucket_info_(0) {}
 
-    void* address() { return value_base_.address(); }
-    value_type& value() { return value_base_.value(); }
-    value_type* value_ptr() { return value_base_.value_ptr(); }
+        void* address() { return value_base_.address(); }
+        value_type& value() { return value_base_.value(); }
+        value_type* value_ptr() { return value_base_.value_ptr(); }
 
-    std::size_t get_bucket() const
-    {
-        return bucket_info_ & ((std::size_t)-1 >> 1);
-    }
+        std::size_t get_bucket() const
+        {
+          return bucket_info_ & ((std::size_t)-1 >> 1);
+        }
 
-    std::size_t is_first_in_group() const
-    {
-        return !(bucket_info_ & ~((std::size_t)-1 >> 1));
-    }
+        std::size_t is_first_in_group() const
+        {
+          return !(bucket_info_ & ~((std::size_t)-1 >> 1));
+        }
 
-    void set_first_in_group()
-    {
-        bucket_info_ = bucket_info_ & ((std::size_t)-1 >> 1);
-    }
+        void set_first_in_group()
+        {
+          bucket_info_ = bucket_info_ & ((std::size_t)-1 >> 1);
+        }
 
-    void reset_first_in_group()
-    {
-        bucket_info_ = bucket_info_ | ~((std::size_t)-1 >> 1);
-    }
+        void reset_first_in_group()
+        {
+          bucket_info_ = bucket_info_ | ~((std::size_t)-1 >> 1);
+        }
 
-  private:
-    ptr_node& operator=(ptr_node const&);
-};
+      private:
+        ptr_node& operator=(ptr_node const&);
+      };
 
-// If the allocator uses raw pointers use ptr_node
-// Otherwise use node.
+      // 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::node<A, T> node;
+      template <typename A, typename T, typename NodePtr, typename BucketPtr>
+      struct pick_node2
+      {
+        typedef boost::unordered::detail::node<A, T> node;
 
-    typedef typename boost::unordered::detail::allocator_traits<
-        typename boost::unordered::detail::rebind_wrap<A, node>::type>::pointer
-        node_pointer;
+        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;
-};
+        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_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;
+      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,
+        typedef boost::unordered::detail::allocator_traits<
+          typename boost::unordered::detail::rebind_wrap<A,
             boost::unordered::detail::ptr_node<nonconst> >::type>
-        tentative_node_traits;
+          tentative_node_traits;
 
-    typedef boost::unordered::detail::allocator_traits<
-        typename boost::unordered::detail::rebind_wrap<A,
+        typedef boost::unordered::detail::allocator_traits<
+          typename boost::unordered::detail::rebind_wrap<A,
             boost::unordered::detail::ptr_bucket>::type>
-        tentative_bucket_traits;
+          tentative_bucket_traits;
 
-    typedef pick_node2<A, nonconst, typename tentative_node_traits::pointer,
-        typename tentative_bucket_traits::pointer>
-        pick;
+        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;
-};
-}
-}
+        typedef typename pick::node node;
+        typedef typename pick::bucket bucket;
+        typedef typename pick::link_pointer link_pointer;
+      };
+    }
+  }
 }
 
 #undef BOOST_UNORDERED_EMPLACE_TEMPLATE
diff --git a/include/boost/unordered/detail/map.hpp b/include/boost/unordered/detail/map.hpp
index 172b4f4b..024b3611 100644
--- a/include/boost/unordered/detail/map.hpp
+++ b/include/boost/unordered/detail/map.hpp
@@ -7,58 +7,60 @@
 #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 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 std::pair<K const, M> value_type;
-    typedef H hasher;
-    typedef P key_equal;
-    typedef K const const_key_type;
+        typedef std::pair<K const, M> value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef K const const_key_type;
 
-    typedef typename ::boost::unordered::detail::rebind_wrap<A,
-        value_type>::type value_allocator;
-    typedef boost::unordered::detail::allocator_traits<value_allocator>
-        value_allocator_traits;
+        typedef typename ::boost::unordered::detail::rebind_wrap<A,
+          value_type>::type value_allocator;
+        typedef boost::unordered::detail::allocator_traits<value_allocator>
+          value_allocator_traits;
 
-    typedef boost::unordered::detail::pick_node<A, value_type> pick;
-    typedef typename pick::node node;
-    typedef typename pick::bucket bucket;
-    typedef typename pick::link_pointer link_pointer;
+        typedef boost::unordered::detail::pick_node<A, 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<types> table;
-    typedef boost::unordered::detail::map_extractor<value_type> extractor;
+        typedef boost::unordered::detail::table<types> table;
+        typedef boost::unordered::detail::map_extractor<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> l_iterator;
-    typedef boost::unordered::iterator_detail::cl_iterator<node> 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> l_iterator;
+        typedef boost::unordered::iterator_detail::cl_iterator<node>
+          cl_iterator;
 
-    typedef boost::unordered::node_handle_map<node, K, M, A> node_type;
-    typedef boost::unordered::insert_return_type_map<node, K, M, A>
-        insert_return_type;
-};
+        typedef boost::unordered::node_handle_map<node, K, M, A> node_type;
+        typedef boost::unordered::insert_return_type_map<node, K, M, A>
+          insert_return_type;
+      };
 
-template <typename K, typename M, typename H, typename P, typename A>
-class instantiate_map
-{
-    typedef boost::unordered_map<K, M, H, P, A> container;
-    container x;
-    typename container::node_type node_type;
-    typename container::insert_return_type insert_return_type;
-};
+      template <typename K, typename M, typename H, typename P, typename A>
+      class instantiate_map
+      {
+        typedef boost::unordered_map<K, M, H, P, A> container;
+        container x;
+        typename container::node_type node_type;
+        typename container::insert_return_type insert_return_type;
+      };
 
-template <typename K, typename M, typename H, typename P, typename A>
-class instantiate_multimap
-{
-    typedef boost::unordered_multimap<K, M, H, P, A> container;
-    container x;
-    typename container::node_type node_type;
-};
-}
-}
+      template <typename K, typename M, typename H, typename P, typename A>
+      class instantiate_multimap
+      {
+        typedef boost::unordered_multimap<K, M, H, P, A> container;
+        container x;
+        typename container::node_type node_type;
+      };
+    }
+  }
 }
diff --git a/include/boost/unordered/detail/set.hpp b/include/boost/unordered/detail/set.hpp
index a1649917..af3dbd58 100644
--- a/include/boost/unordered/detail/set.hpp
+++ b/include/boost/unordered/detail/set.hpp
@@ -7,57 +7,59 @@
 #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 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 T value_type;
-    typedef H hasher;
-    typedef P key_equal;
-    typedef T const const_key_type;
+        typedef T value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef T const const_key_type;
 
-    typedef typename ::boost::unordered::detail::rebind_wrap<A,
-        value_type>::type value_allocator;
-    typedef boost::unordered::detail::allocator_traits<value_allocator>
-        value_allocator_traits;
+        typedef typename ::boost::unordered::detail::rebind_wrap<A,
+          value_type>::type value_allocator;
+        typedef boost::unordered::detail::allocator_traits<value_allocator>
+          value_allocator_traits;
 
-    typedef boost::unordered::detail::pick_node<A, value_type> pick;
-    typedef typename pick::node node;
-    typedef typename pick::bucket bucket;
-    typedef typename pick::link_pointer link_pointer;
+        typedef boost::unordered::detail::pick_node<A, 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<types> table;
-    typedef boost::unordered::detail::set_extractor<value_type> extractor;
+        typedef boost::unordered::detail::table<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> l_iterator;
-    typedef boost::unordered::iterator_detail::cl_iterator<node> 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> l_iterator;
+        typedef boost::unordered::iterator_detail::cl_iterator<node>
+          cl_iterator;
 
-    typedef boost::unordered::node_handle_set<node, T, A> node_type;
-    typedef boost::unordered::insert_return_type_set<node, T, A>
-        insert_return_type;
-};
+        typedef boost::unordered::node_handle_set<node, T, A> node_type;
+        typedef boost::unordered::insert_return_type_set<node, T, A>
+          insert_return_type;
+      };
 
-template <typename T, typename H, typename P, typename A> class instantiate_set
-{
-    typedef boost::unordered_set<T, H, P, A> container;
-    container x;
-    typename container::node_type node_type;
-    typename container::insert_return_type insert_return_type;
-};
+      template <typename T, typename H, typename P, typename A>
+      class instantiate_set
+      {
+        typedef boost::unordered_set<T, H, P, A> container;
+        container x;
+        typename container::node_type node_type;
+        typename container::insert_return_type insert_return_type;
+      };
 
-template <typename T, typename H, typename P, typename A>
-class instantiate_multiset
-{
-    typedef boost::unordered_multiset<T, H, P, A> container;
-    container x;
-    typename container::node_type node_type;
-};
-}
-}
+      template <typename T, typename H, typename P, typename A>
+      class instantiate_multiset
+      {
+        typedef boost::unordered_multiset<T, H, P, A> container;
+        container x;
+        typename container::node_type node_type;
+      };
+    }
+  }
 }
diff --git a/include/boost/unordered/unordered_map.hpp b/include/boost/unordered/unordered_map.hpp
index a0b4d532..d2f66a98 100644
--- a/include/boost/unordered/unordered_map.hpp
+++ b/include/boost/unordered/unordered_map.hpp
@@ -34,2456 +34,2471 @@
 #endif
 
 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)
+      BOOST_COPYABLE_AND_MOVABLE(unordered_map)
 #endif
-    template <typename, typename, typename, typename, typename>
-    friend class unordered_multimap;
+      template <typename, typename, typename, typename, typename>
+      friend class unordered_multimap;
 
-  public:
-    typedef K key_type;
-    typedef T mapped_type;
-    typedef std::pair<const K, T> value_type;
-    typedef H hasher;
-    typedef P key_equal;
-    typedef A allocator_type;
+    public:
+      typedef K key_type;
+      typedef T mapped_type;
+      typedef std::pair<const K, T> value_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::value_allocator_traits value_allocator_traits;
-    typedef typename types::table table;
-    typedef typename table::node_pointer node_pointer;
-    typedef typename table::link_pointer link_pointer;
+    private:
+      typedef boost::unordered::detail::map<A, K, T, H, P> types;
+      typedef typename types::value_allocator_traits value_allocator_traits;
+      typedef typename types::table table;
+      typedef typename table::node_pointer node_pointer;
+      typedef typename table::link_pointer link_pointer;
 
-  public:
-    typedef typename value_allocator_traits::pointer pointer;
-    typedef typename value_allocator_traits::const_pointer const_pointer;
+    public:
+      typedef typename value_allocator_traits::pointer pointer;
+      typedef typename value_allocator_traits::const_pointer const_pointer;
 
-    typedef value_type& reference;
-    typedef value_type const& const_reference;
+      typedef value_type& reference;
+      typedef value_type const& const_reference;
 
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
 
-    typedef typename table::iterator iterator;
-    typedef typename table::c_iterator const_iterator;
-    typedef typename table::l_iterator local_iterator;
-    typedef typename table::cl_iterator const_local_iterator;
-    typedef typename types::node_type node_type;
-    typedef typename types::insert_return_type insert_return_type;
+      typedef typename table::iterator iterator;
+      typedef typename table::c_iterator const_iterator;
+      typedef typename table::l_iterator local_iterator;
+      typedef typename table::cl_iterator const_local_iterator;
+      typedef typename types::node_type node_type;
+      typedef typename types::insert_return_type insert_return_type;
 
-  private:
-    table table_;
+    private:
+      table table_;
 
-  public:
-    // constructors
+    public:
+      // constructors
 
-    unordered_map();
+      unordered_map();
 
-    explicit unordered_map(size_type, const hasher& = hasher(),
+      explicit unordered_map(size_type, const hasher& = hasher(),
         const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    template <class InputIt>
-    unordered_map(InputIt, InputIt,
+      template <class InputIt>
+      unordered_map(InputIt, InputIt,
         size_type = boost::unordered::detail::default_bucket_count,
         const hasher& = hasher(), const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    unordered_map(unordered_map const&);
+      unordered_map(unordered_map const&);
 
 #if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_map(BOOST_RV_REF(unordered_map) other)
+  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      unordered_map(BOOST_RV_REF(unordered_map) other)
         BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-        : table_(other.table_, boost::unordered::detail::move_tag())
-    {
+          : table_(other.table_, boost::unordered::detail::move_tag())
+      {
         // The move is done in table_
-    }
+      }
 #endif
 
-    explicit unordered_map(allocator_type const&);
+      explicit unordered_map(allocator_type const&);
 
-    unordered_map(unordered_map const&, allocator_type const&);
+      unordered_map(unordered_map const&, allocator_type const&);
 
-    unordered_map(BOOST_RV_REF(unordered_map), allocator_type const&);
+      unordered_map(BOOST_RV_REF(unordered_map), allocator_type const&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_map(std::initializer_list<value_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());
 #endif
 
-    explicit unordered_map(size_type, const allocator_type&);
+      explicit unordered_map(size_type, const allocator_type&);
 
-    explicit unordered_map(size_type, const hasher&, const allocator_type&);
+      explicit unordered_map(size_type, const hasher&, const allocator_type&);
 
-    template <class InputIt>
-    unordered_map(InputIt, InputIt, size_type, const allocator_type&);
+      template <class InputIt>
+      unordered_map(InputIt, InputIt, size_type, const allocator_type&);
 
-    template <class InputIt>
-    unordered_map(
+      template <class InputIt>
+      unordered_map(
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_map(
+      unordered_map(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
-    unordered_map(std::initializer_list<value_type>, size_type, const hasher&,
+      unordered_map(std::initializer_list<value_type>, size_type, const hasher&,
         const allocator_type&);
 #endif
 
-    // Destructor
+      // Destructor
 
-    ~unordered_map() BOOST_NOEXCEPT;
+      ~unordered_map() BOOST_NOEXCEPT;
 
 // Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-    unordered_map& operator=(BOOST_COPY_ASSIGN_REF(unordered_map) x)
-    {
+      unordered_map& operator=(BOOST_COPY_ASSIGN_REF(unordered_map) x)
+      {
         table_.assign(x.table_, boost::unordered::detail::true_type());
         return *this;
-    }
+      }
 
-    unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::true_type());
         return *this;
-    }
+      }
 #else
-    unordered_map& operator=(unordered_map const& x)
-    {
+      unordered_map& operator=(unordered_map const& x)
+      {
         table_.assign(x.table_, boost::unordered::detail::true_type());
         return *this;
-    }
+      }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_map& operator=(unordered_map&& x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_map& operator=(unordered_map&& x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::true_type());
         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
-    {
+      allocator_type get_allocator() const BOOST_NOEXCEPT
+      {
         return table_.node_alloc();
-    }
+      }
 
-    // iterators
+      // iterators
 
-    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
+      iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-    const_iterator begin() const BOOST_NOEXCEPT
-    {
+      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
-    {
+      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(); }
 
-    // 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;
 
 // emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
+      {
         return table_.emplace_unique(
-            table::extractor::extract(boost::forward<Args>(args)...),
-            boost::forward<Args>(args)...);
-    }
+          table::extractor::extract(boost::forward<Args>(args)...),
+          boost::forward<Args>(args)...);
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    // 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(
+      std::pair<iterator, bool> emplace(
         boost::unordered::detail::empty_emplace =
-            boost::unordered::detail::empty_emplace(),
+          boost::unordered::detail::empty_emplace(),
         value_type v = value_type())
-    {
+      {
         return this->emplace(boost::move(v));
-    }
+      }
 
 #endif
 
-    template <typename A0>
-    std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0>
+      std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
+      {
         return table_.emplace_unique(
-            table::extractor::extract(boost::forward<A0>(a0)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0)));
-    }
+          table::extractor::extract(boost::forward<A0>(a0)),
+          boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    std::pair<iterator, bool> emplace(
+      template <typename A0, typename A1>
+      std::pair<iterator, bool> emplace(
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return table_.emplace_unique(
-            table::extractor::extract(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+          table::extractor::extract(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)),
+          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(
+      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_unique(
-            table::extractor::extract(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1),
-                boost::forward<A2>(a2)));
-    }
+          table::extractor::extract(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+      {
         return table_.emplace_hint_unique(hint,
-            table::extractor::extract(boost::forward<Args>(args)...),
-            boost::forward<Args>(args)...);
-    }
+          table::extractor::extract(boost::forward<Args>(args)...),
+          boost::forward<Args>(args)...);
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    iterator emplace_hint(const_iterator hint,
+      iterator emplace_hint(const_iterator hint,
         boost::unordered::detail::empty_emplace =
-            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_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+      {
         return table_.emplace_hint_unique(hint,
-            table::extractor::extract(boost::forward<A0>(a0)),
-            boost::unordered::detail::create_emplace_args(
-                                              boost::forward<A0>(a0)));
-    }
+          table::extractor::extract(boost::forward<A0>(a0)),
+          boost::unordered::detail::create_emplace_args(
+                                            boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    iterator emplace_hint(
+      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_unique(
-            hint, table::extractor::extract(
-                      boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+      {
+        return table_.emplace_hint_unique(hint,
+          table::extractor::extract(boost::forward<A0>(a0),
+                                            boost::forward<A1>(a1)),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+                                            boost::forward<A1>(a1)));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+      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_unique(
-            hint, table::extractor::extract(
-                      boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1),
-                boost::forward<A2>(a2)));
-    }
+          hint, table::extractor::extract(
+                  boost::forward<A0>(a0), boost::forward<A1>(a1)),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
 #endif
 
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 #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_unique(                                          \
-            table::extractor::extract(                                         \
-                boost::forward<A0>(a0), boost::forward<A1>(a1)),               \
-            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)>                          \
+  std::pair<iterator, bool> emplace(                                           \
+    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                        \
+  {                                                                            \
+    return table_.emplace_unique(                                              \
+      table::extractor::extract(                                               \
+        boost::forward<A0>(a0), boost::forward<A1>(a1)),                       \
+      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_unique(                                     \
-            hint, table::extractor::extract(                                   \
-                      boost::forward<A0>(a0), boost::forward<A1>(a1)),         \
-            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_unique(                                         \
+      hint, table::extractor::extract(                                         \
+              boost::forward<A0>(a0), boost::forward<A1>(a1)),                 \
+      boost::unordered::detail::create_emplace_args(                           \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));               \
+  }
 
-    BOOST_UNORDERED_EMPLACE(1, 4, _)
-    BOOST_UNORDERED_EMPLACE(1, 5, _)
-    BOOST_UNORDERED_EMPLACE(1, 6, _)
-    BOOST_UNORDERED_EMPLACE(1, 7, _)
-    BOOST_UNORDERED_EMPLACE(1, 8, _)
-    BOOST_UNORDERED_EMPLACE(1, 9, _)
-    BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+      BOOST_UNORDERED_EMPLACE(1, 4, _)
+      BOOST_UNORDERED_EMPLACE(1, 5, _)
+      BOOST_UNORDERED_EMPLACE(1, 6, _)
+      BOOST_UNORDERED_EMPLACE(1, 7, _)
+      BOOST_UNORDERED_EMPLACE(1, 8, _)
+      BOOST_UNORDERED_EMPLACE(1, 9, _)
+      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
         BOOST_UNORDERED_EMPLACE, _)
 
 #undef BOOST_UNORDERED_EMPLACE
 
 #endif
 
-    std::pair<iterator, bool> insert(value_type const& 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)
-    {
+      std::pair<iterator, bool> insert(BOOST_RV_REF(value_type) x)
+      {
         return this->emplace(boost::move(x));
-    }
+      }
 
-    template <class P2>
-    std::pair<iterator, bool> insert(BOOST_RV_REF(P2) obj,
+      template <class P2>
+      std::pair<iterator, bool> insert(BOOST_RV_REF(P2) obj,
         typename boost::enable_if_c<
-            boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
-            void*>::type = 0)
-    {
+          boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
+          void*>::type = 0)
+      {
         return this->emplace(boost::forward<P2>(obj));
-    }
+      }
 
-    iterator insert(const_iterator hint, value_type const& 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)
-    {
+      iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
+      {
         return this->emplace_hint(hint, boost::move(x));
-    }
+      }
 
-    template <class P2>
-    iterator insert(const_iterator hint, BOOST_RV_REF(P2) obj,
+      template <class P2>
+      iterator insert(const_iterator hint, BOOST_RV_REF(P2) obj,
         typename boost::enable_if_c<
-            boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
-            void*>::type = 0)
-    {
+          boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
+          void*>::type = 0)
+      {
         return this->emplace_hint(hint, boost::forward<P2>(obj));
-    }
+      }
 
-    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
 
-    // extract
+      // extract
 
-    node_type extract(const_iterator position)
-    {
+      node_type extract(const_iterator position)
+      {
         return node_type(
-            table_.extract_by_iterator_unique(position), table_.node_alloc());
-    }
+          table_.extract_by_iterator_unique(position), table_.node_alloc());
+      }
 
-    node_type extract(const key_type& k)
-    {
+      node_type extract(const key_type& k)
+      {
         return node_type(table_.extract_by_key(k), table_.node_alloc());
-    }
+      }
 
-    insert_return_type insert(BOOST_RV_REF(node_type) np)
-    {
+      insert_return_type insert(BOOST_RV_REF(node_type) np)
+      {
         insert_return_type result;
         table_.move_insert_node_type_unique(np, result);
         return boost::move(result);
-    }
+      }
 
-    iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
-    {
+      iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
+      {
         return table_.move_insert_node_type_with_hint_unique(hint, np);
-    }
+      }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ||                               \
-    (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
-  private:
-    // Note: Use r-value node_type to insert.
-    insert_return_type insert(node_type&);
-    iterator insert(const_iterator, node_type& np);
+  (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
+    private:
+      // Note: Use r-value node_type to insert.
+      insert_return_type insert(node_type&);
+      iterator insert(const_iterator, node_type& np);
 
-  public:
+    public:
 #endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    std::pair<iterator, bool> try_emplace(
+      template <class... Args>
+      std::pair<iterator, bool> try_emplace(
         key_type const& k, BOOST_FWD_REF(Args)... args)
-    {
+      {
         return table_.try_emplace_unique(k, boost::forward<Args>(args)...);
-    }
+      }
 
-    template <class... Args>
-    std::pair<iterator, bool> try_emplace(
+      template <class... Args>
+      std::pair<iterator, bool> try_emplace(
         BOOST_RV_REF(key_type) k, BOOST_FWD_REF(Args)... args)
-    {
+      {
         return table_.try_emplace_unique(
-            boost::move(k), boost::forward<Args>(args)...);
-    }
+          boost::move(k), boost::forward<Args>(args)...);
+      }
 
-    template <class... Args>
-    iterator try_emplace(
+      template <class... Args>
+      iterator try_emplace(
         const_iterator hint, key_type const& k, BOOST_FWD_REF(Args)... args)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, k, boost::forward<Args>(args)...);
-    }
+          hint, k, boost::forward<Args>(args)...);
+      }
 
-    template <class... Args>
-    iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,
+      template <class... Args>
+      iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,
         BOOST_FWD_REF(Args)... args)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, boost::move(k), boost::forward<Args>(args)...);
-    }
+          hint, boost::move(k), boost::forward<Args>(args)...);
+      }
 
 #else
 
-    // In order to make this a template, this handles both:
-    // try_emplace(key const&)
-    // try_emplace(key&&)
+      // In order to make this a template, this handles both:
+      // try_emplace(key const&)
+      // try_emplace(key&&)
 
-    template <typename Key>
-    std::pair<iterator, bool> try_emplace(BOOST_FWD_REF(Key) k)
-    {
+      template <typename Key>
+      std::pair<iterator, bool> try_emplace(BOOST_FWD_REF(Key) k)
+      {
         return table_.try_emplace_unique(boost::forward<Key>(k));
-    }
+      }
 
-    // In order to make this a template, this handles both:
-    // try_emplace(const_iterator hint, key const&)
-    // try_emplace(const_iterator hint, key&&)
+      // In order to make this a template, this handles both:
+      // try_emplace(const_iterator hint, key const&)
+      // try_emplace(const_iterator hint, key&&)
 
-    template <typename Key>
-    iterator try_emplace(const_iterator hint, BOOST_FWD_REF(Key) k)
-    {
+      template <typename Key>
+      iterator try_emplace(const_iterator hint, BOOST_FWD_REF(Key) k)
+      {
         return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k));
-    }
+      }
 
-    // try_emplace(key const&, Args&&...)
+      // try_emplace(key const&, Args&&...)
 
-    template <typename A0>
-    std::pair<iterator, bool> try_emplace(
+      template <typename A0>
+      std::pair<iterator, bool> try_emplace(
         key_type const& k, BOOST_FWD_REF(A0) a0)
-    {
+      {
         return table_.try_emplace_unique(
-            k, boost::unordered::detail::create_emplace_args(
-                   boost::forward<A0>(a0)));
-    }
+          k, boost::unordered::detail::create_emplace_args(
+               boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    std::pair<iterator, bool> try_emplace(
+      template <typename A0, typename A1>
+      std::pair<iterator, bool> try_emplace(
         key_type const& k, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return table_.try_emplace_unique(
-            k, boost::unordered::detail::create_emplace_args(
-                   boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+          k, 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> try_emplace(key_type const& k,
+      template <typename A0, typename A1, typename A2>
+      std::pair<iterator, bool> try_emplace(key_type const& k,
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-    {
+      {
         return table_.try_emplace_unique(
-            k, boost::unordered::detail::create_emplace_args(
-                   boost::forward<A0>(a0), boost::forward<A1>(a1),
-                   boost::forward<A2>(a2)));
-    }
+          k,
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
-    // try_emplace(key&&, Args&&...)
+      // try_emplace(key&&, Args&&...)
 
-    template <typename A0>
-    std::pair<iterator, bool> try_emplace(
+      template <typename A0>
+      std::pair<iterator, bool> try_emplace(
         BOOST_RV_REF(key_type) k, BOOST_FWD_REF(A0) a0)
-    {
+      {
         return table_.try_emplace_unique(
-            boost::move(k), boost::unordered::detail::create_emplace_args(
-                                boost::forward<A0>(a0)));
-    }
+          boost::move(k), boost::unordered::detail::create_emplace_args(
+                            boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    std::pair<iterator, bool> try_emplace(
+      template <typename A0, typename A1>
+      std::pair<iterator, bool> try_emplace(
         BOOST_RV_REF(key_type) k, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return table_.try_emplace_unique(
-            boost::move(k),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+          boost::move(k), 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> try_emplace(BOOST_RV_REF(key_type) k,
+      template <typename A0, typename A1, typename A2>
+      std::pair<iterator, bool> try_emplace(BOOST_RV_REF(key_type) k,
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-    {
+      {
         return table_.try_emplace_unique(
-            boost::move(k), boost::unordered::detail::create_emplace_args(
-                                boost::forward<A0>(a0), boost::forward<A1>(a1),
-                                boost::forward<A2>(a2)));
-    }
+          boost::move(k),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
-    // try_emplace(const_iterator hint, key const&, Args&&...)
+      // try_emplace(const_iterator hint, key const&, Args&&...)
 
-    template <typename A0>
-    iterator try_emplace(
+      template <typename A0>
+      iterator try_emplace(
         const_iterator hint, key_type const& k, BOOST_FWD_REF(A0) a0)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, k, boost::unordered::detail::create_emplace_args(
-                         boost::forward<A0>(a0)));
-    }
+          hint, k, boost::unordered::detail::create_emplace_args(
+                     boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    iterator try_emplace(const_iterator hint, key_type const& k,
+      template <typename A0, typename A1>
+      iterator try_emplace(const_iterator hint, key_type const& k,
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, k, boost::unordered::detail::create_emplace_args(
-                         boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+          hint, k, boost::unordered::detail::create_emplace_args(
+                     boost::forward<A0>(a0), boost::forward<A1>(a1)));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator try_emplace(const_iterator hint, key_type const& k,
+      template <typename A0, typename A1, typename A2>
+      iterator try_emplace(const_iterator hint, key_type const& k,
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, k, boost::unordered::detail::create_emplace_args(
-                         boost::forward<A0>(a0), boost::forward<A1>(a1),
-                         boost::forward<A2>(a2)));
-    }
+          hint, k,
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
-    // try_emplace(const_iterator hint, key&&, Args&&...)
+      // try_emplace(const_iterator hint, key&&, Args&&...)
 
-    template <typename A0>
-    iterator try_emplace(
+      template <typename A0>
+      iterator try_emplace(
         const_iterator hint, BOOST_RV_REF(key_type) k, BOOST_FWD_REF(A0) a0)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, boost::move(k), boost::unordered::detail::create_emplace_args(
-                                      boost::forward<A0>(a0)));
-    }
+          hint, boost::move(k), boost::unordered::detail::create_emplace_args(
+                                  boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,
+      template <typename A0, typename A1>
+      iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
-        return table_.try_emplace_hint_unique(
-            hint, boost::move(k),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+      {
+        return table_.try_emplace_hint_unique(hint, boost::move(k),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+                                                boost::forward<A1>(a1)));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,
+      template <typename A0, typename A1, typename A2>
+      iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-    {
+      {
         return table_.try_emplace_hint_unique(
-            hint, boost::move(k),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1),
-                boost::forward<A2>(a2)));
-    }
+          hint, boost::move(k),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
 #define BOOST_UNORDERED_TRY_EMPLACE(z, n, _)                                   \
                                                                                \
-    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                        \
-    std::pair<iterator, bool> try_emplace(                                     \
-        key_type const& k, BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a)) \
-    {                                                                          \
-        return table_.try_emplace_unique(                                      \
-            k, 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)>                          \
+  std::pair<iterator, bool> try_emplace(                                       \
+    key_type const& k, BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))     \
+  {                                                                            \
+    return table_.try_emplace_unique(                                          \
+      k, 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)>                        \
-    std::pair<iterator, bool> try_emplace(BOOST_RV_REF(key_type) k,            \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
-    {                                                                          \
-        return table_.try_emplace_unique(boost::move(k),                       \
-            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)>                          \
+  std::pair<iterator, bool> try_emplace(BOOST_RV_REF(key_type) k,              \
+    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                        \
+  {                                                                            \
+    return table_.try_emplace_unique(boost::move(k),                           \
+      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 try_emplace(const_iterator hint, key_type const& k,               \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
-    {                                                                          \
-        return table_.try_emplace_hint_unique(hint, k,                         \
-            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 try_emplace(const_iterator hint, key_type const& k,                 \
+    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                        \
+  {                                                                            \
+    return table_.try_emplace_hint_unique(                                     \
+      hint, k, 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 try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,        \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                    \
-    {                                                                          \
-        return table_.try_emplace_hint_unique(hint, boost::move(k),            \
-            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 try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k,          \
+    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                        \
+  {                                                                            \
+    return table_.try_emplace_hint_unique(hint, boost::move(k),                \
+      boost::unordered::detail::create_emplace_args(BOOST_PP_ENUM_##z(         \
+        n, BOOST_UNORDERED_CALL_FORWARD, a)));                                 \
+  }
 
-    BOOST_UNORDERED_TRY_EMPLACE(1, 4, _)
-    BOOST_UNORDERED_TRY_EMPLACE(1, 5, _)
-    BOOST_UNORDERED_TRY_EMPLACE(1, 6, _)
-    BOOST_UNORDERED_TRY_EMPLACE(1, 7, _)
-    BOOST_UNORDERED_TRY_EMPLACE(1, 8, _)
-    BOOST_UNORDERED_TRY_EMPLACE(1, 9, _)
-    BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+      BOOST_UNORDERED_TRY_EMPLACE(1, 4, _)
+      BOOST_UNORDERED_TRY_EMPLACE(1, 5, _)
+      BOOST_UNORDERED_TRY_EMPLACE(1, 6, _)
+      BOOST_UNORDERED_TRY_EMPLACE(1, 7, _)
+      BOOST_UNORDERED_TRY_EMPLACE(1, 8, _)
+      BOOST_UNORDERED_TRY_EMPLACE(1, 9, _)
+      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
         BOOST_UNORDERED_TRY_EMPLACE, _)
 
 #undef BOOST_UNORDERED_TRY_EMPLACE
 
 #endif
 
-    template <class M>
-    std::pair<iterator, bool> insert_or_assign(
+      template <class M>
+      std::pair<iterator, bool> insert_or_assign(
         key_type const& k, BOOST_FWD_REF(M) obj)
-    {
+      {
         return table_.insert_or_assign_unique(k, boost::forward<M>(obj));
-    }
+      }
 
-    template <class M>
-    std::pair<iterator, bool> insert_or_assign(
+      template <class M>
+      std::pair<iterator, bool> insert_or_assign(
         BOOST_RV_REF(key_type) k, BOOST_FWD_REF(M) obj)
-    {
+      {
         return table_.insert_or_assign_unique(
-            boost::move(k), boost::forward<M>(obj));
-    }
+          boost::move(k), boost::forward<M>(obj));
+      }
 
-    template <class M>
-    iterator insert_or_assign(
+      template <class M>
+      iterator insert_or_assign(
         const_iterator, key_type const& k, BOOST_FWD_REF(M) obj)
-    {
+      {
         return table_.insert_or_assign_unique(k, boost::forward<M>(obj)).first;
-    }
+      }
 
-    template <class M>
-    iterator insert_or_assign(
+      template <class M>
+      iterator insert_or_assign(
         const_iterator, BOOST_RV_REF(key_type) k, BOOST_FWD_REF(M) obj)
-    {
+      {
         return table_
-            .insert_or_assign_unique(boost::move(k), boost::forward<M>(obj))
-            .first;
-    }
+          .insert_or_assign_unique(boost::move(k), boost::forward<M>(obj))
+          .first;
+      }
 
-    iterator erase(iterator);
-    iterator erase(const_iterator);
-    size_type erase(const key_type&);
-    iterator erase(const_iterator, const_iterator);
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    void quick_erase(const_iterator it) { erase(it); }
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    void erase_return_void(const_iterator it) { erase(it); }
+      iterator erase(iterator);
+      iterator erase(const_iterator);
+      size_type erase(const key_type&);
+      iterator erase(const_iterator, const_iterator);
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void quick_erase(const_iterator it) { erase(it); }
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void erase_return_void(const_iterator it) { erase(it); }
 
-    void swap(unordered_map&);
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+      void swap(unordered_map&);
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
 
-    template <typename H2, typename P2>
-    void merge(boost::unordered_map<K, T, H2, P2, A>& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_map<K, T, H2, P2, A>& source);
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename H2, typename P2>
-    void merge(boost::unordered_map<K, T, H2, P2, A>&& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_map<K, T, H2, P2, A>&& source);
 #endif
 
-    template <typename H2, typename P2>
-    void merge(boost::unordered_multimap<K, T, H2, P2, A>& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multimap<K, T, H2, P2, A>& source);
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename H2, typename P2>
-    void merge(boost::unordered_multimap<K, T, H2, P2, A>&& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multimap<K, T, H2, P2, A>&& source);
 #endif
 
-    // 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,
+      template <class CompatibleKey, class CompatibleHash,
         class CompatiblePredicate>
-    iterator find(CompatibleKey const&, CompatibleHash const&,
+      iterator find(CompatibleKey const&, CompatibleHash const&,
         CompatiblePredicate const&);
 
-    template <class CompatibleKey, class CompatibleHash,
+      template <class CompatibleKey, class CompatibleHash,
         class CompatiblePredicate>
-    const_iterator find(CompatibleKey const&, CompatibleHash const&,
+      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(
+      std::pair<iterator, iterator> equal_range(const key_type&);
+      std::pair<const_iterator, const_iterator> equal_range(
         const key_type&) const;
 
-    mapped_type& operator[](const key_type&);
-    mapped_type& operator[](BOOST_RV_REF(key_type));
-    mapped_type& at(const key_type&);
-    mapped_type const& at(const key_type&) const;
+      mapped_type& operator[](const key_type&);
+      mapped_type& operator[](BOOST_RV_REF(key_type));
+      mapped_type& at(const key_type&);
+      mapped_type const& at(const key_type&) const;
 
-    // bucket interface
+      // bucket interface
 
-    size_type bucket_count() const BOOST_NOEXCEPT
-    {
+      size_type bucket_count() const BOOST_NOEXCEPT
+      {
         return table_.bucket_count_;
-    }
+      }
 
-    size_type max_bucket_count() const BOOST_NOEXCEPT
-    {
+      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
-    {
+      size_type bucket(const key_type& k) const
+      {
         return table_.hash_to_bucket(table_.hash(k));
-    }
+      }
 
-    local_iterator begin(size_type n)
-    {
+      local_iterator begin(size_type n)
+      {
         return local_iterator(table_.begin(n), n, table_.bucket_count_);
-    }
+      }
 
-    const_local_iterator begin(size_type n) const
-    {
+      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 cbegin(size_type n) const
-    {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
-    }
-
-    const_local_iterator cend(size_type) const
-    {
+      const_local_iterator end(size_type) const
+      {
         return const_local_iterator();
-    }
+      }
 
-    // hash policy
+      const_local_iterator cbegin(size_type n) const
+      {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+      }
 
-    float load_factor() const BOOST_NOEXCEPT;
-    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
-    void max_load_factor(float) BOOST_NOEXCEPT;
-    void rehash(size_type);
-    void reserve(size_type);
+      const_local_iterator cend(size_type) const
+      {
+        return const_local_iterator();
+      }
+
+      // hash policy
+
+      float load_factor() const BOOST_NOEXCEPT;
+      float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
+      void max_load_factor(float) BOOST_NOEXCEPT;
+      void rehash(size_type);
+      void reserve(size_type);
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-    friend bool operator==
+      friend bool operator==
         <K, T, H, P, A>(unordered_map const&, unordered_map const&);
-    friend bool operator!=
+      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)
+      BOOST_COPYABLE_AND_MOVABLE(unordered_multimap)
 #endif
-    template <typename, typename, typename, typename, typename>
-    friend class unordered_map;
+      template <typename, typename, typename, typename, typename>
+      friend class unordered_map;
 
-  public:
-    typedef K key_type;
-    typedef T mapped_type;
-    typedef std::pair<const K, T> value_type;
-    typedef H hasher;
-    typedef P key_equal;
-    typedef A allocator_type;
+    public:
+      typedef K key_type;
+      typedef T mapped_type;
+      typedef std::pair<const K, T> value_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::value_allocator_traits value_allocator_traits;
-    typedef typename types::table table;
-    typedef typename table::node_pointer node_pointer;
-    typedef typename table::link_pointer link_pointer;
+    private:
+      typedef boost::unordered::detail::map<A, K, T, H, P> types;
+      typedef typename types::value_allocator_traits value_allocator_traits;
+      typedef typename types::table table;
+      typedef typename table::node_pointer node_pointer;
+      typedef typename table::link_pointer link_pointer;
 
-  public:
-    typedef typename value_allocator_traits::pointer pointer;
-    typedef typename value_allocator_traits::const_pointer const_pointer;
+    public:
+      typedef typename value_allocator_traits::pointer pointer;
+      typedef typename value_allocator_traits::const_pointer const_pointer;
 
-    typedef value_type& reference;
-    typedef value_type const& const_reference;
+      typedef value_type& reference;
+      typedef value_type const& const_reference;
 
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
 
-    typedef typename table::iterator iterator;
-    typedef typename table::c_iterator const_iterator;
-    typedef typename table::l_iterator local_iterator;
-    typedef typename table::cl_iterator const_local_iterator;
-    typedef typename types::node_type node_type;
+      typedef typename table::iterator iterator;
+      typedef typename table::c_iterator const_iterator;
+      typedef typename table::l_iterator local_iterator;
+      typedef typename table::cl_iterator const_local_iterator;
+      typedef typename types::node_type node_type;
 
-  private:
-    table table_;
+    private:
+      table table_;
 
-  public:
-    // constructors
+    public:
+      // constructors
 
-    unordered_multimap();
+      unordered_multimap();
 
-    explicit unordered_multimap(size_type, const hasher& = hasher(),
+      explicit unordered_multimap(size_type, const hasher& = hasher(),
         const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    template <class InputIt>
-    unordered_multimap(InputIt, InputIt,
+      template <class InputIt>
+      unordered_multimap(InputIt, InputIt,
         size_type = boost::unordered::detail::default_bucket_count,
         const hasher& = hasher(), const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    unordered_multimap(unordered_multimap const&);
+      unordered_multimap(unordered_multimap const&);
 
 #if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
+  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
         BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-        : table_(other.table_, boost::unordered::detail::move_tag())
-    {
+          : table_(other.table_, boost::unordered::detail::move_tag())
+      {
         // The move is done in table_
-    }
+      }
 #endif
 
-    explicit unordered_multimap(allocator_type const&);
+      explicit unordered_multimap(allocator_type const&);
 
-    unordered_multimap(unordered_multimap const&, allocator_type const&);
+      unordered_multimap(unordered_multimap const&, allocator_type const&);
 
-    unordered_multimap(BOOST_RV_REF(unordered_multimap), allocator_type const&);
+      unordered_multimap(
+        BOOST_RV_REF(unordered_multimap), allocator_type const&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_multimap(std::initializer_list<value_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());
 #endif
 
-    explicit unordered_multimap(size_type, const allocator_type&);
+      explicit unordered_multimap(size_type, const allocator_type&);
 
-    explicit unordered_multimap(
+      explicit unordered_multimap(
         size_type, const hasher&, const allocator_type&);
 
-    template <class InputIt>
-    unordered_multimap(InputIt, InputIt, size_type, const allocator_type&);
+      template <class InputIt>
+      unordered_multimap(InputIt, InputIt, size_type, const allocator_type&);
 
-    template <class InputIt>
-    unordered_multimap(
+      template <class InputIt>
+      unordered_multimap(
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_multimap(
+      unordered_multimap(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
-    unordered_multimap(std::initializer_list<value_type>, size_type,
+      unordered_multimap(std::initializer_list<value_type>, size_type,
         const hasher&, const allocator_type&);
 #endif
 
-    // Destructor
+      // Destructor
 
-    ~unordered_multimap() BOOST_NOEXCEPT;
+      ~unordered_multimap() BOOST_NOEXCEPT;
 
 // Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-    unordered_multimap& operator=(BOOST_COPY_ASSIGN_REF(unordered_multimap) x)
-    {
+      unordered_multimap& operator=(BOOST_COPY_ASSIGN_REF(unordered_multimap) x)
+      {
         table_.assign(x.table_, boost::unordered::detail::false_type());
         return *this;
-    }
+      }
 
-    unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::false_type());
         return *this;
-    }
+      }
 #else
-    unordered_multimap& operator=(unordered_multimap const& x)
-    {
+      unordered_multimap& operator=(unordered_multimap const& x)
+      {
         table_.assign(x.table_, boost::unordered::detail::false_type());
         return *this;
-    }
+      }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_multimap& operator=(unordered_multimap&& x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_multimap& operator=(unordered_multimap&& x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::false_type());
         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
-    {
+      allocator_type get_allocator() const BOOST_NOEXCEPT
+      {
         return table_.node_alloc();
-    }
+      }
 
-    // iterators
+      // iterators
 
-    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
+      iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-    const_iterator begin() const BOOST_NOEXCEPT
-    {
+      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
-    {
+      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(); }
 
-    // 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;
 
 // emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
+      {
         return iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(), boost::forward<Args>(args)...)));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(), boost::forward<Args>(args)...)));
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    // 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 =
+      iterator emplace(boost::unordered::detail::empty_emplace =
                          boost::unordered::detail::empty_emplace(),
         value_type v = value_type())
-    {
+      {
         return this->emplace(boost::move(v));
-    }
+      }
 
 #endif
 
-    template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
+      {
         return iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0)))));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(), 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)
-    {
+      template <typename A0, typename A1>
+      iterator emplace(BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+      {
         return iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0), boost::forward<A1>(a1)))));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(),
+            boost::unordered::detail::create_emplace_args(
+              boost::forward<A0>(a0), boost::forward<A1>(a1)))));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator emplace(
+      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 iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0), boost::forward<A1>(a1),
-                    boost::forward<A2>(a2)))));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(),
+            boost::unordered::detail::create_emplace_args(
+              boost::forward<A0>(a0), boost::forward<A1>(a1),
+              boost::forward<A2>(a2)))));
+      }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+      {
         return iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(), boost::forward<Args>(args)...)));
-    }
+          hint, boost::unordered::detail::func::construct_node_from_args(
+                  table_.node_alloc(), boost::forward<Args>(args)...)));
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    iterator emplace_hint(const_iterator hint,
+      iterator emplace_hint(const_iterator hint,
         boost::unordered::detail::empty_emplace =
-            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_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+      {
         return iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(),
-                      boost::unordered::detail::create_emplace_args(
-                          boost::forward<A0>(a0)))));
-    }
+          hint,
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(), boost::unordered::detail::create_emplace_args(
+                                   boost::forward<A0>(a0)))));
+      }
 
-    template <typename A0, typename A1>
-    iterator emplace_hint(
+      template <typename A0, typename A1>
+      iterator emplace_hint(
         const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(),
-                      boost::unordered::detail::create_emplace_args(
-                          boost::forward<A0>(a0), boost::forward<A1>(a1)))));
-    }
+          hint, boost::unordered::detail::func::construct_node_from_args(
+                  table_.node_alloc(),
+                  boost::unordered::detail::create_emplace_args(
+                    boost::forward<A0>(a0), boost::forward<A1>(a1)))));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+      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 iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(),
-                      boost::unordered::detail::create_emplace_args(
-                          boost::forward<A0>(a0), boost::forward<A1>(a1),
-                          boost::forward<A2>(a2)))));
-    }
+          hint, boost::unordered::detail::func::construct_node_from_args(
+                  table_.node_alloc(),
+                  boost::unordered::detail::create_emplace_args(
+                    boost::forward<A0>(a0), boost::forward<A1>(a1),
+                    boost::forward<A2>(a2)))));
+      }
 
 #endif
 
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 #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 iterator(table_.emplace_equiv(                                  \
-            boost::unordered::detail::func::construct_node_from_args(          \
-                table_.node_alloc(),                                           \
-                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(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))         \
+  {                                                                            \
+    return iterator(table_.emplace_equiv(                                      \
+      boost::unordered::detail::func::construct_node_from_args(                \
+        table_.node_alloc(),                                                   \
+        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 iterator(table_.emplace_hint_equiv(                             \
-            hint,                                                              \
-            boost::unordered::detail::func::construct_node_from_args(          \
-                table_.node_alloc(),                                           \
-                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 iterator(table_.emplace_hint_equiv(                                 \
+      hint, boost::unordered::detail::func::construct_node_from_args(          \
+              table_.node_alloc(),                                             \
+              boost::unordered::detail::create_emplace_args(                   \
+                BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)))));     \
+  }
 
-    BOOST_UNORDERED_EMPLACE(1, 4, _)
-    BOOST_UNORDERED_EMPLACE(1, 5, _)
-    BOOST_UNORDERED_EMPLACE(1, 6, _)
-    BOOST_UNORDERED_EMPLACE(1, 7, _)
-    BOOST_UNORDERED_EMPLACE(1, 8, _)
-    BOOST_UNORDERED_EMPLACE(1, 9, _)
-    BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+      BOOST_UNORDERED_EMPLACE(1, 4, _)
+      BOOST_UNORDERED_EMPLACE(1, 5, _)
+      BOOST_UNORDERED_EMPLACE(1, 6, _)
+      BOOST_UNORDERED_EMPLACE(1, 7, _)
+      BOOST_UNORDERED_EMPLACE(1, 8, _)
+      BOOST_UNORDERED_EMPLACE(1, 9, _)
+      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(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)
-    {
+      iterator insert(BOOST_RV_REF(value_type) x)
+      {
         return this->emplace(boost::move(x));
-    }
+      }
 
-    template <class P2>
-    iterator insert(BOOST_RV_REF(P2) obj,
+      template <class P2>
+      iterator insert(BOOST_RV_REF(P2) obj,
         typename boost::enable_if_c<
-            boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
-            void*>::type = 0)
-    {
+          boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
+          void*>::type = 0)
+      {
         return this->emplace(boost::forward<P2>(obj));
-    }
+      }
 
-    iterator insert(const_iterator hint, value_type const& 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)
-    {
+      iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
+      {
         return this->emplace_hint(hint, boost::move(x));
-    }
+      }
 
-    template <class P2>
-    iterator insert(const_iterator hint, BOOST_RV_REF(P2) obj,
+      template <class P2>
+      iterator insert(const_iterator hint, BOOST_RV_REF(P2) obj,
         typename boost::enable_if_c<
-            boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
-            void*>::type = 0)
-    {
+          boost::is_constructible<value_type, BOOST_RV_REF(P2)>::value,
+          void*>::type = 0)
+      {
         return this->emplace_hint(hint, boost::forward<P2>(obj));
-    }
+      }
 
-    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
 
-    // extract
+      // extract
 
-    node_type extract(const_iterator position)
-    {
+      node_type extract(const_iterator position)
+      {
         return node_type(
-            table_.extract_by_iterator_equiv(position), table_.node_alloc());
-    }
+          table_.extract_by_iterator_equiv(position), table_.node_alloc());
+      }
 
-    node_type extract(const key_type& k)
-    {
+      node_type extract(const key_type& k)
+      {
         return node_type(table_.extract_by_key(k), table_.node_alloc());
-    }
+      }
 
-    iterator insert(BOOST_RV_REF(node_type) np)
-    {
+      iterator insert(BOOST_RV_REF(node_type) np)
+      {
         return table_.move_insert_node_type_equiv(np);
-    }
+      }
 
-    iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
-    {
+      iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
+      {
         return table_.move_insert_node_type_with_hint_equiv(hint, np);
-    }
+      }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ||                               \
-    (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
-  private:
-    // Note: Use r-value node_type to insert.
-    iterator insert(node_type&);
-    iterator insert(const_iterator, node_type& np);
+  (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
+    private:
+      // Note: Use r-value node_type to insert.
+      iterator insert(node_type&);
+      iterator insert(const_iterator, node_type& np);
 
-  public:
+    public:
 #endif
 
-    iterator erase(iterator);
-    iterator erase(const_iterator);
-    size_type erase(const key_type&);
-    iterator erase(const_iterator, const_iterator);
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    void quick_erase(const_iterator it) { erase(it); }
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    void erase_return_void(const_iterator it) { erase(it); }
+      iterator erase(iterator);
+      iterator erase(const_iterator);
+      size_type erase(const key_type&);
+      iterator erase(const_iterator, const_iterator);
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void quick_erase(const_iterator it) { erase(it); }
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void erase_return_void(const_iterator it) { erase(it); }
 
-    void swap(unordered_multimap&);
+      void swap(unordered_multimap&);
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multimap<K, T, H2, P2, A>& source);
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multimap<K, T, H2, P2, A>&& source);
+#endif
+
+      template <typename H2, typename P2>
+      void merge(boost::unordered_map<K, T, H2, P2, A>& source);
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename H2, typename P2>
+      void merge(boost::unordered_map<K, T, H2, P2, A>&& source);
+#endif
+
+      // observers
+
+      hasher hash_function() const;
+      key_equal key_eq() const;
+
+      // lookup
+
+      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>
+      const_iterator find(CompatibleKey const&, CompatibleHash const&,
+        CompatiblePredicate const&) 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;
+
+      // bucket interface
+
+      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 bucket_size(size_type) const;
+
+      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_);
+      }
+
+      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(); }
+
+      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 cend(size_type) const
+      {
+        return const_local_iterator();
+      }
+
+      // hash policy
+
+      float load_factor() const BOOST_NOEXCEPT;
+      float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
+      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&);
+#endif
+    }; // 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(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>
+    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)
+    {
+      this->insert(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_,
+            unordered_map::value_allocator_traits::
+              select_on_container_copy_construction(other.get_allocator()))
+    {
+      if (other.table_.size_) {
+        table_.copy_buckets(
+          other.table_, boost::unordered::detail::true_type());
+      }
+    }
+
+    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)
+    {
+      if (other.table_.size_) {
+        table_.copy_buckets(
+          other.table_, boost::unordered::detail::true_type());
+      }
+    }
+
+    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 (table_.node_alloc() == other.table_.node_alloc()) {
+        table_.move_buckets_from(other.table_);
+      } else if (other.table_.size_) {
+        // TODO: Could pick new bucket size?
+        table_.move_buckets(other.table_);
+      }
+    }
+
+#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)
+    {
+      this->insert(list.begin(), list.end());
+    }
+
+#endif
+
+    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>
+    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)
+    {
+      this->insert(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)
+    {
+      this->insert(f, l);
+    }
+
+#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 allocator_type& a)
+        : table_(
+            boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+            hasher(), key_equal(), a)
+    {
+      this->insert(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)
+    {
+      this->insert(list.begin(), list.end());
+    }
+
+#endif
+
+    template <class K, class T, class H, class P, class A>
+    unordered_map<K, T, H, P, A>::~unordered_map() BOOST_NOEXCEPT
+    {
+    }
+
+#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<K, T, H, P, A>::operator=(
+      std::initializer_list<value_type> list)
+    {
+      this->clear();
+      this->insert(list.begin(), list.end());
+      return *this;
+    }
+
+#endif
+
+    // 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
+    {
+      using namespace std;
+
+      // size <= mlf_ * count
+      return boost::unordered::detail::double_to_size(
+               ceil(static_cast<double>(table_.mlf_) *
+                    static_cast<double>(table_.max_bucket_count()))) -
+             1;
+    }
+
+    // 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)
+    {
+      if (first != last) {
+        table_.insert_range_unique(
+          table::extractor::extract(*first), 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)
+    {
+      this->insert(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(iterator position)
+    {
+      node_pointer node = table::get_node(position);
+      BOOST_ASSERT(node);
+      node_pointer next = table::next_node(node);
+      table_.erase_nodes_unique(node, next);
+      return iterator(next);
+    }
+
+    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)
+    {
+      node_pointer node = table::get_node(position);
+      BOOST_ASSERT(node);
+      node_pointer next = table::next_node(node);
+      table_.erase_nodes_unique(node, next);
+      return iterator(next);
+    }
+
+    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_unique(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)
+    {
+      node_pointer last_node = table::get_node(last);
+      if (first == last)
+        return iterator(last_node);
+      table_.erase_nodes_unique(table::get_node(first), last_node);
+      return iterator(last_node);
+    }
+
+    template <class K, class T, class H, class P, class A>
+    void unordered_map<K, T, H, P, A>::swap(unordered_map& other)
     // C++17 support: BOOST_NOEXCEPT_IF(
     //    value_allocator_traits::is_always_equal::value &&
     //    is_nothrow_move_assignable_v<H> &&
     //    is_nothrow_move_assignable_v<P>)
-    void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+    {
+      table_.swap(other.table_);
+    }
 
+    template <class K, class T, class H, class P, class A>
     template <typename H2, typename P2>
-    void merge(boost::unordered_multimap<K, T, H2, P2, A>& source);
+    void unordered_map<K, T, H, P, A>::merge(
+      boost::unordered_map<K, T, H2, P2, A>& source)
+    {
+      table_.merge_unique(source.table_);
+    }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <class K, class T, class H, class P, class A>
     template <typename H2, typename P2>
-    void merge(boost::unordered_multimap<K, T, H2, P2, A>&& source);
+    void unordered_map<K, T, H, P, A>::merge(
+      boost::unordered_map<K, T, H2, P2, A>&& source)
+    {
+      table_.merge_unique(source.table_);
+    }
 #endif
 
+    template <class K, class T, class H, class P, class A>
     template <typename H2, typename P2>
-    void merge(boost::unordered_map<K, T, H2, P2, A>& source);
+    void unordered_map<K, T, H, P, A>::merge(
+      boost::unordered_multimap<K, T, H2, P2, A>& source)
+    {
+      table_.merge_unique(source.table_);
+    }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <class K, class T, class H, class P, class A>
     template <typename H2, typename P2>
-    void merge(boost::unordered_map<K, T, H2, P2, A>&& source);
+    void unordered_map<K, T, H, P, A>::merge(
+      boost::unordered_multimap<K, T, H2, P2, A>&& source)
+    {
+      table_.merge_unique(source.table_);
+    }
 #endif
 
     // observers
 
-    hasher hash_function() const;
-    key_equal key_eq() const;
+    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();
+    }
 
     // lookup
 
-    iterator find(const key_type&);
-    const_iterator find(const key_type&) const;
+    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>
     template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    iterator find(CompatibleKey const&, CompatibleHash const&,
-        CompatiblePredicate const&);
+      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_.find_node_impl(table::policy::apply_hash(hash, k), k, eq));
+    }
 
+    template <class K, class T, class H, class P, class A>
     template <class CompatibleKey, class CompatibleHash,
-        class CompatiblePredicate>
-    const_iterator find(CompatibleKey const&, CompatibleHash const&,
-        CompatiblePredicate const&) 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;
-
-    // bucket interface
-
-    size_type bucket_count() const BOOST_NOEXCEPT
+      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 table_.bucket_count_;
+      return const_iterator(
+        table_.find_node_impl(table::policy::apply_hash(hash, k), k, eq));
     }
 
-    size_type max_bucket_count() const BOOST_NOEXCEPT
+    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_.max_bucket_count();
+      return table_.find_node(k) ? 1 : 0;
     }
 
-    size_type bucket_size(size_type) const;
-
-    size_type bucket(const key_type& k) const
+    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_.hash_to_bucket(table_.hash(k));
+      node_pointer n = table_.find_node(k);
+      return std::make_pair(iterator(n), iterator(n ? table::next_node(n) : n));
     }
 
-    local_iterator begin(size_type n)
+    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 local_iterator(table_.begin(n), n, table_.bucket_count_);
+      node_pointer n = table_.find_node(k);
+      return std::make_pair(
+        const_iterator(n), const_iterator(n ? table::next_node(n) : n));
     }
 
-    const_local_iterator begin(size_type n) const
+    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 const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+      return table_.try_emplace_unique(k).first->second;
     }
 
-    local_iterator end(size_type) { return local_iterator(); }
-
-    const_local_iterator end(size_type) const { return const_local_iterator(); }
-
-    const_local_iterator cbegin(size_type n) const
+    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[](BOOST_RV_REF(key_type) k)
     {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+      return table_.try_emplace_unique(boost::move(k)).first->second;
     }
 
-    const_local_iterator cend(size_type) const
+    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 const_local_iterator();
+      if (table_.size_) {
+        node_pointer n = table_.find_node(k);
+        if (n)
+          return n->value().second;
+      }
+
+      boost::throw_exception(
+        std::out_of_range("Unable to find key in unordered_map."));
+    }
+
+    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
+    {
+      if (table_.size_) {
+        node_pointer n = table_.find_node(k);
+        if (n)
+          return n->value().second;
+      }
+
+      boost::throw_exception(
+        std::out_of_range("Unable to find key in unordered_map."));
+    }
+
+    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
 
-    float load_factor() const BOOST_NOEXCEPT;
-    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
-    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&);
-#endif
-}; // 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(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>
-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)
-{
-    this->insert(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_,
-          unordered_map::value_allocator_traits::
-              select_on_container_copy_construction(other.get_allocator()))
-{
-    if (other.table_.size_) {
-        table_.copy_buckets(
-            other.table_, boost::unordered::detail::true_type());
-    }
-}
-
-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)
-{
-    if (other.table_.size_) {
-        table_.copy_buckets(
-            other.table_, boost::unordered::detail::true_type());
-    }
-}
-
-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 (table_.node_alloc() == other.table_.node_alloc()) {
-        table_.move_buckets_from(other.table_);
-    } else if (other.table_.size_) {
-        // TODO: Could pick new bucket size?
-        table_.move_buckets(other.table_);
-    }
-}
-
-#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)
-{
-    this->insert(list.begin(), list.end());
-}
-
-#endif
-
-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>
-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)
-{
-    this->insert(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)
-{
-    this->insert(f, l);
-}
-
-#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 allocator_type& a)
-    : table_(
-          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
-          hasher(), key_equal(), a)
-{
-    this->insert(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)
-{
-    this->insert(list.begin(), list.end());
-}
-
-#endif
-
-template <class K, class T, class H, class P, class A>
-unordered_map<K, T, H, P, A>::~unordered_map() BOOST_NOEXCEPT
-{
-}
-
-#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<K, T, H, P, A>::operator=(
-    std::initializer_list<value_type> list)
-{
-    this->clear();
-    this->insert(list.begin(), list.end());
-    return *this;
-}
-
-#endif
-
-// 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
-{
-    using namespace std;
-
-    // size <= mlf_ * count
-    return boost::unordered::detail::double_to_size(
-               ceil(static_cast<double>(table_.mlf_) *
-                    static_cast<double>(table_.max_bucket_count()))) -
-           1;
-}
-
-// 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)
-{
-    if (first != last) {
-        table_.insert_range_unique(
-            table::extractor::extract(*first), 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)
-{
-    this->insert(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(iterator position)
-{
-    node_pointer node = table::get_node(position);
-    BOOST_ASSERT(node);
-    node_pointer next = table::next_node(node);
-    table_.erase_nodes_unique(node, next);
-    return iterator(next);
-}
-
-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)
-{
-    node_pointer node = table::get_node(position);
-    BOOST_ASSERT(node);
-    node_pointer next = table::next_node(node);
-    table_.erase_nodes_unique(node, next);
-    return iterator(next);
-}
-
-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_unique(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)
-{
-    node_pointer last_node = table::get_node(last);
-    if (first == last)
-        return iterator(last_node);
-    table_.erase_nodes_unique(table::get_node(first), last_node);
-    return iterator(last_node);
-}
-
-template <class K, class T, class H, class P, class A>
-void unordered_map<K, T, H, P, A>::swap(unordered_map& other)
-// C++17 support: BOOST_NOEXCEPT_IF(
-//    value_allocator_traits::is_always_equal::value &&
-//    is_nothrow_move_assignable_v<H> &&
-//    is_nothrow_move_assignable_v<P>)
-{
-    table_.swap(other.table_);
-}
-
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_map<K, T, H, P, A>::merge(
-    boost::unordered_map<K, T, H2, P2, A>& source)
-{
-    table_.merge_unique(source.table_);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_map<K, T, H, P, A>::merge(
-    boost::unordered_map<K, T, H2, P2, A>&& source)
-{
-    table_.merge_unique(source.table_);
-}
-#endif
-
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_map<K, T, H, P, A>::merge(
-    boost::unordered_multimap<K, T, H2, P2, A>& source)
-{
-    table_.merge_unique(source.table_);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_map<K, T, H, P, A>::merge(
-    boost::unordered_multimap<K, T, H2, P2, A>&& source)
-{
-    table_.merge_unique(source.table_);
-}
-#endif
-
-// 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>::key_equal
-unordered_map<K, T, H, P, A>::key_eq() const
-{
-    return table_.key_eq();
-}
-
-// 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>::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_.find_node_impl(table::policy::apply_hash(hash, k), k, 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_.find_node_impl(table::policy::apply_hash(hash, k), k, 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_.find_node(k) ? 1 : 0;
-}
-
-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)
-{
-    node_pointer n = table_.find_node(k);
-    return std::make_pair(iterator(n), iterator(n ? table::next_node(n) : n));
-}
-
-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
-{
-    node_pointer n = table_.find_node(k);
-    return std::make_pair(
-        const_iterator(n), const_iterator(n ? table::next_node(n) : n));
-}
-
-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_.try_emplace_unique(k).first->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[](BOOST_RV_REF(key_type) k)
-{
-    return table_.try_emplace_unique(boost::move(k)).first->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)
-{
-    if (table_.size_) {
-        node_pointer n = table_.find_node(k);
-        if (n)
-            return n->value().second;
+    template <class K, class T, class H, class P, class A>
+    float unordered_map<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+    {
+      BOOST_ASSERT(table_.bucket_count_ != 0);
+      return static_cast<float>(table_.size_) /
+             static_cast<float>(table_.bucket_count_);
     }
 
-    boost::throw_exception(
-        std::out_of_range("Unable to find key in unordered_map."));
-}
-
-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
-{
-    if (table_.size_) {
-        node_pointer n = table_.find_node(k);
-        if (n)
-            return n->value().second;
+    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);
     }
 
-    boost::throw_exception(
-        std::out_of_range("Unable to find key in unordered_map."));
-}
+    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>
-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
-
-template <class K, class T, class H, class P, class A>
-float unordered_map<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
-{
-    BOOST_ASSERT(table_.bucket_count_ != 0);
-    return static_cast<float>(table_.size_) /
-           static_cast<float>(table_.bucket_count_);
-}
-
-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>::reserve(size_type n)
-{
-    table_.rehash(static_cast<std::size_t>(
+    template <class K, class T, class H, class P, class A>
+    void unordered_map<K, T, H, P, A>::reserve(size_type n)
+    {
+      table_.rehash(static_cast<std::size_t>(
         std::ceil(static_cast<double>(n) / table_.mlf_)));
-}
+    }
 
-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
+    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)
     {
-        unordered_map<K, T, H, P, A> x;
-    };
-#endif
-    return m1.table_.equals_unique(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)
-{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-    struct dummy
-    {
+      struct dummy
+      {
         unordered_map<K, T, H, P, A> x;
-    };
+      };
 #endif
-    return !m1.table_.equals_unique(m2.table_);
-}
+      return m1.table_.equals_unique(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)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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
-    {
+      struct dummy
+      {
         unordered_map<K, T, H, P, A> x;
-    };
+      };
 #endif
-    m1.swap(m2);
-}
+      return !m1.table_.equals_unique(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)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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(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()
+        : table_(boost::unordered::detail::default_bucket_count, hasher(),
+            key_equal(), allocator_type())
+    {
+    }
 
-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)
-{
-    this->insert(f, l);
-}
+    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(
-    unordered_multimap const& other)
-    : table_(other.table_,
-          unordered_multimap::value_allocator_traits::
+    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)
+    {
+      this->insert(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_,
+            unordered_multimap::value_allocator_traits::
               select_on_container_copy_construction(other.get_allocator()))
-{
-    if (other.table_.size_) {
+    {
+      if (other.table_.size_) {
         table_.copy_buckets(
-            other.table_, boost::unordered::detail::false_type());
+          other.table_, boost::unordered::detail::false_type());
+      }
     }
-}
 
-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)
-{
-    if (other.table_.size_) {
+    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)
+    {
+      if (other.table_.size_) {
         table_.copy_buckets(
-            other.table_, boost::unordered::detail::false_type());
+          other.table_, boost::unordered::detail::false_type());
+      }
     }
-}
 
-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 (table_.node_alloc() == other.table_.node_alloc()) {
+    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 (table_.node_alloc() == other.table_.node_alloc()) {
         table_.move_buckets_from(other.table_);
-    } else if (other.table_.size_) {
+      } else if (other.table_.size_) {
         // TODO: Could pick new bucket size?
         table_.move_buckets_equiv(other.table_);
+      }
     }
-}
 
 #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)
-{
-    this->insert(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)
+    {
+      this->insert(list.begin(), list.end());
+    }
 
 #endif
 
-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>
-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)
-{
-    this->insert(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)
+    {
+      this->insert(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)
-{
-    this->insert(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)
+    {
+      this->insert(f, l);
+    }
 
 #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 allocator_type& a)
-    : table_(
-          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
-          hasher(), key_equal(), a)
-{
-    this->insert(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)
+    {
+      this->insert(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)
-{
-    this->insert(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)
+    {
+      this->insert(list.begin(), list.end());
+    }
 
 #endif
 
-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() BOOST_NOEXCEPT
+    {
+    }
 
 #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<K, T, H, P, A>::operator=(
-    std::initializer_list<value_type> list)
-{
-    this->clear();
-    this->insert(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)
+    {
+      this->clear();
+      this->insert(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
-{
-    using namespace std;
+    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
+    {
+      using namespace std;
 
-    // size <= mlf_ * count
-    return boost::unordered::detail::double_to_size(
+      // size <= mlf_ * count
+      return boost::unordered::detail::double_to_size(
                ceil(static_cast<double>(table_.mlf_) *
                     static_cast<double>(table_.max_bucket_count()))) -
-           1;
-}
+             1;
+    }
 
-// 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_equiv(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_equiv(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)
-{
-    this->insert(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)
+    {
+      this->insert(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(iterator position)
-{
-    node_pointer node = table::get_node(position);
-    BOOST_ASSERT(node);
-    node_pointer next = table::next_node(node);
-    table_.erase_nodes_equiv(node, next);
-    return iterator(next);
-}
+    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(iterator position)
+    {
+      node_pointer node = table::get_node(position);
+      BOOST_ASSERT(node);
+      node_pointer next = table::next_node(node);
+      table_.erase_nodes_equiv(node, next);
+      return iterator(next);
+    }
 
-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)
-{
-    node_pointer node = table::get_node(position);
-    BOOST_ASSERT(node);
-    node_pointer next = table::next_node(node);
-    table_.erase_nodes_equiv(node, next);
-    return iterator(next);
-}
+    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)
+    {
+      node_pointer node = table::get_node(position);
+      BOOST_ASSERT(node);
+      node_pointer next = table::next_node(node);
+      table_.erase_nodes_equiv(node, next);
+      return iterator(next);
+    }
 
-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_equiv(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_equiv(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)
-{
-    node_pointer last_node = table::get_node(last);
-    if (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)
+    {
+      node_pointer last_node = table::get_node(last);
+      if (first == last)
         return iterator(last_node);
-    table_.erase_nodes_equiv(table::get_node(first), last_node);
-    return iterator(last_node);
-}
-
-template <class K, class T, class H, class P, class A>
-void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other)
-// C++17 support: BOOST_NOEXCEPT_IF(
-//    value_allocator_traits::is_always_equal::value &&
-//    is_nothrow_move_assignable_v<H> &&
-//    is_nothrow_move_assignable_v<P>)
-{
-    table_.swap(other.table_);
-}
-
-// 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>::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>
-template <typename H2, typename P2>
-void unordered_multimap<K, T, H, P, A>::merge(
-    boost::unordered_multimap<K, T, H2, P2, A>& source)
-{
-    while (!source.empty()) {
-        insert(source.extract(source.begin()));
+      table_.erase_nodes_equiv(table::get_node(first), last_node);
+      return iterator(last_node);
+    }
+
+    template <class K, class T, class H, class P, class A>
+    void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other)
+    // C++17 support: BOOST_NOEXCEPT_IF(
+    //    value_allocator_traits::is_always_equal::value &&
+    //    is_nothrow_move_assignable_v<H> &&
+    //    is_nothrow_move_assignable_v<P>)
+    {
+      table_.swap(other.table_);
+    }
+
+    // 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>::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>
+    template <typename H2, typename P2>
+    void unordered_multimap<K, T, H, P, A>::merge(
+      boost::unordered_multimap<K, T, H2, P2, A>& source)
+    {
+      while (!source.empty()) {
+        insert(source.extract(source.begin()));
+      }
     }
-}
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multimap<K, T, H, P, A>::merge(
-    boost::unordered_multimap<K, T, H2, P2, A>&& source)
-{
-    while (!source.empty()) {
+    template <class K, class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multimap<K, T, H, P, A>::merge(
+      boost::unordered_multimap<K, T, H2, P2, A>&& source)
+    {
+      while (!source.empty()) {
         insert(source.extract(source.begin()));
+      }
     }
-}
 #endif
 
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multimap<K, T, H, P, A>::merge(
-    boost::unordered_map<K, T, H2, P2, A>& source)
-{
-    while (!source.empty()) {
+    template <class K, class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multimap<K, T, H, P, A>::merge(
+      boost::unordered_map<K, T, H2, P2, A>& source)
+    {
+      while (!source.empty()) {
         insert(source.extract(source.begin()));
+      }
     }
-}
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class K, class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multimap<K, T, H, P, A>::merge(
-    boost::unordered_map<K, T, H2, P2, A>&& source)
-{
-    while (!source.empty()) {
+    template <class K, class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multimap<K, T, H, P, A>::merge(
+      boost::unordered_map<K, T, H2, P2, A>&& source)
+    {
+      while (!source.empty()) {
         insert(source.extract(source.begin()));
+      }
     }
-}
 #endif
 
-// 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(
+    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_.find_node_impl(table::policy::apply_hash(hash, k), k, 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(
+    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_.find_node_impl(table::policy::apply_hash(hash, k), k, 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
-{
-    node_pointer n = table_.find_node(k);
-    return n ? table_.group_count(n) : 0;
-}
+    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
+    {
+      node_pointer n = table_.find_node(k);
+      return n ? table_.group_count(n) : 0;
+    }
 
-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)
-{
-    node_pointer n = table_.find_node(k);
-    return std::make_pair(iterator(n), iterator(n ? table_.next_group(n) : n));
-}
+    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)
+    {
+      node_pointer n = table_.find_node(k);
+      return std::make_pair(
+        iterator(n), iterator(n ? table_.next_group(n) : n));
+    }
 
-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
-{
-    node_pointer n = table_.find_node(k);
-    return std::make_pair(
+    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
+    {
+      node_pointer n = table_.find_node(k);
+      return std::make_pair(
         const_iterator(n), const_iterator(n ? table_.next_group(n) : 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);
-}
+    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
-{
-    BOOST_ASSERT(table_.bucket_count_ != 0);
-    return static_cast<float>(table_.size_) /
-           static_cast<float>(table_.bucket_count_);
-}
+    template <class K, class T, class H, class P, class A>
+    float unordered_multimap<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+    {
+      BOOST_ASSERT(table_.bucket_count_ != 0);
+      return static_cast<float>(table_.size_) /
+             static_cast<float>(table_.bucket_count_);
+    }
 
-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_.rehash(static_cast<std::size_t>(
+    template <class K, class T, class H, class P, class A>
+    void unordered_multimap<K, T, H, P, A>::reserve(size_type n)
+    {
+      table_.rehash(static_cast<std::size_t>(
         std::ceil(static_cast<double>(n) / table_.mlf_)));
-}
+    }
 
-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
+    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)
     {
-        unordered_multimap<K, T, H, P, A> x;
-    };
-#endif
-    return m1.table_.equals_equiv(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)
-{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-    struct dummy
-    {
+      struct dummy
+      {
         unordered_multimap<K, T, H, P, A> x;
-    };
+      };
 #endif
-    return !m1.table_.equals_equiv(m2.table_);
-}
+      return m1.table_.equals_equiv(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)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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
-    {
+      struct dummy
+      {
         unordered_multimap<K, T, H, P, A> x;
-    };
+      };
 #endif
-    m1.swap(m2);
-}
+      return !m1.table_.equals_equiv(m2.table_);
+    }
 
-template <typename N, class K, class T, class A> class node_handle_map
-{
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_map)
+    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)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
+    {
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+      struct dummy
+      {
+        unordered_multimap<K, T, H, P, A> x;
+      };
+#endif
+      m1.swap(m2);
+    }
 
-    template <typename Types> friend struct ::boost::unordered::detail::table;
-    template <class K2, class T2, class H2, class P2, class A2>
-    friend class boost::unordered::unordered_map;
-    template <class K2, class T2, class H2, class P2, class A2>
-    friend class boost::unordered::unordered_multimap;
+    template <typename N, class K, class T, class A> class node_handle_map
+    {
+      BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_map)
 
-    typedef typename boost::unordered::detail::rebind_wrap<A,
+      template <typename Types> friend struct ::boost::unordered::detail::table;
+      template <class K2, class T2, class H2, class P2, class A2>
+      friend class boost::unordered::unordered_map;
+      template <class K2, class T2, class H2, class P2, class A2>
+      friend class boost::unordered::unordered_multimap;
+
+      typedef typename boost::unordered::detail::rebind_wrap<A,
         std::pair<K const, T> >::type value_allocator;
-    typedef boost::unordered::detail::allocator_traits<value_allocator>
+      typedef boost::unordered::detail::allocator_traits<value_allocator>
         value_allocator_traits;
-    typedef N node;
-    typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
+      typedef N node;
+      typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
         node_allocator;
-    typedef boost::unordered::detail::allocator_traits<node_allocator>
+      typedef boost::unordered::detail::allocator_traits<node_allocator>
         node_allocator_traits;
-    typedef typename node_allocator_traits::pointer node_pointer;
+      typedef typename node_allocator_traits::pointer node_pointer;
 
-  public:
-    typedef K key_type;
-    typedef T mapped_type;
-    typedef A allocator_type;
+    public:
+      typedef K key_type;
+      typedef T mapped_type;
+      typedef A allocator_type;
 
-  private:
-    node_pointer ptr_;
-    bool has_alloc_;
-    boost::unordered::detail::value_base<value_allocator> alloc_;
+    private:
+      node_pointer ptr_;
+      bool has_alloc_;
+      boost::unordered::detail::value_base<value_allocator> alloc_;
 
-    node_handle_map(node_pointer ptr, allocator_type const& a)
-        : ptr_(ptr), has_alloc_(false)
-    {
+      node_handle_map(node_pointer ptr, allocator_type const& a)
+          : ptr_(ptr), has_alloc_(false)
+      {
         if (ptr_) {
-            new ((void*)&alloc_) value_allocator(a);
-            has_alloc_ = true;
+          new ((void*)&alloc_) value_allocator(a);
+          has_alloc_ = true;
         }
-    }
+      }
 
-  public:
-    BOOST_CONSTEXPR node_handle_map() BOOST_NOEXCEPT : ptr_(), has_alloc_(false)
-    {
-    }
+    public:
+      BOOST_CONSTEXPR node_handle_map() BOOST_NOEXCEPT : ptr_(),
+                                                         has_alloc_(false)
+      {
+      }
 
-    ~node_handle_map()
-    {
+      ~node_handle_map()
+      {
         if (has_alloc_ && ptr_) {
-            node_allocator node_alloc(alloc_.value());
-            boost::unordered::detail::node_tmp<node_allocator> tmp(
-                ptr_, node_alloc);
+          node_allocator node_alloc(alloc_.value());
+          boost::unordered::detail::node_tmp<node_allocator> tmp(
+            ptr_, node_alloc);
         }
         if (has_alloc_) {
-            alloc_.value_ptr()->~value_allocator();
+          alloc_.value_ptr()->~value_allocator();
         }
-    }
+      }
 
-    node_handle_map(BOOST_RV_REF(node_handle_map) n) BOOST_NOEXCEPT
+      node_handle_map(BOOST_RV_REF(node_handle_map) n) BOOST_NOEXCEPT
         : ptr_(n.ptr_),
           has_alloc_(false)
-    {
+      {
         if (n.has_alloc_) {
-            new ((void*)&alloc_) value_allocator(boost::move(n.alloc_.value()));
-            has_alloc_ = true;
-            n.ptr_ = node_pointer();
-            n.alloc_.value_ptr()->~value_allocator();
-            n.has_alloc_ = false;
+          new ((void*)&alloc_) value_allocator(boost::move(n.alloc_.value()));
+          has_alloc_ = true;
+          n.ptr_ = node_pointer();
+          n.alloc_.value_ptr()->~value_allocator();
+          n.has_alloc_ = false;
         }
-    }
+      }
 
-    node_handle_map& operator=(BOOST_RV_REF(node_handle_map) n)
-    {
+      node_handle_map& operator=(BOOST_RV_REF(node_handle_map) n)
+      {
         BOOST_ASSERT(!has_alloc_ ||
                      value_allocator_traits::
-                         propagate_on_container_move_assignment::value ||
+                       propagate_on_container_move_assignment::value ||
                      (n.has_alloc_ && alloc_.value() == n.alloc_.value()));
 
         if (ptr_) {
-            node_allocator node_alloc(alloc_.value());
-            boost::unordered::detail::node_tmp<node_allocator> tmp(
-                ptr_, node_alloc);
-            ptr_ = node_pointer();
+          node_allocator node_alloc(alloc_.value());
+          boost::unordered::detail::node_tmp<node_allocator> tmp(
+            ptr_, node_alloc);
+          ptr_ = node_pointer();
         }
 
         if (has_alloc_) {
-            alloc_.value_ptr()->~value_allocator();
-            has_alloc_ = false;
+          alloc_.value_ptr()->~value_allocator();
+          has_alloc_ = false;
         }
 
         if (!has_alloc_ && n.has_alloc_) {
-            move_allocator(n);
+          move_allocator(n);
         }
 
         ptr_ = n.ptr_;
         n.ptr_ = node_pointer();
 
         return *this;
-    }
+      }
 
-    key_type& key() const { return const_cast<key_type&>(ptr_->value().first); }
+      key_type& key() const
+      {
+        return const_cast<key_type&>(ptr_->value().first);
+      }
 
-    mapped_type& mapped() const { return ptr_->value().second; }
+      mapped_type& mapped() const { return ptr_->value().second; }
 
-    allocator_type get_allocator() const { return alloc_.value(); }
+      allocator_type get_allocator() const { return alloc_.value(); }
 
-    BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
+      BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
 
-    bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
+      bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
 
-    bool empty() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
+      bool empty() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
 
-    void swap(node_handle_map& n) BOOST_NOEXCEPT_IF(
+      void swap(node_handle_map& n) BOOST_NOEXCEPT_IF(
         value_allocator_traits::propagate_on_container_swap::value
         /* || value_allocator_traits::is_always_equal::value */)
-    {
+      {
         if (!has_alloc_) {
-            if (n.has_alloc_) {
-                move_allocator(n);
-            }
+          if (n.has_alloc_) {
+            move_allocator(n);
+          }
         } else if (!n.has_alloc_) {
-            n.move_allocator(*this);
+          n.move_allocator(*this);
         } else {
-            swap_impl(n, boost::unordered::detail::integral_constant<bool,
-                             value_allocator_traits::
-                                 propagate_on_container_swap::value>());
+          swap_impl(
+            n, boost::unordered::detail::integral_constant<bool,
+                 value_allocator_traits::propagate_on_container_swap::value>());
         }
         boost::swap(ptr_, n.ptr_);
-    }
+      }
 
-  private:
-    void move_allocator(node_handle_map& n)
-    {
+    private:
+      void move_allocator(node_handle_map& n)
+      {
         new ((void*)&alloc_) value_allocator(boost::move(n.alloc_.value()));
         n.alloc_.value_ptr()->~value_allocator();
         has_alloc_ = true;
         n.has_alloc_ = false;
-    }
+      }
 
-    void swap_impl(node_handle_map&, boost::unordered::detail::false_type) {}
+      void swap_impl(node_handle_map&, boost::unordered::detail::false_type) {}
 
-    void swap_impl(node_handle_map& n, boost::unordered::detail::true_type)
-    {
+      void swap_impl(node_handle_map& n, boost::unordered::detail::true_type)
+      {
         boost::swap(alloc_, n.alloc_);
+      }
+    };
+
+    template <class N, class K, class T, class A>
+    void swap(node_handle_map<N, K, T, A>& x, node_handle_map<N, K, T, A>& y)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
+    {
+      x.swap(y);
     }
-};
 
-template <class N, class K, class T, class A>
-void swap(node_handle_map<N, K, T, A>& x, node_handle_map<N, K, T, A>& y)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
-{
-    x.swap(y);
-}
+    template <class N, class K, class T, class A> struct insert_return_type_map
+    {
+    private:
+      BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_map)
 
-template <class N, class K, class T, class A> struct insert_return_type_map
-{
-  private:
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_map)
-
-    typedef typename boost::unordered::detail::rebind_wrap<A,
+      typedef typename boost::unordered::detail::rebind_wrap<A,
         std::pair<K const, T> >::type value_allocator;
-    typedef N node_;
+      typedef N node_;
 
-  public:
-    bool inserted;
-    boost::unordered::iterator_detail::iterator<node_> position;
-    boost::unordered::node_handle_map<N, K, T, A> node;
+    public:
+      bool inserted;
+      boost::unordered::iterator_detail::iterator<node_> position;
+      boost::unordered::node_handle_map<N, K, T, A> node;
 
-    insert_return_type_map() : inserted(false), position(), node() {}
+      insert_return_type_map() : inserted(false), position(), node() {}
 
-    insert_return_type_map(BOOST_RV_REF(insert_return_type_map)
-            x) BOOST_NOEXCEPT : inserted(x.inserted),
-                                position(x.position),
-                                node(boost::move(x.node))
-    {
-    }
+      insert_return_type_map(BOOST_RV_REF(insert_return_type_map)
+          x) BOOST_NOEXCEPT : inserted(x.inserted),
+                              position(x.position),
+                              node(boost::move(x.node))
+      {
+      }
 
-    insert_return_type_map& operator=(BOOST_RV_REF(insert_return_type_map) x)
-    {
+      insert_return_type_map& operator=(BOOST_RV_REF(insert_return_type_map) x)
+      {
         inserted = x.inserted;
         position = x.position;
         node = boost::move(x.node);
         return *this;
-    }
-};
+      }
+    };
 
-template <class N, class K, class T, class A>
-void swap(insert_return_type_map<N, K, T, A>& x,
-    insert_return_type_map<N, K, T, A>& y)
-{
-    boost::swap(x.node, y.node);
-    boost::swap(x.inserted, y.inserted);
-    boost::swap(x.position, y.position);
-}
-} // namespace unordered
+    template <class N, class K, class T, class A>
+    void swap(insert_return_type_map<N, K, T, A>& x,
+      insert_return_type_map<N, K, T, A>& y)
+    {
+      boost::swap(x.node, y.node);
+      boost::swap(x.inserted, y.inserted);
+      boost::swap(x.position, y.position);
+    }
+  } // namespace unordered
 } // namespace boost
 
 #if defined(BOOST_MSVC)
diff --git a/include/boost/unordered/unordered_map_fwd.hpp b/include/boost/unordered/unordered_map_fwd.hpp
index ebac59b4..794b7042 100644
--- a/include/boost/unordered/unordered_map_fwd.hpp
+++ b/include/boost/unordered/unordered_map_fwd.hpp
@@ -17,48 +17,48 @@
 #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 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>& m1, unordered_map<K, T, H, P, A>& m2)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
+    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>& m1, unordered_map<K, T, H, P, A>& m2)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-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>& m1,
-    unordered_multimap<K, T, H, P, A>& m2)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
+    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>& m1,
+      unordered_multimap<K, T, H, P, A>& m2)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-template <class N, class K, class T, class A> class node_handle_map;
-template <class N, class K, class T, class A> struct insert_return_type_map;
-}
+    template <class N, class K, class T, class A> class node_handle_map;
+    template <class N, class K, class T, class A> struct insert_return_type_map;
+  }
 
-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 985742ff..5a8791a6 100644
--- a/include/boost/unordered/unordered_set.hpp
+++ b/include/boost/unordered/unordered_set.hpp
@@ -33,2011 +33,2023 @@
 #endif
 
 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)
+      BOOST_COPYABLE_AND_MOVABLE(unordered_set)
 #endif
-    template <typename, typename, typename, typename>
-    friend class unordered_multiset;
+      template <typename, typename, typename, typename>
+      friend class unordered_multiset;
 
-  public:
-    typedef T key_type;
-    typedef T value_type;
-    typedef H hasher;
-    typedef P key_equal;
-    typedef A allocator_type;
+    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::value_allocator_traits value_allocator_traits;
-    typedef typename types::table table;
-    typedef typename table::node_pointer node_pointer;
-    typedef typename table::link_pointer link_pointer;
+    private:
+      typedef boost::unordered::detail::set<A, T, H, P> types;
+      typedef typename types::value_allocator_traits value_allocator_traits;
+      typedef typename types::table table;
+      typedef typename table::node_pointer node_pointer;
+      typedef typename table::link_pointer link_pointer;
 
-  public:
-    typedef typename value_allocator_traits::pointer pointer;
-    typedef typename value_allocator_traits::const_pointer const_pointer;
+    public:
+      typedef typename value_allocator_traits::pointer pointer;
+      typedef typename value_allocator_traits::const_pointer const_pointer;
 
-    typedef value_type& reference;
-    typedef value_type const& const_reference;
+      typedef value_type& reference;
+      typedef value_type const& const_reference;
 
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
 
-    typedef typename table::iterator iterator;
-    typedef typename table::c_iterator const_iterator;
-    typedef typename table::l_iterator local_iterator;
-    typedef typename table::cl_iterator const_local_iterator;
-    typedef typename types::node_type node_type;
-    typedef typename types::insert_return_type insert_return_type;
+      typedef typename table::iterator iterator;
+      typedef typename table::c_iterator const_iterator;
+      typedef typename table::l_iterator local_iterator;
+      typedef typename table::cl_iterator const_local_iterator;
+      typedef typename types::node_type node_type;
+      typedef typename types::insert_return_type insert_return_type;
 
-  private:
-    table table_;
+    private:
+      table table_;
 
-  public:
-    // constructors
+    public:
+      // constructors
 
-    unordered_set();
+      unordered_set();
 
-    explicit unordered_set(size_type, const hasher& = hasher(),
+      explicit unordered_set(size_type, const hasher& = hasher(),
         const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    template <class InputIt>
-    unordered_set(InputIt, InputIt,
+      template <class InputIt>
+      unordered_set(InputIt, InputIt,
         size_type = boost::unordered::detail::default_bucket_count,
         const hasher& = hasher(), const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    unordered_set(unordered_set const&);
+      unordered_set(unordered_set const&);
 
 #if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_set(BOOST_RV_REF(unordered_set) other)
+  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      unordered_set(BOOST_RV_REF(unordered_set) other)
         BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-        : table_(other.table_, boost::unordered::detail::move_tag())
-    {
+          : table_(other.table_, boost::unordered::detail::move_tag())
+      {
         // The move is done in table_
-    }
+      }
 #endif
 
-    explicit unordered_set(allocator_type const&);
+      explicit unordered_set(allocator_type const&);
 
-    unordered_set(unordered_set const&, allocator_type const&);
+      unordered_set(unordered_set const&, allocator_type const&);
 
-    unordered_set(BOOST_RV_REF(unordered_set), allocator_type const&);
+      unordered_set(BOOST_RV_REF(unordered_set), allocator_type const&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_set(std::initializer_list<value_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());
 #endif
 
-    explicit unordered_set(size_type, const allocator_type&);
+      explicit unordered_set(size_type, const allocator_type&);
 
-    explicit unordered_set(size_type, const hasher&, const allocator_type&);
+      explicit unordered_set(size_type, const hasher&, const allocator_type&);
 
-    template <class InputIt>
-    unordered_set(InputIt, InputIt, size_type, const allocator_type&);
+      template <class InputIt>
+      unordered_set(InputIt, InputIt, size_type, const allocator_type&);
 
-    template <class InputIt>
-    unordered_set(
+      template <class InputIt>
+      unordered_set(
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_set(
+      unordered_set(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
-    unordered_set(std::initializer_list<value_type>, size_type, const hasher&,
+      unordered_set(std::initializer_list<value_type>, size_type, const hasher&,
         const allocator_type&);
 #endif
 
-    // Destructor
+      // Destructor
 
-    ~unordered_set() BOOST_NOEXCEPT;
+      ~unordered_set() BOOST_NOEXCEPT;
 
 // Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-    unordered_set& operator=(BOOST_COPY_ASSIGN_REF(unordered_set) x)
-    {
+      unordered_set& operator=(BOOST_COPY_ASSIGN_REF(unordered_set) x)
+      {
         table_.assign(x.table_, boost::unordered::detail::true_type());
         return *this;
-    }
+      }
 
-    unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::true_type());
         return *this;
-    }
+      }
 #else
-    unordered_set& operator=(unordered_set const& x)
-    {
+      unordered_set& operator=(unordered_set const& x)
+      {
         table_.assign(x.table_, boost::unordered::detail::true_type());
         return *this;
-    }
+      }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_set& operator=(unordered_set&& x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_set& operator=(unordered_set&& x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::true_type());
         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
-    {
+      allocator_type get_allocator() const BOOST_NOEXCEPT
+      {
         return table_.node_alloc();
-    }
+      }
 
-    // iterators
+      // iterators
 
-    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
+      iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-    const_iterator begin() const BOOST_NOEXCEPT
-    {
+      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
-    {
+      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(); }
 
-    // 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;
 
 // emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
+      {
         return table_.emplace_unique(
-            table::extractor::extract(boost::forward<Args>(args)...),
-            boost::forward<Args>(args)...);
-    }
+          table::extractor::extract(boost::forward<Args>(args)...),
+          boost::forward<Args>(args)...);
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    // 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(
+      std::pair<iterator, bool> emplace(
         boost::unordered::detail::empty_emplace =
-            boost::unordered::detail::empty_emplace(),
+          boost::unordered::detail::empty_emplace(),
         value_type v = value_type())
-    {
+      {
         return this->emplace(boost::move(v));
-    }
+      }
 
 #endif
 
-    template <typename A0>
-    std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0>
+      std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
+      {
         return table_.emplace_unique(
-            table::extractor::extract(boost::forward<A0>(a0)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0)));
-    }
+          table::extractor::extract(boost::forward<A0>(a0)),
+          boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    std::pair<iterator, bool> emplace(
+      template <typename A0, typename A1>
+      std::pair<iterator, bool> emplace(
         BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return table_.emplace_unique(
-            table::extractor::extract(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+          table::extractor::extract(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)),
+          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(
+      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_unique(
-            table::extractor::extract(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1),
-                boost::forward<A2>(a2)));
-    }
+          table::extractor::extract(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+      {
         return table_.emplace_hint_unique(hint,
-            table::extractor::extract(boost::forward<Args>(args)...),
-            boost::forward<Args>(args)...);
-    }
+          table::extractor::extract(boost::forward<Args>(args)...),
+          boost::forward<Args>(args)...);
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    iterator emplace_hint(const_iterator hint,
+      iterator emplace_hint(const_iterator hint,
         boost::unordered::detail::empty_emplace =
-            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_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+      {
         return table_.emplace_hint_unique(hint,
-            table::extractor::extract(boost::forward<A0>(a0)),
-            boost::unordered::detail::create_emplace_args(
-                                              boost::forward<A0>(a0)));
-    }
+          table::extractor::extract(boost::forward<A0>(a0)),
+          boost::unordered::detail::create_emplace_args(
+                                            boost::forward<A0>(a0)));
+      }
 
-    template <typename A0, typename A1>
-    iterator emplace_hint(
+      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_unique(
-            hint, table::extractor::extract(
-                      boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1)));
-    }
+      {
+        return table_.emplace_hint_unique(hint,
+          table::extractor::extract(boost::forward<A0>(a0),
+                                            boost::forward<A1>(a1)),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+                                            boost::forward<A1>(a1)));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+      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_unique(
-            hint, table::extractor::extract(
-                      boost::forward<A0>(a0), boost::forward<A1>(a1)),
-            boost::unordered::detail::create_emplace_args(
-                boost::forward<A0>(a0), boost::forward<A1>(a1),
-                boost::forward<A2>(a2)));
-    }
+          hint, table::extractor::extract(
+                  boost::forward<A0>(a0), boost::forward<A1>(a1)),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
 
 #endif
 
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 #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_unique(                                          \
-            table::extractor::extract(                                         \
-                boost::forward<A0>(a0), boost::forward<A1>(a1)),               \
-            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)>                          \
+  std::pair<iterator, bool> emplace(                                           \
+    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                        \
+  {                                                                            \
+    return table_.emplace_unique(                                              \
+      table::extractor::extract(                                               \
+        boost::forward<A0>(a0), boost::forward<A1>(a1)),                       \
+      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_unique(                                     \
-            hint, table::extractor::extract(                                   \
-                      boost::forward<A0>(a0), boost::forward<A1>(a1)),         \
-            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_unique(                                         \
+      hint, table::extractor::extract(                                         \
+              boost::forward<A0>(a0), boost::forward<A1>(a1)),                 \
+      boost::unordered::detail::create_emplace_args(                           \
+        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));               \
+  }
 
-    BOOST_UNORDERED_EMPLACE(1, 4, _)
-    BOOST_UNORDERED_EMPLACE(1, 5, _)
-    BOOST_UNORDERED_EMPLACE(1, 6, _)
-    BOOST_UNORDERED_EMPLACE(1, 7, _)
-    BOOST_UNORDERED_EMPLACE(1, 8, _)
-    BOOST_UNORDERED_EMPLACE(1, 9, _)
-    BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+      BOOST_UNORDERED_EMPLACE(1, 4, _)
+      BOOST_UNORDERED_EMPLACE(1, 5, _)
+      BOOST_UNORDERED_EMPLACE(1, 6, _)
+      BOOST_UNORDERED_EMPLACE(1, 7, _)
+      BOOST_UNORDERED_EMPLACE(1, 8, _)
+      BOOST_UNORDERED_EMPLACE(1, 9, _)
+      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
         BOOST_UNORDERED_EMPLACE, _)
 
 #undef BOOST_UNORDERED_EMPLACE
 
 #endif
 
-    std::pair<iterator, bool> insert(value_type const& 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)
-    {
+      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)
-    {
+      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)
-    {
+      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
 
-    // extract
+      // extract
 
-    node_type extract(const_iterator position)
-    {
+      node_type extract(const_iterator position)
+      {
         return node_type(
-            table_.extract_by_iterator_unique(position), table_.node_alloc());
-    }
+          table_.extract_by_iterator_unique(position), table_.node_alloc());
+      }
 
-    node_type extract(const key_type& k)
-    {
+      node_type extract(const key_type& k)
+      {
         return node_type(table_.extract_by_key(k), table_.node_alloc());
-    }
+      }
 
-    insert_return_type insert(BOOST_RV_REF(node_type) np)
-    {
+      insert_return_type insert(BOOST_RV_REF(node_type) np)
+      {
         insert_return_type result;
         table_.move_insert_node_type_unique(np, result);
         return boost::move(result);
-    }
+      }
 
-    iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
-    {
+      iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
+      {
         return table_.move_insert_node_type_with_hint_unique(hint, np);
-    }
+      }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ||                               \
-    (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
-  private:
-    // Note: Use r-value node_type to insert.
-    insert_return_type insert(node_type&);
-    iterator insert(const_iterator, node_type& np);
+  (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
+    private:
+      // Note: Use r-value node_type to insert.
+      insert_return_type insert(node_type&);
+      iterator insert(const_iterator, node_type& np);
 
-  public:
+    public:
 #endif
 
-    iterator erase(const_iterator);
-    size_type erase(const key_type&);
-    iterator erase(const_iterator, const_iterator);
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    void quick_erase(const_iterator it) { erase(it); }
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    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);
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void quick_erase(const_iterator it) { erase(it); }
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void erase_return_void(const_iterator it) { erase(it); }
 
-    void swap(unordered_set&);
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+      void swap(unordered_set&);
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
 
-    template <typename H2, typename P2>
-    void merge(boost::unordered_set<T, H2, P2, A>& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_set<T, H2, P2, A>& source);
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename H2, typename P2>
-    void merge(boost::unordered_set<T, H2, P2, A>&& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_set<T, H2, P2, A>&& source);
 #endif
 
-    template <typename H2, typename P2>
-    void merge(boost::unordered_multiset<T, H2, P2, A>& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multiset<T, H2, P2, A>& source);
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename H2, typename P2>
-    void merge(boost::unordered_multiset<T, H2, P2, A>&& source);
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multiset<T, H2, P2, A>&& source);
 #endif
 
-    // 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,
+      template <class CompatibleKey, class CompatibleHash,
         class CompatiblePredicate>
-    const_iterator find(CompatibleKey const&, CompatibleHash const&,
+      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(
+      std::pair<const_iterator, const_iterator> equal_range(
         const key_type&) const;
 
-    // bucket interface
+      // bucket interface
 
-    size_type bucket_count() const BOOST_NOEXCEPT
-    {
+      size_type bucket_count() const BOOST_NOEXCEPT
+      {
         return table_.bucket_count_;
-    }
+      }
 
-    size_type max_bucket_count() const BOOST_NOEXCEPT
-    {
+      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
-    {
+      size_type bucket(const key_type& k) const
+      {
         return table_.hash_to_bucket(table_.hash(k));
-    }
+      }
 
-    local_iterator begin(size_type n)
-    {
+      local_iterator begin(size_type n)
+      {
         return local_iterator(table_.begin(n), n, table_.bucket_count_);
-    }
+      }
 
-    const_local_iterator begin(size_type n) const
-    {
+      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 cbegin(size_type n) const
-    {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
-    }
-
-    const_local_iterator cend(size_type) const
-    {
+      const_local_iterator end(size_type) const
+      {
         return const_local_iterator();
-    }
+      }
 
-    // hash policy
+      const_local_iterator cbegin(size_type n) const
+      {
+        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+      }
 
-    float load_factor() const BOOST_NOEXCEPT;
-    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
-    void max_load_factor(float) BOOST_NOEXCEPT;
-    void rehash(size_type);
-    void reserve(size_type);
+      const_local_iterator cend(size_type) const
+      {
+        return const_local_iterator();
+      }
+
+      // hash policy
+
+      float load_factor() const BOOST_NOEXCEPT;
+      float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
+      void max_load_factor(float) BOOST_NOEXCEPT;
+      void rehash(size_type);
+      void reserve(size_type);
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-    friend bool operator==
+      friend bool operator==
         <T, H, P, A>(unordered_set const&, unordered_set const&);
-    friend bool operator!=
+      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)
+      BOOST_COPYABLE_AND_MOVABLE(unordered_multiset)
 #endif
-    template <typename, typename, typename, typename>
-    friend class unordered_set;
+      template <typename, typename, typename, typename>
+      friend class unordered_set;
 
-  public:
-    typedef T key_type;
-    typedef T value_type;
-    typedef H hasher;
-    typedef P key_equal;
-    typedef A allocator_type;
+    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::value_allocator_traits value_allocator_traits;
-    typedef typename types::table table;
-    typedef typename table::node_pointer node_pointer;
-    typedef typename table::link_pointer link_pointer;
+    private:
+      typedef boost::unordered::detail::set<A, T, H, P> types;
+      typedef typename types::value_allocator_traits value_allocator_traits;
+      typedef typename types::table table;
+      typedef typename table::node_pointer node_pointer;
+      typedef typename table::link_pointer link_pointer;
 
-  public:
-    typedef typename value_allocator_traits::pointer pointer;
-    typedef typename value_allocator_traits::const_pointer const_pointer;
+    public:
+      typedef typename value_allocator_traits::pointer pointer;
+      typedef typename value_allocator_traits::const_pointer const_pointer;
 
-    typedef value_type& reference;
-    typedef value_type const& const_reference;
+      typedef value_type& reference;
+      typedef value_type const& const_reference;
 
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
 
-    typedef typename table::iterator iterator;
-    typedef typename table::c_iterator const_iterator;
-    typedef typename table::l_iterator local_iterator;
-    typedef typename table::cl_iterator const_local_iterator;
-    typedef typename types::node_type node_type;
+      typedef typename table::iterator iterator;
+      typedef typename table::c_iterator const_iterator;
+      typedef typename table::l_iterator local_iterator;
+      typedef typename table::cl_iterator const_local_iterator;
+      typedef typename types::node_type node_type;
 
-  private:
-    table table_;
+    private:
+      table table_;
 
-  public:
-    // constructors
+    public:
+      // constructors
 
-    unordered_multiset();
+      unordered_multiset();
 
-    explicit unordered_multiset(size_type, const hasher& = hasher(),
+      explicit unordered_multiset(size_type, const hasher& = hasher(),
         const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    template <class InputIt>
-    unordered_multiset(InputIt, InputIt,
+      template <class InputIt>
+      unordered_multiset(InputIt, InputIt,
         size_type = boost::unordered::detail::default_bucket_count,
         const hasher& = hasher(), const key_equal& = key_equal(),
         const allocator_type& = allocator_type());
 
-    unordered_multiset(unordered_multiset const&);
+      unordered_multiset(unordered_multiset const&);
 
 #if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
+  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
         BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
-        : table_(other.table_, boost::unordered::detail::move_tag())
-    {
+          : table_(other.table_, boost::unordered::detail::move_tag())
+      {
         // The move is done in table_
-    }
+      }
 #endif
 
-    explicit unordered_multiset(allocator_type const&);
+      explicit unordered_multiset(allocator_type const&);
 
-    unordered_multiset(unordered_multiset const&, allocator_type const&);
+      unordered_multiset(unordered_multiset const&, allocator_type const&);
 
-    unordered_multiset(BOOST_RV_REF(unordered_multiset), allocator_type const&);
+      unordered_multiset(
+        BOOST_RV_REF(unordered_multiset), allocator_type const&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_multiset(std::initializer_list<value_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());
 #endif
 
-    explicit unordered_multiset(size_type, const allocator_type&);
+      explicit unordered_multiset(size_type, const allocator_type&);
 
-    explicit unordered_multiset(
+      explicit unordered_multiset(
         size_type, const hasher&, const allocator_type&);
 
-    template <class InputIt>
-    unordered_multiset(InputIt, InputIt, size_type, const allocator_type&);
+      template <class InputIt>
+      unordered_multiset(InputIt, InputIt, size_type, const allocator_type&);
 
-    template <class InputIt>
-    unordered_multiset(
+      template <class InputIt>
+      unordered_multiset(
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    unordered_multiset(
+      unordered_multiset(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
-    unordered_multiset(std::initializer_list<value_type>, size_type,
+      unordered_multiset(std::initializer_list<value_type>, size_type,
         const hasher&, const allocator_type&);
 #endif
 
-    // Destructor
+      // Destructor
 
-    ~unordered_multiset() BOOST_NOEXCEPT;
+      ~unordered_multiset() BOOST_NOEXCEPT;
 
 // Assign
 
 #if defined(BOOST_UNORDERED_USE_MOVE)
-    unordered_multiset& operator=(BOOST_COPY_ASSIGN_REF(unordered_multiset) x)
-    {
+      unordered_multiset& operator=(BOOST_COPY_ASSIGN_REF(unordered_multiset) x)
+      {
         table_.assign(x.table_, boost::unordered::detail::false_type());
         return *this;
-    }
+      }
 
-    unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::false_type());
         return *this;
-    }
+      }
 #else
-    unordered_multiset& operator=(unordered_multiset const& x)
-    {
+      unordered_multiset& operator=(unordered_multiset const& x)
+      {
         table_.assign(x.table_, boost::unordered::detail::false_type());
         return *this;
-    }
+      }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    unordered_multiset& operator=(unordered_multiset&& x)
-    // C++17 support: BOOST_NOEXCEPT_IF(
-    //    value_allocator_traits::is_always_equal::value &&
-    //    is_nothrow_move_assignable_v<H> &&
-    //    is_nothrow_move_assignable_v<P>)
-    {
+      unordered_multiset& operator=(unordered_multiset&& x)
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      {
         table_.move_assign(x.table_, boost::unordered::detail::false_type());
         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
-    {
+      allocator_type get_allocator() const BOOST_NOEXCEPT
+      {
         return table_.node_alloc();
-    }
+      }
 
-    // iterators
+      // iterators
 
-    iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
+      iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
 
-    const_iterator begin() const BOOST_NOEXCEPT
-    {
+      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
-    {
+      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(); }
 
-    // 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;
 
 // emplace
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
+      {
         return iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(), boost::forward<Args>(args)...)));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(), boost::forward<Args>(args)...)));
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    // 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 =
+      iterator emplace(boost::unordered::detail::empty_emplace =
                          boost::unordered::detail::empty_emplace(),
         value_type v = value_type())
-    {
+      {
         return this->emplace(boost::move(v));
-    }
+      }
 
 #endif
 
-    template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
+      {
         return iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0)))));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(), 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)
-    {
+      template <typename A0, typename A1>
+      iterator emplace(BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+      {
         return iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0), boost::forward<A1>(a1)))));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(),
+            boost::unordered::detail::create_emplace_args(
+              boost::forward<A0>(a0), boost::forward<A1>(a1)))));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator emplace(
+      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 iterator(table_.emplace_equiv(
-            boost::unordered::detail::func::construct_node_from_args(
-                table_.node_alloc(),
-                boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0), boost::forward<A1>(a1),
-                    boost::forward<A2>(a2)))));
-    }
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(),
+            boost::unordered::detail::create_emplace_args(
+              boost::forward<A0>(a0), boost::forward<A1>(a1),
+              boost::forward<A2>(a2)))));
+      }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-    template <class... Args>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+      {
         return iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(), boost::forward<Args>(args)...)));
-    }
+          hint, boost::unordered::detail::func::construct_node_from_args(
+                  table_.node_alloc(), boost::forward<Args>(args)...)));
+      }
 
 #else
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
 
-    iterator emplace_hint(const_iterator hint,
+      iterator emplace_hint(const_iterator hint,
         boost::unordered::detail::empty_emplace =
-            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_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-    {
+      template <typename A0>
+      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+      {
         return iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(),
-                      boost::unordered::detail::create_emplace_args(
-                          boost::forward<A0>(a0)))));
-    }
+          hint,
+          boost::unordered::detail::func::construct_node_from_args(
+            table_.node_alloc(), boost::unordered::detail::create_emplace_args(
+                                   boost::forward<A0>(a0)))));
+      }
 
-    template <typename A0, typename A1>
-    iterator emplace_hint(
+      template <typename A0, typename A1>
+      iterator emplace_hint(
         const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-    {
+      {
         return iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(),
-                      boost::unordered::detail::create_emplace_args(
-                          boost::forward<A0>(a0), boost::forward<A1>(a1)))));
-    }
+          hint, boost::unordered::detail::func::construct_node_from_args(
+                  table_.node_alloc(),
+                  boost::unordered::detail::create_emplace_args(
+                    boost::forward<A0>(a0), boost::forward<A1>(a1)))));
+      }
 
-    template <typename A0, typename A1, typename A2>
-    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
+      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 iterator(table_.emplace_hint_equiv(
-            hint, boost::unordered::detail::func::construct_node_from_args(
-                      table_.node_alloc(),
-                      boost::unordered::detail::create_emplace_args(
-                          boost::forward<A0>(a0), boost::forward<A1>(a1),
-                          boost::forward<A2>(a2)))));
-    }
+          hint, boost::unordered::detail::func::construct_node_from_args(
+                  table_.node_alloc(),
+                  boost::unordered::detail::create_emplace_args(
+                    boost::forward<A0>(a0), boost::forward<A1>(a1),
+                    boost::forward<A2>(a2)))));
+      }
 
 #endif
 
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 #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 iterator(table_.emplace_equiv(                                  \
-            boost::unordered::detail::func::construct_node_from_args(          \
-                table_.node_alloc(),                                           \
-                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(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))         \
+  {                                                                            \
+    return iterator(table_.emplace_equiv(                                      \
+      boost::unordered::detail::func::construct_node_from_args(                \
+        table_.node_alloc(),                                                   \
+        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 iterator(table_.emplace_hint_equiv(                             \
-            hint,                                                              \
-            boost::unordered::detail::func::construct_node_from_args(          \
-                table_.node_alloc(),                                           \
-                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 iterator(table_.emplace_hint_equiv(                                 \
+      hint, boost::unordered::detail::func::construct_node_from_args(          \
+              table_.node_alloc(),                                             \
+              boost::unordered::detail::create_emplace_args(                   \
+                BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)))));     \
+  }
 
-    BOOST_UNORDERED_EMPLACE(1, 4, _)
-    BOOST_UNORDERED_EMPLACE(1, 5, _)
-    BOOST_UNORDERED_EMPLACE(1, 6, _)
-    BOOST_UNORDERED_EMPLACE(1, 7, _)
-    BOOST_UNORDERED_EMPLACE(1, 8, _)
-    BOOST_UNORDERED_EMPLACE(1, 9, _)
-    BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
+      BOOST_UNORDERED_EMPLACE(1, 4, _)
+      BOOST_UNORDERED_EMPLACE(1, 5, _)
+      BOOST_UNORDERED_EMPLACE(1, 6, _)
+      BOOST_UNORDERED_EMPLACE(1, 7, _)
+      BOOST_UNORDERED_EMPLACE(1, 8, _)
+      BOOST_UNORDERED_EMPLACE(1, 9, _)
+      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(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)
-    {
+      iterator insert(BOOST_UNORDERED_RV_REF(value_type) x)
+      {
         return this->emplace(boost::move(x));
-    }
+      }
 
-    iterator insert(const_iterator hint, value_type const& 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)
-    {
+      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
 
-    // extract
+      // extract
 
-    node_type extract(const_iterator position)
-    {
+      node_type extract(const_iterator position)
+      {
         return node_type(
-            table_.extract_by_iterator_equiv(position), table_.node_alloc());
-    }
+          table_.extract_by_iterator_equiv(position), table_.node_alloc());
+      }
 
-    node_type extract(const key_type& k)
-    {
+      node_type extract(const key_type& k)
+      {
         return node_type(table_.extract_by_key(k), table_.node_alloc());
-    }
+      }
 
-    iterator insert(BOOST_RV_REF(node_type) np)
-    {
+      iterator insert(BOOST_RV_REF(node_type) np)
+      {
         return table_.move_insert_node_type_equiv(np);
-    }
+      }
 
-    iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
-    {
+      iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
+      {
         return table_.move_insert_node_type_with_hint_equiv(hint, np);
-    }
+      }
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ||                               \
-    (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
-  private:
-    // Note: Use r-value node_type to insert.
-    iterator insert(node_type&);
-    iterator insert(const_iterator, node_type& np);
+  (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
+    private:
+      // Note: Use r-value node_type to insert.
+      iterator insert(node_type&);
+      iterator insert(const_iterator, node_type& np);
 
-  public:
+    public:
 #endif
 
-    iterator erase(const_iterator);
-    size_type erase(const key_type&);
-    iterator erase(const_iterator, const_iterator);
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    void quick_erase(const_iterator it) { erase(it); }
-    BOOST_UNORDERED_DEPRECATED("Use erase instead")
-    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);
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void quick_erase(const_iterator it) { erase(it); }
+      BOOST_UNORDERED_DEPRECATED("Use erase instead")
+      void erase_return_void(const_iterator it) { erase(it); }
 
-    void swap(unordered_multiset&);
+      void swap(unordered_multiset&);
+      // C++17 support: BOOST_NOEXCEPT_IF(
+      //    value_allocator_traits::is_always_equal::value &&
+      //    is_nothrow_move_assignable_v<H> &&
+      //    is_nothrow_move_assignable_v<P>)
+      void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multiset<T, H2, P2, A>& source);
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename H2, typename P2>
+      void merge(boost::unordered_multiset<T, H2, P2, A>&& source);
+#endif
+
+      template <typename H2, typename P2>
+      void merge(boost::unordered_set<T, H2, P2, A>& source);
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      template <typename H2, typename P2>
+      void merge(boost::unordered_set<T, H2, P2, A>&& source);
+#endif
+
+      // observers
+
+      hasher hash_function() const;
+      key_equal key_eq() const;
+
+      // lookup
+
+      const_iterator find(const key_type&) 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;
+
+      std::pair<const_iterator, const_iterator> equal_range(
+        const key_type&) const;
+
+      // bucket interface
+
+      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 bucket_size(size_type) const;
+
+      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_);
+      }
+
+      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(); }
+
+      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 cend(size_type) const
+      {
+        return const_local_iterator();
+      }
+
+      // hash policy
+
+      float load_factor() const BOOST_NOEXCEPT;
+      float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
+      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&);
+#endif
+    }; // 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(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>
+    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)
+    {
+      this->insert(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_,
+            unordered_set::value_allocator_traits::
+              select_on_container_copy_construction(other.get_allocator()))
+    {
+      if (other.table_.size_) {
+        table_.copy_buckets(
+          other.table_, boost::unordered::detail::true_type());
+      }
+    }
+
+    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)
+    {
+      if (other.table_.size_) {
+        table_.copy_buckets(
+          other.table_, boost::unordered::detail::true_type());
+      }
+    }
+
+    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 (table_.node_alloc() == other.table_.node_alloc()) {
+        table_.move_buckets_from(other.table_);
+      } else if (other.table_.size_) {
+        // TODO: Could pick new bucket size?
+        table_.move_buckets(other.table_);
+      }
+    }
+
+#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)
+    {
+      this->insert(list.begin(), list.end());
+    }
+
+#endif
+
+    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>
+    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)
+    {
+      this->insert(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)
+    {
+      this->insert(f, l);
+    }
+
+#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 allocator_type& a)
+        : table_(
+            boost::unordered::detail::initial_size(list.begin(), list.end(), n),
+            hasher(), key_equal(), a)
+    {
+      this->insert(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)
+    {
+      this->insert(list.begin(), list.end());
+    }
+
+#endif
+
+    template <class T, class H, class P, class A>
+    unordered_set<T, H, P, A>::~unordered_set() BOOST_NOEXCEPT
+    {
+    }
+
+#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<T, H, P, A>::operator=(
+      std::initializer_list<value_type> list)
+    {
+      this->clear();
+      this->insert(list.begin(), list.end());
+      return *this;
+    }
+
+#endif
+
+    // 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
+    {
+      using namespace std;
+
+      // size < mlf_ * count
+      return boost::unordered::detail::double_to_size(
+               ceil(static_cast<double>(table_.mlf_) *
+                    static_cast<double>(table_.max_bucket_count()))) -
+             1;
+    }
+
+    // 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)
+    {
+      if (first != last) {
+        table_.insert_range_unique(
+          table::extractor::extract(*first), 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)
+    {
+      this->insert(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)
+    {
+      node_pointer node = table::get_node(position);
+      BOOST_ASSERT(node);
+      node_pointer next = table::next_node(node);
+      table_.erase_nodes_unique(node, next);
+      return iterator(next);
+    }
+
+    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_unique(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)
+    {
+      node_pointer last_node = table::get_node(last);
+      if (first == last)
+        return iterator(last_node);
+      table_.erase_nodes_unique(table::get_node(first), last_node);
+      return iterator(last_node);
+    }
+
+    template <class T, class H, class P, class A>
+    void unordered_set<T, H, P, A>::swap(unordered_set& other)
     // C++17 support: BOOST_NOEXCEPT_IF(
     //    value_allocator_traits::is_always_equal::value &&
     //    is_nothrow_move_assignable_v<H> &&
     //    is_nothrow_move_assignable_v<P>)
-    void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
-
-    template <typename H2, typename P2>
-    void merge(boost::unordered_multiset<T, H2, P2, A>& source);
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename H2, typename P2>
-    void merge(boost::unordered_multiset<T, H2, P2, A>&& source);
-#endif
-
-    template <typename H2, typename P2>
-    void merge(boost::unordered_set<T, H2, P2, A>& source);
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template <typename H2, typename P2>
-    void merge(boost::unordered_set<T, H2, P2, A>&& source);
-#endif
+    {
+      table_.swap(other.table_);
+    }
 
     // observers
 
-    hasher hash_function() const;
-    key_equal key_eq() const;
+    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>
+    template <typename H2, typename P2>
+    void unordered_set<T, H, P, A>::merge(
+      boost::unordered_set<T, H2, P2, A>& source)
+    {
+      table_.merge_unique(source.table_);
+    }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_set<T, H, P, A>::merge(
+      boost::unordered_set<T, H2, P2, A>&& source)
+    {
+      table_.merge_unique(source.table_);
+    }
+#endif
+
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_set<T, H, P, A>::merge(
+      boost::unordered_multiset<T, H2, P2, A>& source)
+    {
+      table_.merge_unique(source.table_);
+    }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_set<T, H, P, A>::merge(
+      boost::unordered_multiset<T, H2, P2, A>&& source)
+    {
+      table_.merge_unique(source.table_);
+    }
+#endif
 
     // lookup
 
-    const_iterator find(const key_type&) const;
+    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>
-    const_iterator find(CompatibleKey const&, CompatibleHash const&,
-        CompatiblePredicate const&) const;
-
-    size_type count(const key_type&) const;
-
-    std::pair<const_iterator, const_iterator> equal_range(
-        const key_type&) const;
-
-    // bucket interface
-
-    size_type bucket_count() const BOOST_NOEXCEPT
+      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 table_.bucket_count_;
+      return const_iterator(
+        table_.find_node_impl(table::policy::apply_hash(hash, k), k, eq));
     }
 
-    size_type max_bucket_count() const BOOST_NOEXCEPT
+    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_.max_bucket_count();
+      return table_.find_node(k) ? 1 : 0;
     }
 
-    size_type bucket_size(size_type) const;
-
-    size_type bucket(const key_type& k) const
+    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_.hash_to_bucket(table_.hash(k));
+      node_pointer n = table_.find_node(k);
+      return std::make_pair(
+        const_iterator(n), const_iterator(n ? table::next_node(n) : n));
     }
 
-    local_iterator begin(size_type 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 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(); }
-
-    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 cend(size_type) const
-    {
-        return const_local_iterator();
+      return table_.bucket_size(n);
     }
 
     // hash policy
 
-    float load_factor() const BOOST_NOEXCEPT;
-    float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
-    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&);
-#endif
-}; // 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(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>
-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)
-{
-    this->insert(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_,
-          unordered_set::value_allocator_traits::
-              select_on_container_copy_construction(other.get_allocator()))
-{
-    if (other.table_.size_) {
-        table_.copy_buckets(
-            other.table_, boost::unordered::detail::true_type());
+    template <class T, class H, class P, class A>
+    float unordered_set<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+    {
+      BOOST_ASSERT(table_.bucket_count_ != 0);
+      return static_cast<float>(table_.size_) /
+             static_cast<float>(table_.bucket_count_);
     }
-}
 
-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)
-{
-    if (other.table_.size_) {
-        table_.copy_buckets(
-            other.table_, boost::unordered::detail::true_type());
+    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>
-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 (table_.node_alloc() == other.table_.node_alloc()) {
-        table_.move_buckets_from(other.table_);
-    } else if (other.table_.size_) {
-        // TODO: Could pick new bucket size?
-        table_.move_buckets(other.table_);
+    template <class T, class H, class P, class A>
+    void unordered_set<T, H, P, A>::rehash(size_type n)
+    {
+      table_.rehash(n);
     }
-}
 
-#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)
-{
-    this->insert(list.begin(), list.end());
-}
-
-#endif
-
-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>
-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)
-{
-    this->insert(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)
-{
-    this->insert(f, l);
-}
-
-#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 allocator_type& a)
-    : table_(
-          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
-          hasher(), key_equal(), a)
-{
-    this->insert(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)
-{
-    this->insert(list.begin(), list.end());
-}
-
-#endif
-
-template <class T, class H, class P, class A>
-unordered_set<T, H, P, A>::~unordered_set() BOOST_NOEXCEPT
-{
-}
-
-#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<T, H, P, A>::operator=(
-    std::initializer_list<value_type> list)
-{
-    this->clear();
-    this->insert(list.begin(), list.end());
-    return *this;
-}
-
-#endif
-
-// 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
-{
-    using namespace std;
-
-    // size < mlf_ * count
-    return boost::unordered::detail::double_to_size(
-               ceil(static_cast<double>(table_.mlf_) *
-                    static_cast<double>(table_.max_bucket_count()))) -
-           1;
-}
-
-// 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)
-{
-    if (first != last) {
-        table_.insert_range_unique(
-            table::extractor::extract(*first), 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)
-{
-    this->insert(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)
-{
-    node_pointer node = table::get_node(position);
-    BOOST_ASSERT(node);
-    node_pointer next = table::next_node(node);
-    table_.erase_nodes_unique(node, next);
-    return iterator(next);
-}
-
-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_unique(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)
-{
-    node_pointer last_node = table::get_node(last);
-    if (first == last)
-        return iterator(last_node);
-    table_.erase_nodes_unique(table::get_node(first), last_node);
-    return iterator(last_node);
-}
-
-template <class T, class H, class P, class A>
-void unordered_set<T, H, P, A>::swap(unordered_set& other)
-// C++17 support: BOOST_NOEXCEPT_IF(
-//    value_allocator_traits::is_always_equal::value &&
-//    is_nothrow_move_assignable_v<H> &&
-//    is_nothrow_move_assignable_v<P>)
-{
-    table_.swap(other.table_);
-}
-
-// 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>::key_equal
-unordered_set<T, H, P, A>::key_eq() const
-{
-    return table_.key_eq();
-}
-
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_set<T, H, P, A>::merge(
-    boost::unordered_set<T, H2, P2, A>& source)
-{
-    table_.merge_unique(source.table_);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_set<T, H, P, A>::merge(
-    boost::unordered_set<T, H2, P2, A>&& source)
-{
-    table_.merge_unique(source.table_);
-}
-#endif
-
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_set<T, H, P, A>::merge(
-    boost::unordered_multiset<T, H2, P2, A>& source)
-{
-    table_.merge_unique(source.table_);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_set<T, H, P, A>::merge(
-    boost::unordered_multiset<T, H2, P2, A>&& source)
-{
-    table_.merge_unique(source.table_);
-}
-#endif
-
-// 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>
-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_.find_node_impl(table::policy::apply_hash(hash, k), k, 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_.find_node(k) ? 1 : 0;
-}
-
-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
-{
-    node_pointer n = table_.find_node(k);
-    return std::make_pair(
-        const_iterator(n), const_iterator(n ? table::next_node(n) : 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
-
-template <class T, class H, class P, class A>
-float unordered_set<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
-{
-    BOOST_ASSERT(table_.bucket_count_ != 0);
-    return static_cast<float>(table_.size_) /
-           static_cast<float>(table_.bucket_count_);
-}
-
-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>::reserve(size_type n)
-{
-    table_.rehash(static_cast<std::size_t>(
+    template <class T, class H, class P, class A>
+    void unordered_set<T, H, P, A>::reserve(size_type n)
+    {
+      table_.rehash(static_cast<std::size_t>(
         std::ceil(static_cast<double>(n) / table_.mlf_)));
-}
+    }
 
-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
+    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)
     {
-        unordered_set<T, H, P, A> x;
-    };
-#endif
-    return m1.table_.equals_unique(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)
-{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-    struct dummy
-    {
+      struct dummy
+      {
         unordered_set<T, H, P, A> x;
-    };
+      };
 #endif
-    return !m1.table_.equals_unique(m2.table_);
-}
+      return m1.table_.equals_unique(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)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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
-    {
+      struct dummy
+      {
         unordered_set<T, H, P, A> x;
-    };
+      };
 #endif
-    m1.swap(m2);
-}
+      return !m1.table_.equals_unique(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)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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(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()
+        : table_(boost::unordered::detail::default_bucket_count, hasher(),
+            key_equal(), allocator_type())
+    {
+    }
 
-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)
-{
-    this->insert(f, l);
-}
+    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(
-    unordered_multiset const& other)
-    : table_(other.table_,
-          unordered_multiset::value_allocator_traits::
+    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)
+    {
+      this->insert(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_,
+            unordered_multiset::value_allocator_traits::
               select_on_container_copy_construction(other.get_allocator()))
-{
-    if (other.table_.size_) {
+    {
+      if (other.table_.size_) {
         table_.copy_buckets(
-            other.table_, boost::unordered::detail::false_type());
+          other.table_, boost::unordered::detail::false_type());
+      }
     }
-}
 
-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)
-{
-    if (other.table_.size_) {
+    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)
+    {
+      if (other.table_.size_) {
         table_.copy_buckets(
-            other.table_, boost::unordered::detail::false_type());
+          other.table_, boost::unordered::detail::false_type());
+      }
     }
-}
 
-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 (table_.node_alloc() == other.table_.node_alloc()) {
+    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 (table_.node_alloc() == other.table_.node_alloc()) {
         table_.move_buckets_from(other.table_);
-    } else if (other.table_.size_) {
+      } else if (other.table_.size_) {
         // TODO: Could pick new bucket size?
         table_.move_buckets_equiv(other.table_);
+      }
     }
-}
 
 #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)
-{
-    this->insert(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)
+    {
+      this->insert(list.begin(), list.end());
+    }
 
 #endif
 
-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>
-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)
-{
-    this->insert(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)
+    {
+      this->insert(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)
-{
-    this->insert(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)
+    {
+      this->insert(f, l);
+    }
 
 #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 allocator_type& a)
-    : table_(
-          boost::unordered::detail::initial_size(list.begin(), list.end(), n),
-          hasher(), key_equal(), a)
-{
-    this->insert(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)
+    {
+      this->insert(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)
-{
-    this->insert(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)
+    {
+      this->insert(list.begin(), list.end());
+    }
 
 #endif
 
-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() BOOST_NOEXCEPT
+    {
+    }
 
 #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<T, H, P, A>::operator=(
-    std::initializer_list<value_type> list)
-{
-    this->clear();
-    this->insert(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)
+    {
+      this->clear();
+      this->insert(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
-{
-    using namespace std;
+    template <class T, class H, class P, class A>
+    std::size_t unordered_multiset<T, H, P, A>::max_size() const BOOST_NOEXCEPT
+    {
+      using namespace std;
 
-    // size < mlf_ * count
-    return boost::unordered::detail::double_to_size(
+      // size < mlf_ * count
+      return boost::unordered::detail::double_to_size(
                ceil(static_cast<double>(table_.mlf_) *
                     static_cast<double>(table_.max_bucket_count()))) -
-           1;
-}
+             1;
+    }
 
-// 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_equiv(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_equiv(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)
-{
-    this->insert(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)
+    {
+      this->insert(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)
-{
-    node_pointer node = table::get_node(position);
-    BOOST_ASSERT(node);
-    node_pointer next = table::next_node(node);
-    table_.erase_nodes_equiv(node, next);
-    return iterator(next);
-}
+    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)
+    {
+      node_pointer node = table::get_node(position);
+      BOOST_ASSERT(node);
+      node_pointer next = table::next_node(node);
+      table_.erase_nodes_equiv(node, next);
+      return iterator(next);
+    }
 
-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_equiv(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_equiv(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)
-{
-    node_pointer last_node = table::get_node(last);
-    if (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)
+    {
+      node_pointer last_node = table::get_node(last);
+      if (first == last)
         return iterator(last_node);
-    table_.erase_nodes_equiv(table::get_node(first), last_node);
-    return iterator(last_node);
-}
-
-template <class T, class H, class P, class A>
-void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other)
-// C++17 support: BOOST_NOEXCEPT_IF(
-//    value_allocator_traits::is_always_equal::value &&
-//    is_nothrow_move_assignable_v<H> &&
-//    is_nothrow_move_assignable_v<P>)
-{
-    table_.swap(other.table_);
-}
-
-// 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>::key_equal
-unordered_multiset<T, H, P, A>::key_eq() const
-{
-    return table_.key_eq();
-}
-
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multiset<T, H, P, A>::merge(
-    boost::unordered_multiset<T, H2, P2, A>& source)
-{
-    while (!source.empty()) {
-        insert(source.extract(source.begin()));
+      table_.erase_nodes_equiv(table::get_node(first), last_node);
+      return iterator(last_node);
+    }
+
+    template <class T, class H, class P, class A>
+    void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other)
+    // C++17 support: BOOST_NOEXCEPT_IF(
+    //    value_allocator_traits::is_always_equal::value &&
+    //    is_nothrow_move_assignable_v<H> &&
+    //    is_nothrow_move_assignable_v<P>)
+    {
+      table_.swap(other.table_);
+    }
+
+    // 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>::key_equal
+    unordered_multiset<T, H, P, A>::key_eq() const
+    {
+      return table_.key_eq();
+    }
+
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multiset<T, H, P, A>::merge(
+      boost::unordered_multiset<T, H2, P2, A>& source)
+    {
+      while (!source.empty()) {
+        insert(source.extract(source.begin()));
+      }
     }
-}
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multiset<T, H, P, A>::merge(
-    boost::unordered_multiset<T, H2, P2, A>&& source)
-{
-    while (!source.empty()) {
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multiset<T, H, P, A>::merge(
+      boost::unordered_multiset<T, H2, P2, A>&& source)
+    {
+      while (!source.empty()) {
         insert(source.extract(source.begin()));
+      }
     }
-}
 #endif
 
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multiset<T, H, P, A>::merge(
-    boost::unordered_set<T, H2, P2, A>& source)
-{
-    while (!source.empty()) {
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multiset<T, H, P, A>::merge(
+      boost::unordered_set<T, H2, P2, A>& source)
+    {
+      while (!source.empty()) {
         insert(source.extract(source.begin()));
+      }
     }
-}
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T, class H, class P, class A>
-template <typename H2, typename P2>
-void unordered_multiset<T, H, P, A>::merge(
-    boost::unordered_set<T, H2, P2, A>&& source)
-{
-    while (!source.empty()) {
+    template <class T, class H, class P, class A>
+    template <typename H2, typename P2>
+    void unordered_multiset<T, H, P, A>::merge(
+      boost::unordered_set<T, H2, P2, A>&& source)
+    {
+      while (!source.empty()) {
         insert(source.extract(source.begin()));
+      }
     }
-}
 #endif
 
-// 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(
+    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_.find_node_impl(table::policy::apply_hash(hash, k), k, 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
-{
-    node_pointer n = table_.find_node(k);
-    return n ? table_.group_count(n) : 0;
-}
+    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
+    {
+      node_pointer n = table_.find_node(k);
+      return n ? table_.group_count(n) : 0;
+    }
 
-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
-{
-    node_pointer n = table_.find_node(k);
-    return std::make_pair(
+    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
+    {
+      node_pointer n = table_.find_node(k);
+      return std::make_pair(
         const_iterator(n), const_iterator(n ? table_.next_group(n) : 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);
-}
+    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
-{
-    BOOST_ASSERT(table_.bucket_count_ != 0);
-    return static_cast<float>(table_.size_) /
-           static_cast<float>(table_.bucket_count_);
-}
+    template <class T, class H, class P, class A>
+    float unordered_multiset<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+    {
+      BOOST_ASSERT(table_.bucket_count_ != 0);
+      return static_cast<float>(table_.size_) /
+             static_cast<float>(table_.bucket_count_);
+    }
 
-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_.rehash(static_cast<std::size_t>(
+    template <class T, class H, class P, class A>
+    void unordered_multiset<T, H, P, A>::reserve(size_type n)
+    {
+      table_.rehash(static_cast<std::size_t>(
         std::ceil(static_cast<double>(n) / table_.mlf_)));
-}
+    }
 
-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
+    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)
     {
-        unordered_multiset<T, H, P, A> x;
-    };
-#endif
-    return m1.table_.equals_equiv(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)
-{
 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
-    struct dummy
-    {
+      struct dummy
+      {
         unordered_multiset<T, H, P, A> x;
-    };
+      };
 #endif
-    return !m1.table_.equals_equiv(m2.table_);
-}
+      return m1.table_.equals_equiv(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)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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
-    {
+      struct dummy
+      {
         unordered_multiset<T, H, P, A> x;
-    };
+      };
 #endif
-    m1.swap(m2);
-}
+      return !m1.table_.equals_equiv(m2.table_);
+    }
 
-template <typename N, typename T, typename A> class node_handle_set
-{
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_set)
+    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)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
+    {
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+      struct dummy
+      {
+        unordered_multiset<T, H, P, A> x;
+      };
+#endif
+      m1.swap(m2);
+    }
 
-    template <typename Types> friend struct ::boost::unordered::detail::table;
-    template <class T2, class H2, class P2, class A2>
-    friend class unordered_set;
-    template <class T2, class H2, class P2, class A2>
-    friend class unordered_multiset;
+    template <typename N, typename T, typename A> class node_handle_set
+    {
+      BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_set)
 
-    typedef typename boost::unordered::detail::rebind_wrap<A, T>::type
+      template <typename Types> friend struct ::boost::unordered::detail::table;
+      template <class T2, class H2, class P2, class A2>
+      friend class unordered_set;
+      template <class T2, class H2, class P2, class A2>
+      friend class unordered_multiset;
+
+      typedef typename boost::unordered::detail::rebind_wrap<A, T>::type
         value_allocator;
-    typedef boost::unordered::detail::allocator_traits<value_allocator>
+      typedef boost::unordered::detail::allocator_traits<value_allocator>
         value_allocator_traits;
-    typedef N node;
-    typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
+      typedef N node;
+      typedef typename boost::unordered::detail::rebind_wrap<A, node>::type
         node_allocator;
-    typedef boost::unordered::detail::allocator_traits<node_allocator>
+      typedef boost::unordered::detail::allocator_traits<node_allocator>
         node_allocator_traits;
-    typedef typename node_allocator_traits::pointer node_pointer;
+      typedef typename node_allocator_traits::pointer node_pointer;
 
-  public:
-    typedef T value_type;
-    typedef A allocator_type;
+    public:
+      typedef T value_type;
+      typedef A allocator_type;
 
-  private:
-    node_pointer ptr_;
-    bool has_alloc_;
-    boost::unordered::detail::value_base<value_allocator> alloc_;
+    private:
+      node_pointer ptr_;
+      bool has_alloc_;
+      boost::unordered::detail::value_base<value_allocator> alloc_;
 
-    node_handle_set(node_pointer ptr, allocator_type const& a)
-        : ptr_(ptr), has_alloc_(false)
-    {
+      node_handle_set(node_pointer ptr, allocator_type const& a)
+          : ptr_(ptr), has_alloc_(false)
+      {
         if (ptr_) {
-            new ((void*)&alloc_) value_allocator(a);
-            has_alloc_ = true;
+          new ((void*)&alloc_) value_allocator(a);
+          has_alloc_ = true;
         }
-    }
+      }
 
-  public:
-    BOOST_CONSTEXPR node_handle_set() BOOST_NOEXCEPT : ptr_(), has_alloc_(false)
-    {
-    }
+    public:
+      BOOST_CONSTEXPR node_handle_set() BOOST_NOEXCEPT : ptr_(),
+                                                         has_alloc_(false)
+      {
+      }
 
-    ~node_handle_set()
-    {
+      ~node_handle_set()
+      {
         if (has_alloc_ && ptr_) {
-            node_allocator node_alloc(alloc_.value());
-            boost::unordered::detail::node_tmp<node_allocator> tmp(
-                ptr_, node_alloc);
+          node_allocator node_alloc(alloc_.value());
+          boost::unordered::detail::node_tmp<node_allocator> tmp(
+            ptr_, node_alloc);
         }
         if (has_alloc_) {
-            alloc_.value_ptr()->~value_allocator();
+          alloc_.value_ptr()->~value_allocator();
         }
-    }
+      }
 
-    node_handle_set(BOOST_RV_REF(node_handle_set) n) BOOST_NOEXCEPT
+      node_handle_set(BOOST_RV_REF(node_handle_set) n) BOOST_NOEXCEPT
         : ptr_(n.ptr_),
           has_alloc_(false)
-    {
+      {
         if (n.has_alloc_) {
-            new ((void*)&alloc_) value_allocator(boost::move(n.alloc_.value()));
-            has_alloc_ = true;
-            n.ptr_ = node_pointer();
-            n.alloc_.value_ptr()->~value_allocator();
-            n.has_alloc_ = false;
+          new ((void*)&alloc_) value_allocator(boost::move(n.alloc_.value()));
+          has_alloc_ = true;
+          n.ptr_ = node_pointer();
+          n.alloc_.value_ptr()->~value_allocator();
+          n.has_alloc_ = false;
         }
-    }
+      }
 
-    node_handle_set& operator=(BOOST_RV_REF(node_handle_set) n)
-    {
+      node_handle_set& operator=(BOOST_RV_REF(node_handle_set) n)
+      {
         BOOST_ASSERT(!has_alloc_ ||
                      value_allocator_traits::
-                         propagate_on_container_move_assignment::value ||
+                       propagate_on_container_move_assignment::value ||
                      (n.has_alloc_ && alloc_.value() == n.alloc_.value()));
 
         if (ptr_) {
-            node_allocator node_alloc(alloc_.value());
-            boost::unordered::detail::node_tmp<node_allocator> tmp(
-                ptr_, node_alloc);
-            ptr_ = node_pointer();
+          node_allocator node_alloc(alloc_.value());
+          boost::unordered::detail::node_tmp<node_allocator> tmp(
+            ptr_, node_alloc);
+          ptr_ = node_pointer();
         }
 
         if (has_alloc_) {
-            alloc_.value_ptr()->~value_allocator();
-            has_alloc_ = false;
+          alloc_.value_ptr()->~value_allocator();
+          has_alloc_ = false;
         }
 
         if (!has_alloc_ && n.has_alloc_) {
-            move_allocator(n);
+          move_allocator(n);
         }
 
         ptr_ = n.ptr_;
         n.ptr_ = node_pointer();
 
         return *this;
-    }
+      }
 
-    value_type& value() const { return ptr_->value(); }
+      value_type& value() const { return ptr_->value(); }
 
-    allocator_type get_allocator() const { return alloc_.value(); }
+      allocator_type get_allocator() const { return alloc_.value(); }
 
-    BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
+      BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
 
-    bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
+      bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
 
-    bool empty() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
+      bool empty() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
 
-    void swap(node_handle_set& n) BOOST_NOEXCEPT_IF(
+      void swap(node_handle_set& n) BOOST_NOEXCEPT_IF(
         value_allocator_traits::propagate_on_container_swap::value
         /* || value_allocator_traits::is_always_equal::value */)
-    {
+      {
         if (!has_alloc_) {
-            if (n.has_alloc_) {
-                move_allocator(n);
-            }
+          if (n.has_alloc_) {
+            move_allocator(n);
+          }
         } else if (!n.has_alloc_) {
-            n.move_allocator(*this);
+          n.move_allocator(*this);
         } else {
-            swap_impl(n, boost::unordered::detail::integral_constant<bool,
-                             value_allocator_traits::
-                                 propagate_on_container_swap::value>());
+          swap_impl(
+            n, boost::unordered::detail::integral_constant<bool,
+                 value_allocator_traits::propagate_on_container_swap::value>());
         }
         boost::swap(ptr_, n.ptr_);
-    }
+      }
 
-  private:
-    void move_allocator(node_handle_set& n)
-    {
+    private:
+      void move_allocator(node_handle_set& n)
+      {
         new ((void*)&alloc_) value_allocator(boost::move(n.alloc_.value()));
         n.alloc_.value_ptr()->~value_allocator();
         has_alloc_ = true;
         n.has_alloc_ = false;
-    }
+      }
 
-    void swap_impl(node_handle_set&, boost::unordered::detail::false_type) {}
+      void swap_impl(node_handle_set&, boost::unordered::detail::false_type) {}
 
-    void swap_impl(node_handle_set& n, boost::unordered::detail::true_type)
-    {
+      void swap_impl(node_handle_set& n, boost::unordered::detail::true_type)
+      {
         boost::swap(alloc_, n.alloc_);
+      }
+    };
+
+    template <typename N, typename T, typename A>
+    void swap(node_handle_set<N, T, A>& x, node_handle_set<N, T, A>& y)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
+    {
+      x.swap(y);
     }
-};
 
-template <typename N, typename T, typename A>
-void swap(node_handle_set<N, T, A>& x, node_handle_set<N, T, A>& y)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
-{
-    x.swap(y);
-}
+    template <typename N, typename T, typename A> struct insert_return_type_set
+    {
+    private:
+      BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_set)
 
-template <typename N, typename T, typename A> struct insert_return_type_set
-{
-  private:
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_set)
-
-    typedef typename boost::unordered::detail::rebind_wrap<A, T>::type
+      typedef typename boost::unordered::detail::rebind_wrap<A, T>::type
         value_allocator;
-    typedef N node_;
+      typedef N node_;
 
-  public:
-    bool inserted;
-    boost::unordered::iterator_detail::c_iterator<node_> position;
-    boost::unordered::node_handle_set<N, T, A> node;
+    public:
+      bool inserted;
+      boost::unordered::iterator_detail::c_iterator<node_> position;
+      boost::unordered::node_handle_set<N, T, A> node;
 
-    insert_return_type_set() : inserted(false), position(), node() {}
+      insert_return_type_set() : inserted(false), position(), node() {}
 
-    insert_return_type_set(BOOST_RV_REF(insert_return_type_set)
-            x) BOOST_NOEXCEPT : inserted(x.inserted),
-                                position(x.position),
-                                node(boost::move(x.node))
-    {
-    }
+      insert_return_type_set(BOOST_RV_REF(insert_return_type_set)
+          x) BOOST_NOEXCEPT : inserted(x.inserted),
+                              position(x.position),
+                              node(boost::move(x.node))
+      {
+      }
 
-    insert_return_type_set& operator=(BOOST_RV_REF(insert_return_type_set) x)
-    {
+      insert_return_type_set& operator=(BOOST_RV_REF(insert_return_type_set) x)
+      {
         inserted = x.inserted;
         position = x.position;
         node = boost::move(x.node);
         return *this;
-    }
-};
+      }
+    };
 
-template <typename N, typename T, typename A>
-void swap(
-    insert_return_type_set<N, T, A>& x, insert_return_type_set<N, T, A>& y)
-{
-    boost::swap(x.node, y.node);
-    boost::swap(x.inserted, y.inserted);
-    boost::swap(x.position, y.position);
-}
-} // namespace unordered
+    template <typename N, typename T, typename A>
+    void swap(
+      insert_return_type_set<N, T, A>& x, insert_return_type_set<N, T, A>& y)
+    {
+      boost::swap(x.node, y.node);
+      boost::swap(x.inserted, y.inserted);
+      boost::swap(x.position, y.position);
+    }
+  } // namespace unordered
 } // namespace boost
 
 #if defined(BOOST_MSVC)
diff --git a/include/boost/unordered/unordered_set_fwd.hpp b/include/boost/unordered/unordered_set_fwd.hpp
index 24842c80..35e2820f 100644
--- a/include/boost/unordered/unordered_set_fwd.hpp
+++ b/include/boost/unordered/unordered_set_fwd.hpp
@@ -17,45 +17,46 @@
 #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 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)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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)
-    BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(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)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-template <class N, class T, class A> class node_handle_set;
-template <class N, class T, class A> struct insert_return_type_set;
-}
+    template <class N, class T, class A> class node_handle_set;
+    template <class N, class T, class A> struct insert_return_type_set;
+  }
 
-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 cad7fb35..05f22fa7 100644
--- a/test/exception/assign_exception_tests.cpp
+++ b/test/exception/assign_exception_tests.cpp
@@ -17,27 +17,27 @@ test::seed_t initialize_seed(12847);
 
 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, test::limited_range)
-    {
-    }
+  test::random_values<T> values;
+  self_assign_base(std::size_t count = 0) : values(count, test::limited_range)
+  {
+  }
 
-    typedef T data_type;
-    T init() const { return T(values.begin(), values.end()); }
+  typedef T data_type;
+  T init() const { return T(values.begin(), values.end()); }
 
-    void run(T& x) const
-    {
-        x = x;
+  void run(T& x) const
+  {
+    x = x;
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, values);
+    test::check_equivalent_keys(x);
+  }
 
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
-    {
-        test::check_equivalent_keys(x);
-    }
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+  {
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct self_assign_test1 : self_assign_base<T>
@@ -46,129 +46,129 @@ template <class T> struct self_assign_test1 : self_assign_base<T>
 
 template <class T> struct self_assign_test2 : self_assign_base<T>
 {
-    self_assign_test2() : self_assign_base<T>(100) {}
+  self_assign_test2() : self_assign_base<T>(100) {}
 };
 
 template <class T> struct assign_base : public test::exception_base
 {
-    test::random_values<T> x_values, y_values;
-    T x, y;
+  test::random_values<T> x_values, y_values;
+  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;
+  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))
-    {
-        x.max_load_factor(mlf1);
-        y.max_load_factor(mlf2);
-    }
-
-    typedef T data_type;
-    T init() const { return T(x); }
-
-    void run(T& x1) const
-    {
-        x1 = y;
-
-        DISABLE_EXCEPTIONS;
-        test::check_container(x1, y_values);
-        test::check_equivalent_keys(x1);
-    }
-
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
-    {
-        test::check_equivalent_keys(x1);
-
-        // If the container is empty at the point of the exception, the
-        // internal structure is hidden, this exposes it, at the cost of
-        // messing up the data.
-        if (x_values.size()) {
-            T& x2 = const_cast<T&>(x1);
-            x2.emplace(*x_values.begin());
-            test::check_equivalent_keys(x2);
-        }
+  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);
+  }
+
+  typedef T data_type;
+  T init() const { return T(x); }
+
+  void run(T& x1) const
+  {
+    x1 = y;
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x1, y_values);
+    test::check_equivalent_keys(x1);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
+  {
+    test::check_equivalent_keys(x1);
+
+    // If the container is empty at the point of the exception, the
+    // internal structure is hidden, this exposes it, at the cost of
+    // messing up the data.
+    if (x_values.size()) {
+      T& x2 = const_cast<T&>(x1);
+      x2.emplace(*x_values.begin());
+      test::check_equivalent_keys(x2);
     }
+  }
 };
 
 template <class T> struct assign_values : assign_base<T>
 {
-    assign_values(unsigned int count1, unsigned int count2, int tag1, int tag2,
-        test::random_generator gen = test::default_generator, float mlf1 = 1.0,
-        float mlf2 = 1.0)
-        : assign_base<T>(tag1, tag2, mlf1, mlf2)
-    {
-        this->x_values.fill(count1, gen);
-        this->y_values.fill(count2, gen);
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
+  assign_values(unsigned int count1, unsigned int count2, int tag1, int tag2,
+    test::random_generator gen = test::default_generator, float mlf1 = 1.0,
+    float mlf2 = 1.0)
+      : assign_base<T>(tag1, tag2, mlf1, mlf2)
+  {
+    this->x_values.fill(count1, gen);
+    this->y_values.fill(count2, gen);
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
 };
 
 template <class T> struct assign_test1 : assign_values<T>
 {
-    assign_test1() : assign_values<T>(0, 0, 0, 0) {}
+  assign_test1() : assign_values<T>(0, 0, 0, 0) {}
 };
 
 template <class T> struct assign_test2 : assign_values<T>
 {
-    assign_test2() : assign_values<T>(60, 0, 0, 0) {}
+  assign_test2() : assign_values<T>(60, 0, 0, 0) {}
 };
 
 template <class T> struct assign_test2a : assign_values<T>
 {
-    assign_test2a() : assign_values<T>(60, 0, 0, 0, test::limited_range) {}
+  assign_test2a() : assign_values<T>(60, 0, 0, 0, test::limited_range) {}
 };
 
 template <class T> struct assign_test3 : assign_values<T>
 {
-    assign_test3() : assign_values<T>(0, 60, 0, 0) {}
+  assign_test3() : assign_values<T>(0, 60, 0, 0) {}
 };
 
 template <class T> struct assign_test3a : assign_values<T>
 {
-    assign_test3a() : assign_values<T>(0, 60, 0, 0, test::limited_range) {}
+  assign_test3a() : assign_values<T>(0, 60, 0, 0, test::limited_range) {}
 };
 
 template <class T> struct assign_test4 : assign_values<T>
 {
-    assign_test4() : assign_values<T>(10, 10, 1, 2) {}
+  assign_test4() : assign_values<T>(10, 10, 1, 2) {}
 };
 
 template <class T> struct assign_test4a : assign_values<T>
 {
-    assign_test4a() : assign_values<T>(10, 100, 1, 2) {}
+  assign_test4a() : assign_values<T>(10, 100, 1, 2) {}
 };
 
 template <class T> struct assign_test4b : assign_values<T>
 {
-    assign_test4b() : assign_values<T>(10, 100, 1, 2, test::limited_range) {}
+  assign_test4b() : assign_values<T>(10, 100, 1, 2, test::limited_range) {}
 };
 
 template <class T> struct assign_test5 : assign_values<T>
 {
-    assign_test5()
-        : assign_values<T>(5, 60, 0, 0, test::default_generator, 1.0f, 0.1f)
-    {
-    }
+  assign_test5()
+      : assign_values<T>(5, 60, 0, 0, test::default_generator, 1.0f, 0.1f)
+  {
+  }
 };
 
 template <class T> struct equivalent_test1 : assign_base<T>
 {
-    equivalent_test1() : assign_base<T>(0, 0)
-    {
-        test::random_values<T> x_values2(10);
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        test::random_values<T> y_values2(10);
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
+  equivalent_test1() : assign_base<T>(0, 0)
+  {
+    test::random_values<T> x_values2(10);
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    test::random_values<T> y_values2(10);
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
 };
 
 // clang-format off
diff --git a/test/exception/constructor_exception_tests.cpp b/test/exception/constructor_exception_tests.cpp
index 39468054..9c755848 100644
--- a/test/exception/constructor_exception_tests.cpp
+++ b/test/exception/constructor_exception_tests.cpp
@@ -16,196 +16,194 @@ test::seed_t initialize_seed(91274);
 
 struct objects
 {
-    test::exception::object obj;
-    test::exception::hash hash;
-    test::exception::equal_to equal_to;
-    test::exception::allocator<test::exception::object> allocator;
+  test::exception::object obj;
+  test::exception::hash hash;
+  test::exception::equal_to equal_to;
+  test::exception::allocator<test::exception::object> allocator;
 };
 
 template <class T> struct construct_test1 : public objects, test::exception_base
 {
-    void run() const
-    {
-        T x;
+  void run() const
+  {
+    T x;
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct construct_test2 : public objects, test::exception_base
 {
-    void run() const
-    {
-        T x(300);
+  void run() const
+  {
+    T x(300);
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct construct_test3 : public objects, test::exception_base
 {
-    void run() const
-    {
-        T x(0, hash);
+  void run() const
+  {
+    T x(0, hash);
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct construct_test4 : public objects, test::exception_base
 {
-    void run() const
-    {
-        T x(0, hash, equal_to);
+  void run() const
+  {
+    T x(0, hash, equal_to);
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct construct_test5 : public objects, test::exception_base
 {
-    void run() const
-    {
-        T x(50, hash, equal_to, allocator);
+  void run() const
+  {
+    T x(50, hash, equal_to, allocator);
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct construct_test6 : public objects, test::exception_base
 {
-    void run() const
-    {
-        T x(allocator);
+  void run() const
+  {
+    T x(allocator);
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct range : public test::exception_base
 {
-    test::random_values<T> values;
+  test::random_values<T> values;
 
-    range() : values(5, test::limited_range) {}
-    range(unsigned int count) : values(count, test::limited_range) {}
+  range() : values(5, test::limited_range) {}
+  range(unsigned int count) : values(count, test::limited_range) {}
 };
 
 template <class T> struct range_construct_test1 : public range<T>, objects
 {
-    void run() const
-    {
-        T x(this->values.begin(), this->values.end());
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end());
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct range_construct_test2 : public range<T>, objects
 {
-    void run() const
-    {
-        T x(this->values.begin(), this->values.end(), 0);
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 0);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct range_construct_test3 : public range<T>, objects
 {
-    void run() const
-    {
-        T x(this->values.begin(), this->values.end(), 0, hash);
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 0, hash);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct range_construct_test4 : public range<T>, objects
 {
-    void run() const
-    {
-        T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 // 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
 {
-    range_construct_test5() : range<T>(60) {}
+  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);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct input_range_construct_test : public range<T>, objects
 {
-    input_range_construct_test() : range<T>(60) {}
+  input_range_construct_test() : range<T>(60) {}
 
-    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);
+  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);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct copy_range_construct_test : public range<T>, objects
 {
-    copy_range_construct_test() : range<T>(60) {}
+  copy_range_construct_test() : range<T>(60) {}
 
-    void run() const
-    {
-        T x(test::copy_iterator(this->values.begin()),
-            test::copy_iterator(this->values.end()), 0, hash, equal_to,
-            allocator);
+  void run() const
+  {
+    T x(test::copy_iterator(this->values.begin()),
+      test::copy_iterator(this->values.end()), 0, hash, equal_to, allocator);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(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),
-    CONTAINER_SEQ)
+  (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 c8ca5a2f..c3b34be2 100644
--- a/test/exception/containers.hpp
+++ b/test/exception/containers.hpp
@@ -13,32 +13,32 @@
 #include "../objects/exception.hpp"
 
 typedef boost::unordered_set<test::exception::object, test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator<test::exception::object> >
-    test_set;
+  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;
+  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;
+  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::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;
+  std::pair<test::exception::object, test::exception::object>,
+  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;
+  std::pair<test::exception::object, test::exception::object>,
+  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)
+  (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 ba6b2bcf..6149235a 100644
--- a/test/exception/copy_exception_tests.cpp
+++ b/test/exception/copy_exception_tests.cpp
@@ -15,91 +15,90 @@ test::seed_t initialize_seed(73041);
 
 template <class T> struct copy_test1 : public test::exception_base
 {
-    T x;
+  T x;
 
-    void run() const
-    {
-        T y(x);
+  void run() const
+  {
+    T y(x);
 
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(y.empty());
-        test::check_equivalent_keys(y);
-    }
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(y.empty());
+    test::check_equivalent_keys(y);
+  }
 };
 
 template <class T> struct copy_test2 : public test::exception_base
 {
-    test::random_values<T> values;
-    T x;
+  test::random_values<T> values;
+  T x;
 
-    copy_test2()
-        : values(5, test::limited_range), x(values.begin(), values.end())
-    {
-    }
+  copy_test2() : values(5, test::limited_range), x(values.begin(), values.end())
+  {
+  }
 
-    void run() const
-    {
-        T y(x);
+  void run() const
+  {
+    T y(x);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(y, this->values);
-        test::check_equivalent_keys(y);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
 };
 
 template <class T> struct copy_test3 : public test::exception_base
 {
-    test::random_values<T> values;
-    T x;
+  test::random_values<T> values;
+  T x;
 
-    copy_test3() : values(100), x(values.begin(), values.end()) {}
+  copy_test3() : values(100), x(values.begin(), values.end()) {}
 
-    void run() const
-    {
-        T y(x);
+  void run() const
+  {
+    T y(x);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(y, this->values);
-        test::check_equivalent_keys(y);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
 };
 
 template <class T> struct copy_test3a : public test::exception_base
 {
-    test::random_values<T> values;
-    T x;
+  test::random_values<T> values;
+  T x;
 
-    copy_test3a()
-        : values(100, test::limited_range), x(values.begin(), values.end())
-    {
-    }
+  copy_test3a()
+      : values(100, test::limited_range), x(values.begin(), values.end())
+  {
+  }
 
-    void run() const
-    {
-        T y(x);
+  void run() const
+  {
+    T y(x);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(y, this->values);
-        test::check_equivalent_keys(y);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
 };
 
 template <class T> struct copy_with_allocator_test : public test::exception_base
 {
-    test::random_values<T> values;
-    T x;
-    test::exception::allocator<test::exception::object> allocator;
+  test::random_values<T> values;
+  T x;
+  test::exception::allocator<test::exception::object> allocator;
 
-    copy_with_allocator_test() : values(100), x(values.begin(), values.end()) {}
+  copy_with_allocator_test() : values(100), x(values.begin(), values.end()) {}
 
-    void run() const
-    {
-        T y(x, allocator);
+  void run() const
+  {
+    T y(x, allocator);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(y, this->values);
-        test::check_equivalent_keys(y);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
 };
 
 // clang-format off
diff --git a/test/exception/erase_exception_tests.cpp b/test/exception/erase_exception_tests.cpp
index 93e09439..dcd2dbd5 100644
--- a/test/exception/erase_exception_tests.cpp
+++ b/test/exception/erase_exception_tests.cpp
@@ -13,43 +13,43 @@ test::seed_t initialize_seed(835193);
 
 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, test::limited_range)
-    {
-    }
+  test::random_values<T> values;
+  erase_test_base(unsigned int count = 5) : values(count, test::limited_range)
+  {
+  }
 
-    typedef T data_type;
+  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
-    {
-        std::string scope(test::scope);
+  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)");
+    BOOST_TEST(scope.find("hash::") != std::string::npos ||
+               scope.find("equal_to::") != std::string::npos ||
+               scope == "operator==(object, object)");
 
-        test::check_equivalent_keys(x);
-    }
+    test::check_equivalent_keys(x);
+  }
 };
 
 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;
+  void run(T& x) const
+  {
+    typedef BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+      iterator;
 
-        for (iterator it = this->values.begin(), end = this->values.end();
-             it != end; ++it) {
-            x.erase(test::get_key<T>(*it));
-        }
-
-        DISABLE_EXCEPTIONS;
-        BOOST_TEST(x.empty());
-        test::check_equivalent_keys(x);
+    for (iterator it = this->values.begin(), end = this->values.end();
+         it != end; ++it) {
+      x.erase(test::get_key<T>(*it));
     }
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
 };
 
 EXCEPTION_TESTS((erase_by_key_test1), CONTAINER_SEQ)
diff --git a/test/exception/insert_exception_tests.cpp b/test/exception/insert_exception_tests.cpp
index d5fc3f10..f0e55ae7 100644
--- a/test/exception/insert_exception_tests.cpp
+++ b/test/exception/insert_exception_tests.cpp
@@ -17,16 +17,16 @@ test::seed_t initialize_seed(747373);
 // Fill in a container so that it's about to rehash
 template <typename T> void rehash_prep(T& x)
 {
-    using namespace std;
-    typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
+  using namespace std;
+  typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
 
-    x.max_load_factor(0.25);
-    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);
-    test::random_values<T> v(initial_elements);
-    x.insert(v.begin(), v.end());
-    BOOST_TEST(bucket_count == x.bucket_count());
+  x.max_load_factor(0.25);
+  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);
+  test::random_values<T> v(initial_elements);
+  x.insert(v.begin(), v.end());
+  BOOST_TEST(bucket_count == x.bucket_count());
 }
 
 // Overload to generate inserters that need type information.
@@ -34,7 +34,7 @@ template <typename T> void rehash_prep(T& x)
 template <typename Inserter, typename T>
 Inserter generate(Inserter inserter, T&)
 {
-    return inserter;
+  return inserter;
 }
 
 // Get the iterator returned from an insert/emplace.
@@ -43,7 +43,7 @@ template <typename T> T get_iterator(T const& x) { return x; }
 
 template <typename T> T get_iterator(std::pair<T, bool> const& x)
 {
-    return x.first;
+  return x.first;
 }
 
 // Generic insert exception test for typical single element inserts..
@@ -51,28 +51,27 @@ template <typename T> T get_iterator(std::pair<T, bool> const& x)
 template <typename T, typename Inserter, typename Values>
 void insert_exception_test_impl(T x, Inserter insert, Values const& v)
 {
-    test::strong<T> strong;
+  test::strong<T> strong;
 
-    test::ordered<T> tracker;
-    tracker.insert(x.begin(), x.end());
+  test::ordered<T> tracker;
+  tracker.insert(x.begin(), x.end());
 
-    try {
-        ENABLE_EXCEPTIONS;
+  try {
+    ENABLE_EXCEPTIONS;
 
-        for (typename Values::const_iterator it = v.begin(); it != v.end();
-             ++it) {
-            strong.store(x, test::detail::tracker.count_allocations);
-            insert(x, it);
-        }
-    } catch (...) {
-        test::check_equivalent_keys(x);
-        insert.exception_check(x, strong);
-        throw;
+    for (typename Values::const_iterator it = v.begin(); it != v.end(); ++it) {
+      strong.store(x, test::detail::tracker.count_allocations);
+      insert(x, it);
     }
-
+  } catch (...) {
     test::check_equivalent_keys(x);
-    insert.track(tracker, v.begin(), v.end());
-    tracker.compare(x);
+    insert.exception_check(x, strong);
+    throw;
+  }
+
+  test::check_equivalent_keys(x);
+  insert.track(tracker, v.begin(), v.end());
+  tracker.compare(x);
 }
 
 // Simple insert exception test
@@ -80,12 +79,12 @@ void insert_exception_test_impl(T x, Inserter insert, Values const& v)
 template <typename T, typename Inserter>
 void insert_exception_test(T*, Inserter insert, test::random_generator gen)
 {
-    for (int i = 0; i < 5; ++i) {
-        test::random_values<T> v(10, gen);
-        T x;
+  for (int i = 0; i < 5; ++i) {
+    test::random_values<T> v(10, gen);
+    T x;
 
-        EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v));
-    }
+    EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v));
+  }
 }
 
 // Insert into a container which is about to hit its max load, so that it
@@ -93,130 +92,130 @@ void insert_exception_test(T*, Inserter insert, test::random_generator gen)
 
 template <typename T, typename Inserter>
 void insert_rehash_exception_test(
-    T*, Inserter insert, test::random_generator gen)
+  T*, Inserter insert, test::random_generator gen)
 {
-    for (int i = 0; i < 5; ++i) {
-        T x;
-        rehash_prep(x);
+  for (int i = 0; i < 5; ++i) {
+    T x;
+    rehash_prep(x);
 
-        test::random_values<T> v2(5, gen);
-        EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v2));
-    }
+    test::random_values<T> v2(5, gen);
+    EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v2));
+  }
 }
 
 // Various methods for inserting a single element
 
 struct inserter_base
 {
-    template <typename T> void exception_check(T& x, test::strong<T>& strong)
-    {
-        std::string scope(test::scope);
+  template <typename T> void exception_check(T& x, test::strong<T>& strong)
+  {
+    std::string scope(test::scope);
 
-        if (scope.find("hash::operator()") == std::string::npos)
-            strong.test(x, test::detail::tracker.count_allocations);
-    }
+    if (scope.find("hash::operator()") == std::string::npos)
+      strong.test(x, test::detail::tracker.count_allocations);
+  }
 
-    template <typename T, typename Iterator>
-    void track(T& tracker, Iterator begin, Iterator end)
-    {
-        tracker.insert(begin, end);
-    }
+  template <typename T, typename Iterator>
+  void track(T& tracker, Iterator begin, Iterator end)
+  {
+    tracker.insert(begin, end);
+  }
 };
 
 struct insert_lvalue_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.insert(*it);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(*it);
+  }
 } insert_lvalue;
 
 struct insert_lvalue_begin_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.insert(x.begin(), *it);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(x.begin(), *it);
+  }
 } insert_lvalue_begin;
 
 struct insert_lvalue_end_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.insert(x.end(), *it);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(x.end(), *it);
+  }
 } insert_lvalue_end;
 
 struct insert_lvalue_pos_type
 {
-    template <typename T> struct impl : inserter_base
+  template <typename T> struct impl : inserter_base
+  {
+    typename T::iterator pos;
+
+    impl(T& x) : pos(x.begin()) {}
+
+    template <typename Iterator> void operator()(T& x, Iterator it)
     {
-        typename T::iterator pos;
-
-        impl(T& x) : pos(x.begin()) {}
-
-        template <typename Iterator> void operator()(T& x, Iterator it)
-        {
-            pos = get_iterator(x.insert(pos, *it));
-        }
-    };
-
-    template <typename T> friend impl<T> generate(insert_lvalue_pos_type, T& x)
-    {
-        return impl<T>(x);
+      pos = get_iterator(x.insert(pos, *it));
     }
+  };
+
+  template <typename T> friend impl<T> generate(insert_lvalue_pos_type, T& x)
+  {
+    return impl<T>(x);
+  }
 } insert_lvalue_pos;
 
 struct insert_single_item_range_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.insert(it, test::next(it));
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(it, test::next(it));
+  }
 } insert_single_item_range;
 
 struct emplace_lvalue_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.emplace(*it);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace(*it);
+  }
 } emplace_lvalue;
 
 struct emplace_lvalue_begin_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.emplace_hint(x.begin(), *it);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace_hint(x.begin(), *it);
+  }
 } emplace_lvalue_begin;
 
 struct emplace_lvalue_end_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.emplace_hint(x.end(), *it);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace_hint(x.end(), *it);
+  }
 } emplace_lvalue_end;
 
 struct emplace_lvalue_pos_type
 {
-    template <typename T> struct impl : inserter_base
+  template <typename T> struct impl : inserter_base
+  {
+    typename T::iterator pos;
+
+    impl(T& x) : pos(x.begin()) {}
+
+    template <typename Iterator> void operator()(T& x, Iterator it)
     {
-        typename T::iterator pos;
-
-        impl(T& x) : pos(x.begin()) {}
-
-        template <typename Iterator> void operator()(T& x, Iterator it)
-        {
-            pos = get_iterator(x.emplace_hint(pos, *it));
-        }
-    };
-
-    template <typename T> friend impl<T> generate(emplace_lvalue_pos_type, T& x)
-    {
-        return impl<T>(x);
+      pos = get_iterator(x.emplace_hint(pos, *it));
     }
+  };
+
+  template <typename T> friend impl<T> generate(emplace_lvalue_pos_type, T& x)
+  {
+    return impl<T>(x);
+  }
 } emplace_lvalue_pos;
 
 // Run the exception tests in various combinations.
@@ -256,21 +255,21 @@ UNORDERED_TEST(insert_rehash_exception_test,
 
 struct pair_emplace_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.emplace(boost::unordered::piecewise_construct,
-            boost::make_tuple(it->first), boost::make_tuple(it->second));
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(it->first), boost::make_tuple(it->second));
+  }
 } pair_emplace;
 
 struct pair_emplace2_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.emplace_hint(x.begin(), boost::unordered::piecewise_construct,
-            boost::make_tuple(it->first),
-            boost::make_tuple(it->second.tag1_, it->second.tag2_));
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace_hint(x.begin(), boost::unordered::piecewise_construct,
+      boost::make_tuple(it->first),
+      boost::make_tuple(it->second.tag1_, it->second.tag2_));
+  }
 } pair_emplace2;
 
 test_pair_set* test_pair_set_;
@@ -293,54 +292,54 @@ UNORDERED_TEST(insert_rehash_exception_test,
 
 struct try_emplace_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.try_emplace(it->first, it->second);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.try_emplace(it->first, it->second);
+  }
 } try_emplace;
 
 struct try_emplace2_type : inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.try_emplace(it->first, it->second.tag1_, it->second.tag2_);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.try_emplace(it->first, it->second.tag1_, it->second.tag2_);
+  }
 } try_emplace2;
 
 struct map_inserter_base
 {
-    template <typename T> void exception_check(T& x, test::strong<T>& strong)
-    {
-        std::string scope(test::scope);
+  template <typename T> void exception_check(T& x, test::strong<T>& strong)
+  {
+    std::string scope(test::scope);
 
-        if (scope.find("hash::operator()") == std::string::npos &&
-            scope.find("::operator=") == std::string::npos)
-            strong.test(x, test::detail::tracker.count_allocations);
-    }
+    if (scope.find("hash::operator()") == std::string::npos &&
+        scope.find("::operator=") == std::string::npos)
+      strong.test(x, test::detail::tracker.count_allocations);
+  }
 
-    template <typename T, typename Iterator>
-    void track(T& tracker, Iterator begin, Iterator end)
-    {
-        for (; begin != end; ++begin) {
-            tracker[begin->first] = begin->second;
-        }
+  template <typename T, typename Iterator>
+  void track(T& tracker, Iterator begin, Iterator end)
+  {
+    for (; begin != end; ++begin) {
+      tracker[begin->first] = begin->second;
     }
+  }
 };
 
 struct map_insert_operator_type : map_inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x[it->first] = it->second;
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x[it->first] = it->second;
+  }
 } map_insert_operator;
 
 struct map_insert_or_assign_type : map_inserter_base
 {
-    template <typename T, typename Iterator> void operator()(T& x, Iterator it)
-    {
-        x.insert_or_assign(it->first, it->second);
-    }
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert_or_assign(it->first, it->second);
+  }
 } map_insert_or_assign;
 
 // clang-format off
@@ -361,43 +360,43 @@ UNORDERED_TEST(insert_rehash_exception_test,
 template <typename T, typename Values>
 void insert_range_exception_test_impl(T x, Values const& v)
 {
-    test::ordered<T> tracker;
-    tracker.insert(x.begin(), x.end());
-
-    try {
-        ENABLE_EXCEPTIONS;
-        x.insert(v.begin(), v.end());
-    } catch (...) {
-        test::check_equivalent_keys(x);
-        throw;
-    }
+  test::ordered<T> tracker;
+  tracker.insert(x.begin(), x.end());
 
+  try {
+    ENABLE_EXCEPTIONS;
+    x.insert(v.begin(), v.end());
+  } catch (...) {
     test::check_equivalent_keys(x);
-    tracker.insert(v.begin(), v.end());
-    tracker.compare(x);
+    throw;
+  }
+
+  test::check_equivalent_keys(x);
+  tracker.insert(v.begin(), v.end());
+  tracker.compare(x);
 }
 
 template <typename T>
 void insert_range_exception_test(T*, test::random_generator gen)
 {
-    for (int i = 0; i < 5; ++i) {
-        test::random_values<T> v(10, gen);
-        T x;
+  for (int i = 0; i < 5; ++i) {
+    test::random_values<T> v(10, gen);
+    T x;
 
-        EXCEPTION_LOOP(insert_range_exception_test_impl(x, v));
-    }
+    EXCEPTION_LOOP(insert_range_exception_test_impl(x, v));
+  }
 }
 
 template <typename T>
 void insert_range_rehash_exception_test(T*, test::random_generator gen)
 {
-    for (int i = 0; i < 5; ++i) {
-        T x;
-        rehash_prep(x);
+  for (int i = 0; i < 5; ++i) {
+    T x;
+    rehash_prep(x);
 
-        test::random_values<T> v2(5, gen);
-        EXCEPTION_LOOP(insert_range_exception_test_impl(x, v2));
-    }
+    test::random_values<T> v2(5, gen);
+    EXCEPTION_LOOP(insert_range_exception_test_impl(x, v2));
+  }
 }
 
 // clang-format off
diff --git a/test/exception/merge_exception_tests.cpp b/test/exception/merge_exception_tests.cpp
index 48f6b697..4f5034bc 100644
--- a/test/exception/merge_exception_tests.cpp
+++ b/test/exception/merge_exception_tests.cpp
@@ -6,59 +6,59 @@
 
 template <typename T1, typename T2> void merge_exception_test(T1 x, T2 y)
 {
-    std::size_t size = x.size() + y.size();
+  std::size_t size = x.size() + y.size();
 
-    try {
-        ENABLE_EXCEPTIONS;
-        x.merge(y);
-    } catch (...) {
-        test::check_equivalent_keys(x);
-        test::check_equivalent_keys(y);
-        throw;
-    }
-
-    // Not a full check, just want to make sure the merge completed.
-    BOOST_TEST(size == x.size() + y.size());
-    if (y.size()) {
-        BOOST_TEST(test::has_unique_keys<T1>::value);
-        for (typename T2::iterator it = y.begin(); it != y.end(); ++it) {
-            BOOST_TEST(x.find(test::get_key<T2>(*it)) != x.end());
-        }
-    }
+  try {
+    ENABLE_EXCEPTIONS;
+    x.merge(y);
+  } catch (...) {
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
+    throw;
+  }
+
+  // Not a full check, just want to make sure the merge completed.
+  BOOST_TEST(size == x.size() + y.size());
+  if (y.size()) {
+    BOOST_TEST(test::has_unique_keys<T1>::value);
+    for (typename T2::iterator it = y.begin(); it != y.end(); ++it) {
+      BOOST_TEST(x.find(test::get_key<T2>(*it)) != x.end());
+    }
+  }
+  test::check_equivalent_keys(x);
+  test::check_equivalent_keys(y);
 }
 
 template <typename T1, typename T2>
 void merge_exception_test(T1 const*, T2 const*, std::size_t count12, int tag12,
-    test::random_generator gen1, test::random_generator gen2)
+  test::random_generator gen1, test::random_generator gen2)
 {
-    std::size_t count1 = count12 / 256;
-    std::size_t count2 = count12 % 256;
-    int tag1 = tag12 / 256;
-    int tag2 = tag12 % 256;
-    test::random_values<T1> v1(count1, gen1);
-    test::random_values<T2> v2(count2, gen2);
-    T1 x(v1.begin(), v1.end(), 0, test::exception::hash(tag1),
-        test::exception::equal_to(tag1));
-    T2 y(v2.begin(), v2.end(), 0, test::exception::hash(tag2),
-        test::exception::equal_to(tag2));
+  std::size_t count1 = count12 / 256;
+  std::size_t count2 = count12 % 256;
+  int tag1 = tag12 / 256;
+  int tag2 = tag12 % 256;
+  test::random_values<T1> v1(count1, gen1);
+  test::random_values<T2> v2(count2, gen2);
+  T1 x(v1.begin(), v1.end(), 0, test::exception::hash(tag1),
+    test::exception::equal_to(tag1));
+  T2 y(v2.begin(), v2.end(), 0, test::exception::hash(tag2),
+    test::exception::equal_to(tag2));
 
-    EXCEPTION_LOOP(merge_exception_test(x, y))
+  EXCEPTION_LOOP(merge_exception_test(x, y))
 }
 
 boost::unordered_set<test::exception::object, test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator<test::exception::object> >* test_set_;
+  test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >* test_set_;
 boost::unordered_multiset<test::exception::object, test::exception::hash,
-    test::exception::equal_to,
-    test::exception::allocator<test::exception::object> >* test_multiset_;
+  test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >* test_multiset_;
 boost::unordered_map<test::exception::object, test::exception::object,
-    test::exception::hash, test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> >* test_map_;
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >* test_map_;
 boost::unordered_multimap<test::exception::object, test::exception::object,
-    test::exception::hash, test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> >* test_multimap_;
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >* test_multimap_;
 
 using test::default_generator;
 using test::generate_collisions;
diff --git a/test/exception/move_assign_exception_tests.cpp b/test/exception/move_assign_exception_tests.cpp
index 5fe909a2..576d3233 100644
--- a/test/exception/move_assign_exception_tests.cpp
+++ b/test/exception/move_assign_exception_tests.cpp
@@ -11,118 +11,118 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(                                                               \
-    disable : 4512) // move_assignment operator could not be generated
+  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
 {
-    test::random_values<T> x_values, y_values;
-    T x, y;
+  test::random_values<T> x_values, y_values;
+  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;
+  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))
-    {
-        x.max_load_factor(mlf1);
-        y.max_load_factor(mlf2);
-    }
-
-    typedef T data_type;
-    T init() const { return T(x); }
-    void run(T& x1) const
-    {
-        test::exceptions_enable disable_exceptions(false);
-        T y1 = y;
-        disable_exceptions.release();
-        x1 = boost::move(y1);
-
-        DISABLE_EXCEPTIONS;
-        test::check_container(x1, y_values);
-        test::check_equivalent_keys(x1);
-    }
-
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
-    {
-        test::check_equivalent_keys(x1);
-
-        // If the container is empty at the point of the exception, the
-        // internal structure is hidden, this exposes it, at the cost of
-        // messing up the data.
-        if (x_values.size()) {
-            T& x2 = const_cast<T&>(x1);
-            x2.emplace(*x_values.begin());
-            test::check_equivalent_keys(x2);
-        }
+  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);
+  }
+
+  typedef T data_type;
+  T init() const { return T(x); }
+  void run(T& x1) const
+  {
+    test::exceptions_enable disable_exceptions(false);
+    T y1 = y;
+    disable_exceptions.release();
+    x1 = boost::move(y1);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x1, y_values);
+    test::check_equivalent_keys(x1);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
+  {
+    test::check_equivalent_keys(x1);
+
+    // If the container is empty at the point of the exception, the
+    // internal structure is hidden, this exposes it, at the cost of
+    // messing up the data.
+    if (x_values.size()) {
+      T& x2 = const_cast<T&>(x1);
+      x2.emplace(*x_values.begin());
+      test::check_equivalent_keys(x2);
     }
+  }
 };
 
 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)
-    {
-        this->x_values.fill(count1, test::limited_range);
-        this->y_values.fill(count2, test::limited_range);
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
+  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, test::limited_range);
+    this->y_values.fill(count2, test::limited_range);
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
 };
 
 template <class T> struct move_assign_test1 : move_assign_values<T>
 {
-    move_assign_test1() : move_assign_values<T>(0, 0, 0, 0) {}
+  move_assign_test1() : move_assign_values<T>(0, 0, 0, 0) {}
 };
 
 template <class T> struct move_assign_test2 : move_assign_values<T>
 {
-    move_assign_test2() : move_assign_values<T>(60, 0, 0, 0) {}
+  move_assign_test2() : move_assign_values<T>(60, 0, 0, 0) {}
 };
 
 template <class T> struct move_assign_test3 : move_assign_values<T>
 {
-    move_assign_test3() : move_assign_values<T>(0, 60, 0, 0) {}
+  move_assign_test3() : move_assign_values<T>(0, 60, 0, 0) {}
 };
 
 template <class T> struct move_assign_test4 : move_assign_values<T>
 {
-    move_assign_test4() : move_assign_values<T>(10, 10, 1, 2) {}
+  move_assign_test4() : move_assign_values<T>(10, 10, 1, 2) {}
 };
 
 template <class T> struct move_assign_test4a : move_assign_values<T>
 {
-    move_assign_test4a() : move_assign_values<T>(10, 100, 1, 2) {}
+  move_assign_test4a() : move_assign_values<T>(10, 100, 1, 2) {}
 };
 
 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) {}
+  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>
 {
-    equivalent_test1() : move_assign_base<T>(0, 0)
-    {
-        test::random_values<T> x_values2(10, test::limited_range);
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        test::random_values<T> y_values2(10, test::limited_range);
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
+  equivalent_test1() : move_assign_base<T>(0, 0)
+  {
+    test::random_values<T> x_values2(10, test::limited_range);
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    test::random_values<T> y_values2(10, test::limited_range);
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
 };
 
-EXCEPTION_TESTS((move_assign_test1)(move_assign_test2)(move_assign_test3)(
-                    move_assign_test4)(move_assign_test4a)(move_assign_test5)(
-                    equivalent_test1),
-    CONTAINER_SEQ)
+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 f1386532..88f17932 100644
--- a/test/exception/rehash_exception_tests.cpp
+++ b/test/exception/rehash_exception_tests.cpp
@@ -15,115 +15,115 @@ test::seed_t initialize_seed(3298597);
 
 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, test::limited_range), n(n_)
-    {
-    }
+  test::random_values<T> values;
+  unsigned int n;
+  rehash_test_base(unsigned int count = 100, unsigned int n_ = 0)
+      : values(count, test::limited_range), n(n_)
+  {
+  }
 
-    typedef T data_type;
-    typedef test::strong<T> strong_type;
+  typedef T data_type;
+  typedef test::strong<T> strong_type;
 
-    data_type init() const
-    {
-        T x(values.begin(), values.end(), n);
-        return x;
-    }
+  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
-    {
-        std::string scope(test::scope);
+  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)")
-            strong.test(x);
+    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);
-    }
+    test::check_equivalent_keys(x);
+  }
 };
 
 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);
+  rehash_test0() : rehash_test_base<T>(0) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 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);
+  rehash_test1() : rehash_test_base<T>(0) {}
+  void run(T& x) const
+  {
+    x.rehash(200);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 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);
+  rehash_test2() : rehash_test_base<T>(0, 200) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 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);
+  rehash_test3() : rehash_test_base<T>(10, 0) {}
+  void run(T& x) const
+  {
+    x.rehash(200);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 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);
+  rehash_test4() : rehash_test_base<T>(10, 200) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct rehash_test5 : rehash_test_base<T>
 {
-    rehash_test5() : rehash_test_base<T>(200, 10) {}
-    void run(T& x) const
-    {
-        x.rehash(0);
+  rehash_test5() : rehash_test_base<T>(200, 10) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 };
 
 EXCEPTION_TESTS((rehash_test0)(rehash_test1)(rehash_test2)(rehash_test3)(
-                    rehash_test4)(rehash_test5),
-    CONTAINER_SEQ)
+                  rehash_test4)(rehash_test5),
+  CONTAINER_SEQ)
 RUN_TESTS()
diff --git a/test/exception/swap_exception_tests.cpp b/test/exception/swap_exception_tests.cpp
index d8b81128..f722b1af 100644
--- a/test/exception/swap_exception_tests.cpp
+++ b/test/exception/swap_exception_tests.cpp
@@ -17,35 +17,33 @@ test::seed_t initialize_seed(9387);
 
 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, test::limited_range)
-    {
-    }
+  test::random_values<T> values;
+  self_swap_base(std::size_t count = 0) : values(count, test::limited_range) {}
 
-    typedef T data_type;
-    T init() const { return T(values.begin(), values.end()); }
+  typedef T data_type;
+  T init() const { return T(values.begin(), values.end()); }
 
-    void run(T& x) const
-    {
-        x.swap(x);
+  void run(T& x) const
+  {
+    x.swap(x);
 
-        DISABLE_EXCEPTIONS;
-        test::check_container(x, this->values);
-        test::check_equivalent_keys(x);
-    }
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
 
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
-    {
-        std::string scope(test::scope);
+  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)");
+    // 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)");
 
-        test::check_equivalent_keys(x);
-    }
+    test::check_equivalent_keys(x);
+  }
 };
 
 template <class T> struct self_swap_test1 : self_swap_base<T>
@@ -54,91 +52,90 @@ template <class T> struct self_swap_test1 : self_swap_base<T>
 
 template <class T> struct self_swap_test2 : self_swap_base<T>
 {
-    self_swap_test2() : self_swap_base<T>(100) {}
+  self_swap_test2() : self_swap_base<T>(100) {}
 };
 
 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;
+  const test::random_values<T> x_values, y_values;
+  const T initial_x, initial_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;
+  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;
 
-    swap_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
-        : x_values(count1, test::limited_range),
-          y_values(count2, test::limited_range),
-          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))
-    {
+  swap_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
+      : x_values(count1, test::limited_range),
+        y_values(count2, test::limited_range),
+        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_) {}
+
+    T x, y;
+  };
+
+  data_type init() const { return data_type(initial_x, initial_y); }
+
+  void run(data_type& d) const
+  {
+    try {
+      d.x.swap(d.y);
+    } catch (std::runtime_error) {
     }
 
-    struct data_type
-    {
-        data_type(T const& x_, T const& y_) : x(x_), y(y_) {}
+    DISABLE_EXCEPTIONS;
+    test::check_container(d.x, this->y_values);
+    test::check_equivalent_keys(d.x);
+    test::check_container(d.y, this->x_values);
+    test::check_equivalent_keys(d.y);
+  }
 
-        T x, y;
-    };
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const
+  {
+    std::string scope(test::scope);
 
-    data_type init() const { return data_type(initial_x, initial_y); }
+    // 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)");
 
-    void run(data_type& d) const
-    {
-        try {
-            d.x.swap(d.y);
-        } catch (std::runtime_error) {
-        }
-
-        DISABLE_EXCEPTIONS;
-        test::check_container(d.x, this->y_values);
-        test::check_equivalent_keys(d.x);
-        test::check_container(d.y, this->x_values);
-        test::check_equivalent_keys(d.y);
-    }
-
-    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)");
-
-        test::check_equivalent_keys(d.x);
-        test::check_equivalent_keys(d.y);
-    }
+    test::check_equivalent_keys(d.x);
+    test::check_equivalent_keys(d.y);
+  }
 };
 
 template <class T> struct swap_test1 : swap_base<T>
 {
-    swap_test1() : swap_base<T>(0, 0, 0, 0) {}
+  swap_test1() : swap_base<T>(0, 0, 0, 0) {}
 };
 
 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>
 {
-    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>
 {
-    swap_test4() : swap_base<T>(10, 10, 1, 2) {}
+  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),
-    CONTAINER_SEQ)
+                  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 83a2d7f8..1c70a8c7 100644
--- a/test/helpers/check_return_type.hpp
+++ b/test/helpers/check_return_type.hpp
@@ -11,23 +11,23 @@
 #include <boost/type_traits/is_same.hpp>
 
 namespace test {
-template <class T1> struct check_return_type
-{
+  template <class T1> struct check_return_type
+  {
     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));
+      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));
+      BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
     }
-};
+  };
 }
 
 #endif
diff --git a/test/helpers/count.hpp b/test/helpers/count.hpp
index 76248617..3ed49ed6 100644
--- a/test/helpers/count.hpp
+++ b/test/helpers/count.hpp
@@ -9,8 +9,8 @@
 #include <boost/detail/lightweight_test.hpp>
 
 namespace test {
-struct object_count
-{
+  struct object_count
+  {
     int instances;
     int constructions;
 
@@ -19,52 +19,52 @@ struct object_count
 
     void construct()
     {
-        ++instances;
-        ++constructions;
+      ++instances;
+      ++constructions;
     }
 
     void destruct()
     {
-        if (instances == 0) {
-            BOOST_ERROR("Unbalanced constructions.");
-        } else {
-            --instances;
-        }
+      if (instances == 0) {
+        BOOST_ERROR("Unbalanced constructions.");
+      } else {
+        --instances;
+      }
     }
 
     bool operator==(object_count const& x) const
     {
-        return instances == x.instances && constructions == x.constructions;
+      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;
+      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;
-}
+  // 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
-{
+  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
-{
+  struct check_instances
+  {
     int instances_;
     int constructions_;
 
@@ -75,15 +75,15 @@ struct check_instances
     }
     ~check_instances()
     {
-        BOOST_TEST(global_object_count.instances == 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_;
+      return global_object_count.constructions - constructions_;
     }
-};
+  };
 }
 
 #endif
diff --git a/test/helpers/equivalent.hpp b/test/helpers/equivalent.hpp
index 44050a5e..6d05f204 100644
--- a/test/helpers/equivalent.hpp
+++ b/test/helpers/equivalent.hpp
@@ -15,48 +15,49 @@
 #include <boost/unordered_set.hpp>
 
 namespace test {
-template <class T1, class T2>
-bool equivalent_impl(T1 const& x, T2 const& y, base_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)
-{
+  template <class T>
+  bool equivalent_impl(
+    boost::hash<T> const&, boost::hash<T> const&, derived_type)
+  {
     return true;
-}
+  }
 
-template <class T>
-bool equivalent_impl(
+  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(
+  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
-{
+  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);
+      return equivalent_impl(x, y, derived);
     }
-};
+  };
 
-const equivalent_type equivalent;
+  const equivalent_type equivalent;
 
-template <class Container> class unordered_equivalence_tester
-{
+  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_;
@@ -70,26 +71,26 @@ template <class Container> class unordered_equivalence_tester
         : 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();
+      values_.sort();
     }
 
     bool operator()(Container const& x) const
     {
-        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;
+      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;
 
-        value_list copy(x.begin(), x.end());
-        copy.sort();
-        return values_ == copy;
+      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 7edf8848..a7ded572 100644
--- a/test/helpers/exception_test.hpp
+++ b/test/helpers/exception_test.hpp
@@ -14,64 +14,61 @@
 #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>));                        \
-    }
+  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>));                    \
-        }                                                                      \
-    }
+  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_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))
+  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))
+  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))
+  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())
+  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);                                           \
-    }
+  if (::test::exceptions_enabled) {                                            \
+    UNORDERED_EPOINT_IMPL(name);                                               \
+  }
 
 #define ENABLE_EXCEPTIONS                                                      \
-    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
+  ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
 
 #define DISABLE_EXCEPTIONS                                                     \
-    ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
+  ::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
-{
+  class scope_guard
+  {
     scope_guard& operator=(scope_guard const&);
     scope_guard(scope_guard const&);
 
@@ -83,22 +80,22 @@ class scope_guard
     scope_guard(char const* name)
         : old_scope_(scope), scope_(name), dismissed_(false)
     {
-        scope = scope_;
+      scope = scope_;
     }
 
     ~scope_guard()
     {
-        if (dismissed_)
-            scope = old_scope_;
+      if (dismissed_)
+        scope = old_scope_;
     }
 
     void dismiss() { dismissed_ = true; }
 
     bool dismissed() const { return dismissed_; }
-};
+  };
 
-class exceptions_enable
-{
+  class exceptions_enable
+  {
     exceptions_enable& operator=(exceptions_enable const&);
     exceptions_enable(exceptions_enable const&);
 
@@ -109,65 +106,65 @@ class exceptions_enable
     exceptions_enable(bool enable)
         : old_value_(exceptions_enabled), released_(false)
     {
-        exceptions_enabled = enable;
+      exceptions_enabled = enable;
     }
 
     ~exceptions_enable()
     {
-        if (!released_) {
-            exceptions_enabled = old_value_;
-            released_ = true;
-        }
+      if (!released_) {
+        exceptions_enabled = old_value_;
+        released_ = true;
+      }
     }
 
     void release()
     {
-        if (!released_) {
-            exceptions_enabled = old_value_;
-            released_ = true;
-        }
+      if (!released_) {
+        exceptions_enabled = old_value_;
+        released_ = true;
+      }
     }
-};
+  };
 
-struct exception_base
-{
+  struct exception_base
+  {
     struct data_type
     {
     };
     struct strong_type
     {
-        template <class T> void store(T const&) {}
-        template <class T> void test(T const&) const {}
+      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(
+  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(
+  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(
+  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 T> T const& constant(T const& x) { return x; }
 
-template <class Test> class test_runner
-{
+  template <class Test> class test_runner
+  {
     Test const& test_;
     bool exception_in_check_;
 
@@ -178,175 +175,179 @@ template <class Test> class test_runner
     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);
+          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 (...) {
-            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;
+          exception_in_check_ = true;
         }
+        throw;
+      }
     }
     void end()
     {
-        if (exception_in_check_) {
-            BOOST_ERROR("Unexcpected exception in test_runner check call.");
-        }
+      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) {
+    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);
+    template <class Test>
+    void exception_safety(Test const& f, char const* /*name*/)
+    {
+      test_runner<Test> runner(f);
 
-    iteration = 0;
-    bool success = false;
-    unsigned int failure_count = 0;
-    char const* error_msg = 0;
-    do {
+      iteration = 0;
+      bool success = false;
+      unsigned int failure_count = 0;
+      char const* error_msg = 0;
+      do {
         int error_count = boost::detail::test_errors();
         ++iteration;
         count = 0;
 
         try {
-            runner.run();
-            success = true;
+          runner.run();
+          success = true;
         } catch (test_failure) {
-            error_msg = "test_failure caught.";
-            break;
+          error_msg = "test_failure caught.";
+          break;
         } catch (test_exception e) {
-            if (error_count != boost::detail::test_errors()) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM
-                    << "Iteration: " << iteration
-                    << " Error found for epoint: " << e.name << std::endl;
-            }
+          if (error_count != boost::detail::test_errors()) {
+            BOOST_LIGHTWEIGHT_TEST_OSTREAM
+              << "Iteration: " << iteration
+              << " Error found for epoint: " << e.name << std::endl;
+          }
         } catch (...) {
-            error_msg = "Unexpected exception.";
-            break;
+          error_msg = "Unexpected exception.";
+          break;
         }
 
         if (error_count != boost::detail::test_errors()) {
-            ++failure_count;
+          ++failure_count;
         }
-    } while (!success && failure_count < 5);
+      } while (!success && failure_count < 5);
 
-    if (error_msg) {
+      if (error_msg) {
         BOOST_ERROR(error_msg);
+      }
+      runner.end();
     }
-    runner.end();
-}
 
-//
-// An alternative way to run exception tests.
-// See merge_exception_tests.cpp for an example.
+    //
+    // An alternative way to run exception tests.
+    // See merge_exception_tests.cpp for an example.
 
-struct exception_looper
-{
-    bool success;
-    unsigned int failure_count;
-    char const* error_msg;
-    int error_count;
-
-    exception_looper() : success(false), failure_count(0), error_msg(0) {}
-
-    void start() { iteration = 0; }
-
-    bool loop_condition() const
+    struct exception_looper
     {
+      bool success;
+      unsigned int failure_count;
+      char const* error_msg;
+      int error_count;
+
+      exception_looper() : success(false), failure_count(0), error_msg(0) {}
+
+      void start() { iteration = 0; }
+
+      bool loop_condition() const
+      {
         return !error_msg && !success && failure_count < 5;
-    }
+      }
 
-    void start_iteration()
-    {
+      void start_iteration()
+      {
         error_count = boost::detail::test_errors();
         ++iteration;
         count = 0;
-    }
+      }
 
-    void successful_run() { success = true; }
+      void successful_run() { success = true; }
 
-    void test_failure_caught(test_failure const&)
-    {
+      void test_failure_caught(test_failure const&)
+      {
         error_msg = "test_failure caught.";
-    }
+      }
 
-    void test_exception_caught(test_exception const& e)
-    {
+      void test_exception_caught(test_exception const& e)
+      {
         if (error_count != boost::detail::test_errors()) {
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM
-                << "Iteration: " << iteration
-                << " Error found for epoint: " << e.name << std::endl;
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << "Iteration: " << iteration
+            << " Error found for epoint: " << e.name << std::endl;
         }
-    }
+      }
 
-    void unexpected_exception_caught() { error_msg = "Unexpected exception."; }
+      void unexpected_exception_caught()
+      {
+        error_msg = "Unexpected exception.";
+      }
 
-    void end()
-    {
+      void end()
+      {
         if (error_msg) {
-            BOOST_ERROR(error_msg);
+          BOOST_ERROR(error_msg);
         }
-    }
-};
+      }
+    };
 
 #define EXCEPTION_LOOP(op)                                                     \
-    test::lightweight::exception_looper looper;                                \
-    looper.start();                                                            \
-    while (looper.loop_condition()) {                                          \
-        looper.start_iteration();                                              \
-        try {                                                                  \
-            op;                                                                \
-            looper.successful_run();                                           \
-        } catch (test::lightweight::test_failure e) {                          \
-            looper.test_failure_caught(e);                                     \
-        } catch (test::lightweight::test_exception e) {                        \
-            looper.test_exception_caught(e);                                   \
-        } catch (...) {                                                        \
-            looper.unexpected_exception_caught();                              \
-        }                                                                      \
+  test::lightweight::exception_looper looper;                                  \
+  looper.start();                                                              \
+  while (looper.loop_condition()) {                                            \
+    looper.start_iteration();                                                  \
+    try {                                                                      \
+      op;                                                                      \
+      looper.successful_run();                                                 \
+    } catch (test::lightweight::test_failure e) {                              \
+      looper.test_failure_caught(e);                                           \
+    } catch (test::lightweight::test_exception e) {                            \
+      looper.test_exception_caught(e);                                         \
+    } catch (...) {                                                            \
+      looper.unexpected_exception_caught();                                    \
     }                                                                          \
-    looper.end();
-}
+  }                                                                            \
+  looper.end();
+  }
 }
 
 #endif
diff --git a/test/helpers/fwd.hpp b/test/helpers/fwd.hpp
index 29b2e8cc..a5657e01 100644
--- a/test/helpers/fwd.hpp
+++ b/test/helpers/fwd.hpp
@@ -9,24 +9,24 @@
 #include <string>
 
 namespace test {
-typedef enum {
+  typedef enum {
     default_generator,
     generate_collisions,
     limited_range
-} random_generator;
+  } 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);
+  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;
+  struct base_type
+  {
+  } base;
+  struct derived_type : base_type
+  {
+  } derived;
 }
 
 #endif
diff --git a/test/helpers/generators.hpp b/test/helpers/generators.hpp
index 8d5abaa5..c9ed42bd 100644
--- a/test/helpers/generators.hpp
+++ b/test/helpers/generators.hpp
@@ -19,45 +19,45 @@
 #include <utility>
 
 namespace test {
-struct seed_t
-{
+  struct seed_t
+  {
     seed_t(unsigned int x)
     {
-        using namespace std;
-        srand(x);
+      using namespace std;
+      srand(x);
     }
-};
+  };
 
-std::size_t random_value(std::size_t max)
-{
+  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)
-{
+  inline int generate(int const*, random_generator g)
+  {
     using namespace std;
     int value = rand();
     if (g == limited_range) {
-        value = value % 100;
+      value = value % 100;
     }
     return value;
-}
+  }
 
-inline char generate(char const*, random_generator)
-{
+  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)
-{
+  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)
-{
+  inline std::string generate(std::string const*, random_generator g)
+  {
     using namespace std;
 
     char* char_ptr = 0;
@@ -65,30 +65,29 @@ inline std::string generate(std::string const*, random_generator g)
     std::string result;
 
     if (g == limited_range) {
-        std::size_t length = test::random_value(2) + 2;
+      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]))];
-        }
+      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);
-        }
+      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)
-{
+  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 a1453fe5..5f816cfe 100644
--- a/test/helpers/helpers.hpp
+++ b/test/helpers/helpers.hpp
@@ -7,8 +7,8 @@
 #define BOOST_UNORDERED_TEST_HELPERS_HEADER
 
 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; }
@@ -16,38 +16,38 @@ template <class Container> struct get_key_impl
     template <class T>
     static key_type const& get_key(std::pair<key_type, T> const& x, char = 0)
     {
-        return x.first;
+      return x.first;
     }
 
     template <class T>
     static key_type const& get_key(
-        std::pair<key_type const, T> const& x, unsigned char = 0)
+      std::pair<key_type const, T> const& x, unsigned char = 0)
     {
-        return x.first;
+      return x.first;
     }
-};
+  };
 
-template <class Container, class T>
-inline BOOST_DEDUCED_TYPENAME Container::key_type const& get_key(T const& x)
-{
+  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.
+  // 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> Iterator next(Iterator it) { return ++it; }
 
-template <typename Iterator, typename IntType>
-Iterator next(Iterator it, IntType x)
-{
+  template <typename Iterator, typename IntType>
+  Iterator next(Iterator it, IntType x)
+  {
     for (; x > 0; --x) {
-        ++it;
+      ++it;
     }
     return it;
-}
+  }
 }
 
 #endif
diff --git a/test/helpers/input_iterator.hpp b/test/helpers/input_iterator.hpp
index 146ec7a4..18e6695d 100644
--- a/test/helpers/input_iterator.hpp
+++ b/test/helpers/input_iterator.hpp
@@ -11,8 +11,8 @@
 #include <iterator>
 
 namespace test {
-template <class Iterator> struct proxy
-{
+  template <class Iterator> struct proxy
+  {
     typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
 
     explicit proxy(value_type const& v) : v_(v) {}
@@ -23,18 +23,18 @@ template <class Iterator> struct proxy
 
   private:
     proxy& operator=(proxy const&);
-};
+  };
 
-template <class Iterator>
-struct input_iterator_adaptor
+  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> >
-{
+        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;
+      value_type;
 
     input_iterator_adaptor() : base_() {}
     explicit input_iterator_adaptor(Iterator& it) : base_(&it) {}
@@ -42,43 +42,43 @@ struct input_iterator_adaptor
     value_type* operator->() const { return &**base_; }
     input_iterator_adaptor& operator++()
     {
-        ++*base_;
-        return *this;
+      ++*base_;
+      return *this;
     }
     // input_iterator_adaptor operator++(int) {
     //}
     bool operator==(input_iterator_adaptor const& x) const
     {
-        return *base_ == *x.base_;
+      return *base_ == *x.base_;
     }
     bool operator!=(input_iterator_adaptor const& x) const
     {
-        return *base_ != *x.base_;
+      return *base_ != *x.base_;
     }
 
   private:
     Iterator* base_;
-};
+  };
 
-template <class Iterator>
-input_iterator_adaptor<Iterator> input_iterator(Iterator& 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
+  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> >
-{
+        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;
+      value_type;
     typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
-        difference_type;
+      difference_type;
 
     copy_iterator_adaptor() : base_() {}
     explicit copy_iterator_adaptor(Iterator const& it) : base_(it) {}
@@ -87,87 +87,87 @@ struct copy_iterator_adaptor
     value_type operator[](difference_type d) { return base_[d]; }
     copy_iterator_adaptor& operator++()
     {
-        ++base_;
-        return *this;
+      ++base_;
+      return *this;
     }
     copy_iterator_adaptor operator++(int)
     {
-        copy_iterator_adaptor tmp(*this);
-        ++base_;
-        return tmp;
+      copy_iterator_adaptor tmp(*this);
+      ++base_;
+      return tmp;
     }
     copy_iterator_adaptor& operator--()
     {
-        --base_;
-        return *this;
+      --base_;
+      return *this;
     }
     copy_iterator_adaptor operator--(int)
     {
-        copy_iterator_adaptor tmp(*this);
-        --base_;
-        return tmp;
+      copy_iterator_adaptor tmp(*this);
+      --base_;
+      return tmp;
     }
     copy_iterator_adaptor operator+=(difference_type x)
     {
-        base_ += x;
-        return *this;
+      base_ += x;
+      return *this;
     }
     copy_iterator_adaptor operator-=(difference_type x)
     {
-        base_ -= x;
-        return *this;
+      base_ -= x;
+      return *this;
     }
     copy_iterator_adaptor operator+(difference_type n)
     {
-        return copy_iterator_adaptor(base_ + n);
+      return copy_iterator_adaptor(base_ + n);
     }
     copy_iterator_adaptor operator-(difference_type n)
     {
-        return copy_iterator_adaptor(base_ - n);
+      return copy_iterator_adaptor(base_ - n);
     }
     friend copy_iterator_adaptor operator+(
-        difference_type n, copy_iterator_adaptor x)
+      difference_type n, copy_iterator_adaptor x)
     {
-        return x + n;
+      return x + n;
     }
     difference_type operator-(copy_iterator_adaptor const& other)
     {
-        return base_ - other.base_;
+      return base_ - other.base_;
     }
     bool operator==(copy_iterator_adaptor const& x) const
     {
-        return base_ == x.base_;
+      return base_ == x.base_;
     }
     bool operator!=(copy_iterator_adaptor const& x) const
     {
-        return base_ != x.base_;
+      return base_ != x.base_;
     }
     bool operator<(copy_iterator_adaptor const& x) const
     {
-        return base_ < x.base_;
+      return base_ < x.base_;
     }
     bool operator>(copy_iterator_adaptor const& x) const
     {
-        return base_ > x.base_;
+      return base_ > x.base_;
     }
     bool operator<=(copy_iterator_adaptor const& x) const
     {
-        return base_ <= x.base_;
+      return base_ <= x.base_;
     }
     bool operator>=(copy_iterator_adaptor const& x) const
     {
-        return base_ >= x.base_;
+      return base_ >= x.base_;
     }
 
   private:
     Iterator base_;
-};
+  };
 
-template <class Iterator>
-copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
-{
+  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 06091b94..8d47c1d0 100644
--- a/test/helpers/invariants.hpp
+++ b/test/helpers/invariants.hpp
@@ -22,8 +22,8 @@
 #endif
 
 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_;
@@ -31,79 +31,77 @@ template <class X> void check_equivalent_keys(X const& x1)
     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.");
+      // 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);
-
-        unsigned int count_checked = 0;
-        for (; lit != lend && !eq(get_key<X>(*lit), key); ++lit) {
-            ++count_checked;
-        }
-
-        if (lit == lend) {
-            BOOST_ERROR("Unable to find element with a local_iterator");
-            std::cerr << "Checked: " << count_checked << " elements"
-                      << std::endl;
-        } else {
-            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.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);
+
+      unsigned int count_checked = 0;
+      for (; lit != lend && !eq(get_key<X>(*lit), key); ++lit) {
+        ++count_checked;
+      }
+
+      if (lit == lend) {
+        BOOST_ERROR("Unable to find element with a local_iterator");
+        std::cerr << "Checked: " << count_checked << " elements" << std::endl;
+      } else {
+        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;
+      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());
+    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.");
+      BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
 
     // Check that size in the buckets matches up.
 
@@ -111,19 +109,18 @@ template <class X> void check_equivalent_keys(X const& x1)
 
     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;
-        }
+      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;
+      BOOST_ERROR("x1.size() doesn't match bucket size.");
+      std::cout << x1.size() << "/" << bucket_size << std::endl;
     }
-}
+  }
 }
 
 #if defined(BOOST_MSVC)
diff --git a/test/helpers/list.hpp b/test/helpers/list.hpp
index 3453706c..137cb17c 100644
--- a/test/helpers/list.hpp
+++ b/test/helpers/list.hpp
@@ -16,143 +16,143 @@
 #include <iterator>
 
 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;
+      if (*begin != *compare)
+        return false;
     return true;
-}
+  }
 
-template <typename It1, typename It2, typename Pred>
-bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
-{
+  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;
+      if (!predicate(*begin, *compare))
+        return false;
     return true;
-}
+  }
 
-template <typename T> class list;
+  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;
+  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()
+    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;
+          node* tmp = first_;
+          first_ = first_->next_;
+          delete tmp;
         }
-    }
+      }
 
-  private:
-    list_data(list_data const&);
-    list_data& operator=(list_data const&);
-};
+    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++()
+    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 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_; }
-};
+      }
+      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++()
+    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 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_; }
 
-    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
-{
+  template <typename T> class list
+  {
     typedef test::test_detail::list_data<T> data;
     typedef test::test_detail::list_node<T> node;
     data data_;
@@ -173,14 +173,14 @@ template <typename T> class list
     template <class InputIterator>
     list(InputIterator i, InputIterator j) : data_()
     {
-        insert(i, j);
+      insert(i, j);
     }
 
     list& operator=(list const& other)
     {
-        clear();
-        insert(other.begin(), other.end());
-        return *this;
+      clear();
+      insert(other.begin(), other.end());
+      return *this;
     }
 
     iterator begin() { return iterator(data_.first_); }
@@ -192,53 +192,53 @@ template <typename T> class list
 
     template <class InputIterator> void insert(InputIterator i, InputIterator j)
     {
-        for (; i != j; ++i)
-            push_back(*i);
+      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_;
+      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);
-        data_.last_ptr_ = &(*data_.last_ptr_)->next_;
-        ++data_.size_;
+      *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;
-        }
-        data_.last_ptr_ = &data_.first_;
+      while (data_.first_) {
+        node* tmp = data_.first_;
+        data_.first_ = data_.first_->next_;
+        --data_.size_;
+        delete tmp;
+      }
+      data_.last_ptr_ = &data_.first_;
     }
 
     void erase(const_iterator i, const_iterator j)
     {
-        node** ptr = &data_.first_;
+      node** ptr = &data_.first_;
 
-        while (*ptr != i.ptr_) {
-            ptr = &(*ptr)->next_;
-        }
+      while (*ptr != i.ptr_) {
+        ptr = &(*ptr)->next_;
+      }
 
-        while (*ptr != j.ptr_) {
-            node* to_delete = *ptr;
-            *ptr = (*ptr)->next_;
-            --data_.size_;
-            delete to_delete;
-        }
+      while (*ptr != j.ptr_) {
+        node* to_delete = *ptr;
+        *ptr = (*ptr)->next_;
+        --data_.size_;
+        delete to_delete;
+      }
 
-        if (!*ptr)
-            data_.last_ptr_ = ptr;
+      if (!*ptr)
+        data_.last_ptr_ = ptr;
     }
 
     bool empty() const { return !data_.size_; }
@@ -249,14 +249,14 @@ template <typename T> class list
 
     template <typename Less> void sort(Less less = Less())
     {
-        if (!empty())
-            merge_sort(
-                &data_.first_, (std::numeric_limits<size_type>::max)(), 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());
+      return size() == y.size() && test::equal(begin(), end(), y.begin());
     }
 
     bool operator!=(list const& y) const { return !(*this == y); }
@@ -265,56 +265,55 @@ template <typename T> class list
     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;
+      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)
+      node** first, node** second, node** third, Less less)
     {
+      for (;;) {
         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_;
+          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;
+      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 2f910676..22946cc2 100644
--- a/test/helpers/memory.hpp
+++ b/test/helpers/memory.hpp
@@ -13,177 +13,177 @@
 #include <memory>
 
 namespace test {
-namespace detail {
-struct memory_area
-{
-    void const* start;
-    void const* end;
-
-    memory_area(void const* s, void const* e) : start(s), end(e)
+  namespace detail {
+    struct memory_area
     {
+      void const* start;
+      void const* 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) {}
-
-    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.
-
-struct memory_area_compare
-{
-    bool operator()(memory_area const& x, memory_area const& y) const
+    struct memory_track
     {
-        return x.end <= y.start;
-    }
-};
+      explicit memory_track(int tag = -1) : constructed_(0), tag_(tag) {}
 
-struct memory_tracker
-{
-    typedef std::map<memory_area, memory_track, memory_area_compare,
+      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.
+
+    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;
 
-    allocated_memory_type allocated_memory;
-    unsigned int count_allocators;
-    unsigned int count_allocations;
-    unsigned int count_constructions;
-    bool tracking_constructions;
+      allocated_memory_type allocated_memory;
+      unsigned int count_allocators;
+      unsigned int count_allocations;
+      unsigned int count_constructions;
+      bool tracking_constructions;
 
-    memory_tracker()
-        : count_allocators(0), count_allocations(0), count_constructions(0),
-          tracking_constructions(true)
-    {
-    }
+      memory_tracker()
+          : count_allocators(0), count_allocations(0), count_constructions(0),
+            tracking_constructions(true)
+      {
+      }
 
-    ~memory_tracker() { BOOST_TEST(count_allocators == 0); }
+      ~memory_tracker() { BOOST_TEST(count_allocators == 0); }
 
-    void allocator_ref()
-    {
+      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);
+          }
         }
-        ++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)
-    {
+      void track_allocate(void* ptr, std::size_t n, std::size_t size, int tag)
+      {
         if (n == 0) {
-            BOOST_ERROR("Allocating 0 length array.");
+          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)));
+          ++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,
+      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));
+          allocated_memory.find(memory_area(ptr, (char*)ptr + n * size));
         if (pos == allocated_memory.end()) {
-            BOOST_ERROR("Deallocating unknown pointer.");
+          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(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;
-    }
+          --count_allocations;
+      }
 
-    void track_construct(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
-    {
+      void track_construct(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+      {
         if (tracking_constructions) {
-            ++count_constructions;
+          ++count_constructions;
         }
-    }
+      }
 
-    void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
-    {
+      void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+      {
         if (tracking_constructions) {
-            BOOST_TEST(count_constructions > 0);
-            if (count_constructions > 0)
-                --count_constructions;
+          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;
     }
-};
-}
+  }
 
-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;
-}
-}
-
-namespace detail {
-struct disable_construction_tracking
-{
-    bool old_value;
-
-    disable_construction_tracking()
-        : old_value(detail::tracker.tracking_constructions)
+  namespace detail {
+    struct disable_construction_tracking
     {
+      bool old_value;
+
+      disable_construction_tracking()
+          : old_value(detail::tracker.tracking_constructions)
+      {
         test::detail::tracker.tracking_constructions = false;
-    }
+      }
 
-    ~disable_construction_tracking()
-    {
+      ~disable_construction_tracking()
+      {
         test::detail::tracker.tracking_constructions = old_value;
-    }
+      }
 
-  private:
-    disable_construction_tracking(disable_construction_tracking const&);
-    disable_construction_tracking& operator=(
+    private:
+      disable_construction_tracking(disable_construction_tracking const&);
+      disable_construction_tracking& operator=(
         disable_construction_tracking const&);
-};
-}
+    };
+  }
 }
 
 #endif
diff --git a/test/helpers/metafunctions.hpp b/test/helpers/metafunctions.hpp
index c7e2a26a..0442920e 100644
--- a/test/helpers/metafunctions.hpp
+++ b/test/helpers/metafunctions.hpp
@@ -10,25 +10,25 @@
 #include <boost/type_traits/is_same.hpp>
 
 namespace test {
-template <class Container>
-struct is_set
+  template <class Container>
+  struct is_set
     : public boost::is_same<BOOST_DEDUCED_TYPENAME Container::key_type,
-          BOOST_DEDUCED_TYPENAME Container::value_type>
-{
-};
+        BOOST_DEDUCED_TYPENAME Container::value_type>
+  {
+  };
 
-template <class Container> struct has_unique_keys
-{
+  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&);
+      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))));
-};
+      value = sizeof(long) ==
+              sizeof(
+                flip(((Container*)0)
+                       ->insert(
+                         *(BOOST_DEDUCED_TYPENAME Container::value_type*)0))));
+  };
 }
 
 #endif
diff --git a/test/helpers/random_values.hpp b/test/helpers/random_values.hpp
index 65772dba..912b8be0 100644
--- a/test/helpers/random_values.hpp
+++ b/test/helpers/random_values.hpp
@@ -13,8 +13,8 @@
 #include <boost/detail/select_type.hpp>
 
 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_;
@@ -23,24 +23,24 @@ template <class X> struct unordered_generator_set
 
     template <class T> void fill(T& x, std::size_t len)
     {
-        value_type* value_ptr = 0;
-        len += x.size();
+      value_type* value_ptr = 0;
+      len += x.size();
 
-        for (std::size_t i = 0; i < len; ++i) {
-            value_type value = generate(value_ptr, type_);
+      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;
+        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;
 
@@ -50,60 +50,60 @@ template <class X> struct unordered_generator_map
 
     template <class T> void fill(T& x, std::size_t len)
     {
-        key_type* key_ptr = 0;
-        mapped_type* mapped_ptr = 0;
+      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_);
+      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;
+        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
+  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> >
-{
-};
+        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
-{
+  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 random_values : public test::list<BOOST_DEDUCED_TYPENAME X::value_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)
+      test::random_generator const& generator = test::default_generator)
     {
-        fill(count, generator);
+      fill(count, generator);
     }
 
     void fill(std::size_t count,
-        test::random_generator const& generator = test::default_generator)
+      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 0fc3d58c..040c18b4 100644
--- a/test/helpers/strong.hpp
+++ b/test/helpers/strong.hpp
@@ -13,8 +13,8 @@
 #include <iterator>
 
 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_;
@@ -22,22 +22,21 @@ template <class X> class strong
   public:
     void store(X const& x, unsigned int allocations = 0)
     {
-        DISABLE_EXCEPTIONS;
-        values_.clear();
-        values_.insert(x.cbegin(), x.cend());
-        allocations_ = allocations;
+      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.");
+      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 eaaa83f1..5bce54fe 100644
--- a/test/helpers/test.hpp
+++ b/test/helpers/test.hpp
@@ -11,53 +11,53 @@
 #include <boost/preprocessor/stringize.hpp>
 
 #define UNORDERED_AUTO_TEST(x)                                                 \
-    struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base        \
+  struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base          \
+  {                                                                            \
+    BOOST_PP_CAT(x, _type)                                                     \
+    () : ::test::registered_test_base(BOOST_PP_STRINGIZE(x))                   \
     {                                                                          \
-        BOOST_PP_CAT(x, _type)                                                 \
-        () : ::test::registered_test_base(BOOST_PP_STRINGIZE(x))               \
-        {                                                                      \
-            ::test::get_state().add_test(this);                                \
-        }                                                                      \
-        void run();                                                            \
-    };                                                                         \
-    BOOST_PP_CAT(x, _type) x;                                                  \
-    void BOOST_PP_CAT(x, _type)::run()
+      ::test::get_state().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**)                                                      \
-    {                                                                          \
-        BOOST_UNORDERED_TEST_COMPILER_INFO()                                   \
-        ::test::get_state().run_tests();                                       \
-        return boost::report_errors();                                         \
-    }
+  int main(int, char**)                                                        \
+  {                                                                            \
+    BOOST_UNORDERED_TEST_COMPILER_INFO()                                       \
+    ::test::get_state().run_tests();                                           \
+    return boost::report_errors();                                             \
+  }
 
 #define RUN_TESTS_QUIET()                                                      \
-    int main(int, char**)                                                      \
-    {                                                                          \
-        BOOST_UNORDERED_TEST_COMPILER_INFO()                                   \
-        ::test::get_state().run_tests(true);                                   \
-        return boost::report_errors();                                         \
-    }
+  int main(int, char**)                                                        \
+  {                                                                            \
+    BOOST_UNORDERED_TEST_COMPILER_INFO()                                       \
+    ::test::get_state().run_tests(true);                                       \
+    return boost::report_errors();                                             \
+  }
 
 #define UNORDERED_SUB_TEST(x)                                                  \
-    for (int UNORDERED_SUB_TEST_VALUE = ::test::get_state().start_sub_test(x); \
-         UNORDERED_SUB_TEST_VALUE;                                             \
-         UNORDERED_SUB_TEST_VALUE =                                            \
-             ::test::get_state().end_sub_test(x, UNORDERED_SUB_TEST_VALUE))
+  for (int UNORDERED_SUB_TEST_VALUE = ::test::get_state().start_sub_test(x);   \
+       UNORDERED_SUB_TEST_VALUE;                                               \
+       UNORDERED_SUB_TEST_VALUE =                                              \
+         ::test::get_state().end_sub_test(x, UNORDERED_SUB_TEST_VALUE))
 
 namespace test {
 
-struct 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() {}
-};
+  };
 
-struct state
-{
+  struct state
+  {
     bool is_quiet;
     registered_test_base* first_test;
     registered_test_base* last_test;
@@ -66,61 +66,59 @@ struct state
 
     void add_test(registered_test_base* test)
     {
-        if (last_test) {
-            last_test->next = test;
-        } else {
-            first_test = test;
-        }
-        last_test = test;
+      if (last_test) {
+        last_test->next = test;
+      } else {
+        first_test = test;
+      }
+      last_test = test;
     }
 
     void run_tests(bool quiet = false)
     {
-        is_quiet = quiet;
+      is_quiet = quiet;
 
-        for (registered_test_base* i = first_test; i; i = i->next) {
-            int error_count = boost::detail::test_errors();
-            if (!quiet) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Running " << i->name << "\n"
-                                               << std::flush;
-            }
-            i->run();
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM << std::flush;
-            if (quiet && error_count != boost::detail::test_errors()) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in: " << i->name
-                                               << "\n"
-                                               << std::flush;
-            }
+      for (registered_test_base* i = first_test; i; i = i->next) {
+        int error_count = boost::detail::test_errors();
+        if (!quiet) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Running " << i->name << "\n"
+                                         << std::flush;
         }
+        i->run();
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << std::flush;
+        if (quiet && error_count != boost::detail::test_errors()) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in: " << i->name << "\n"
+                                         << std::flush;
+        }
+      }
     }
 
     int start_sub_test(char const* name)
     {
-        if (!is_quiet) {
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Sub-test: " << name << "\n"
-                                           << std::flush;
-        }
-        // Add one because it's used as a loop condition.
-        return boost::detail::test_errors() + 1;
+      if (!is_quiet) {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Sub-test: " << name << "\n"
+                                       << std::flush;
+      }
+      // Add one because it's used as a loop condition.
+      return boost::detail::test_errors() + 1;
     }
 
     int end_sub_test(char const* name, int value)
     {
-        if (is_quiet && value != boost::detail::test_errors() + 1) {
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in sub-test: " << name
-                                           << "\n"
-                                           << std::flush;
-        }
-        return 0;
+      if (is_quiet && value != boost::detail::test_errors() + 1) {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in sub-test: " << name << "\n"
+                                       << std::flush;
+      }
+      return 0;
     }
-};
+  };
 
-// Get the currnet translation unit's test state.
-static inline state& get_state()
-{
+  // Get the currnet translation unit's test state.
+  static inline state& get_state()
+  {
     static state instance;
     return instance;
-}
+  }
 }
 
 #if defined(__cplusplus)
@@ -130,21 +128,21 @@ static inline state& get_state()
 #endif
 
 #define BOOST_UNORDERED_TEST_COMPILER_INFO()                                   \
-    {                                                                          \
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
-            << "Compiler: " << BOOST_COMPILER << "\n"                          \
-            << "Library: " << BOOST_STDLIB << "\n"                             \
-            << "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n"          \
-            << "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: "                    \
-            << BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n"                \
-            << "BOOST_UNORDERED_EMPLACE_LIMIT: "                               \
-            << BOOST_UNORDERED_EMPLACE_LIMIT << "\n"                           \
-            << "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: "                        \
-            << BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n"                    \
-            << "BOOST_UNORDERED_CXX11_CONSTRUCTION: "                          \
-            << BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n"                    \
-            << std::flush;                                                     \
-    }
+  {                                                                            \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "Compiler: " << BOOST_COMPILER << "\n"                                \
+      << "Library: " << BOOST_STDLIB << "\n"                                   \
+      << "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n"                \
+      << "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: "                          \
+      << BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n"                      \
+      << "BOOST_UNORDERED_EMPLACE_LIMIT: " << BOOST_UNORDERED_EMPLACE_LIMIT    \
+      << "\n"                                                                  \
+      << "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: "                              \
+      << BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n"                          \
+      << "BOOST_UNORDERED_CXX11_CONSTRUCTION: "                                \
+      << BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n"                          \
+      << std::flush;                                                           \
+  }
 
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/seq/fold_left.hpp>
@@ -154,52 +152,52 @@ static inline state& get_state()
 
 // 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)
+  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)
+  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)))
+  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);                                \
-    }
+  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))
+  BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))
 
 #define UNORDERED_MULTI_TEST(name, impl, parameters)                           \
-    UNORDERED_MULTI_TEST_REPEAT(name, impl, 1, parameters)
+  UNORDERED_MULTI_TEST_REPEAT(name, impl, 1, parameters)
 
 #define UNORDERED_MULTI_TEST_REPEAT(name, impl, n, parameters)                 \
-    UNORDERED_AUTO_TEST(name)                                                  \
-    {                                                                          \
-        BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                         \
-            UNORDERED_MULTI_TEST_OP, ((impl))((n))parameters)                  \
-    }
+  UNORDERED_AUTO_TEST(name)                                                    \
+  {                                                                            \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                             \
+      UNORDERED_MULTI_TEST_OP, ((impl))((n))parameters)                        \
+  }
 
 #define UNORDERED_MULTI_TEST_OP(r, product)                                    \
-    UNORDERED_MULTI_TEST_OP2(BOOST_PP_SEQ_ELEM(0, product),                    \
-        BOOST_PP_SEQ_ELEM(1, product),                                         \
-        BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))
+  UNORDERED_MULTI_TEST_OP2(BOOST_PP_SEQ_ELEM(0, product),                      \
+    BOOST_PP_SEQ_ELEM(1, product),                                             \
+    BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))
 
 // Need to wrap UNORDERED_SUB_TEST in a block to avoid an msvc bug.
 // https://support.microsoft.com/en-gb/help/315481/bug-too-many-unnested-loops-incorrectly-causes-a-c1061-compiler-error-in-visual-c
 #define UNORDERED_MULTI_TEST_OP2(name, n, params)                              \
+  {                                                                            \
+    UNORDERED_SUB_TEST(BOOST_PP_STRINGIZE(                                     \
+      BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)))           \
     {                                                                          \
-        UNORDERED_SUB_TEST(BOOST_PP_STRINGIZE(                                 \
-            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);                            \
-        }                                                                      \
-    }
+      for (int i = 0; i < n; ++i)                                              \
+        name BOOST_PP_SEQ_TO_TUPLE(params);                                    \
+    }                                                                          \
+  }
 
 #endif
diff --git a/test/helpers/tracker.hpp b/test/helpers/tracker.hpp
index 0ea17a25..f385cd8a 100644
--- a/test/helpers/tracker.hpp
+++ b/test/helpers/tracker.hpp
@@ -20,18 +20,18 @@
 #include <set>
 
 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;
-};
+  };
 
-template <> struct equals_to_compare<test::equal_to>
-{
+  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());
@@ -39,61 +39,61 @@ template <class X1, class X2> void compare_range(X1 const& x1, X2 const& x2)
     values2.sort();
     BOOST_TEST(values1.size() == values2.size() &&
                test::equal(values1.begin(), values1.end(), values2.begin(),
-                   test::equivalent));
-}
+                 test::equivalent));
+  }
 
-template <class X1, class X2, class T>
-void compare_pairs(X1 const& x1, X2 const& x2, T*)
-{
+  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));
-}
+                 test::equivalent));
+  }
 
-template <typename X, bool is_set = test::is_set<X>::value,
+  template <typename X, bool is_set = test::is_set<X>::value,
     bool has_unique_keys = test::has_unique_keys<X>::value>
-struct ordered_base;
+  struct ordered_base;
 
-template <typename X> struct ordered_base<X, true, true>
-{
+  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;
-};
+      BOOST_DEDUCED_TYPENAME
+        equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
+      type;
+  };
 
-template <typename X> struct ordered_base<X, true, false>
-{
+  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;
-};
+      BOOST_DEDUCED_TYPENAME
+        equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
+      type;
+  };
 
-template <typename X> struct ordered_base<X, false, true>
-{
+  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;
-};
+      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>
-{
+  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;
-};
+      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
-{
+  template <class X> class ordered : public ordered_base<X>::type
+  {
     typedef BOOST_DEDUCED_TYPENAME ordered_base<X>::type base;
 
   public:
@@ -106,42 +106,42 @@ template <class X> class ordered : public ordered_base<X>::type
     void compare(X const& x) { compare_range(x, *this); }
 
     void compare_key(
-        X const& x, BOOST_DEDUCED_TYPENAME X::value_type const& val)
+      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);
+      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;
-        }
+      while (b != e) {
+        this->insert(*b);
+        ++b;
+      }
     }
-};
+  };
 
-template <class Equals>
-BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type create_compare(
+  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)
-{
+  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)
-{
+  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 4694438c..e96f8d94 100644
--- a/test/objects/cxx11_allocator.hpp
+++ b/test/objects/cxx11_allocator.hpp
@@ -14,141 +14,141 @@
 #include "../helpers/memory.hpp"
 
 namespace test {
-struct allocator_false
-{
+  struct allocator_false
+  {
     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
-{
+  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
+      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
-{
+  struct select_copy : allocator_false
+  {
     enum
     {
-        is_select_on_copy = 1
+      is_select_on_copy = 1
     };
-};
-struct propagate_swap : allocator_false
-{
+  };
+  struct propagate_swap : allocator_false
+  {
     enum
     {
-        is_propagate_on_swap = 1
+      is_propagate_on_swap = 1
     };
-};
-struct propagate_assign : allocator_false
-{
+  };
+  struct propagate_assign : allocator_false
+  {
     enum
     {
-        is_propagate_on_assign = 1
+      is_propagate_on_assign = 1
     };
-};
-struct propagate_move : allocator_false
-{
+  };
+  struct propagate_move : allocator_false
+  {
     enum
     {
-        is_propagate_on_move = 1
+      is_propagate_on_move = 1
     };
-};
+  };
 
-struct no_select_copy : allocator_flags_all
-{
+  struct no_select_copy : allocator_flags_all
+  {
     enum
     {
-        is_select_on_copy = 0
+      is_select_on_copy = 0
     };
-};
-struct no_propagate_swap : allocator_flags_all
-{
+  };
+  struct no_propagate_swap : allocator_flags_all
+  {
     enum
     {
-        is_propagate_on_swap = 0
+      is_propagate_on_swap = 0
     };
-};
-struct no_propagate_assign : allocator_flags_all
-{
+  };
+  struct no_propagate_assign : allocator_flags_all
+  {
     enum
     {
-        is_propagate_on_assign = 0
+      is_propagate_on_assign = 0
     };
-};
-struct no_propagate_move : allocator_flags_all
-{
+  };
+  struct no_propagate_move : allocator_flags_all
+  {
     enum
     {
-        is_propagate_on_move = 0
+      is_propagate_on_move = 0
     };
-};
+  };
 
-template <typename Flag> struct swap_allocator_base
-{
+  template <typename Flag> struct swap_allocator_base
+  {
     struct propagate_on_container_swap
     {
-        enum
-        {
-            value = Flag::is_propagate_on_swap
-        };
+      enum
+      {
+        value = Flag::is_propagate_on_swap
+      };
     };
-};
+  };
 
-template <typename Flag> struct assign_allocator_base
-{
+  template <typename Flag> struct assign_allocator_base
+  {
     struct propagate_on_container_copy_assignment
     {
-        enum
-        {
-            value = Flag::is_propagate_on_assign
-        };
+      enum
+      {
+        value = Flag::is_propagate_on_assign
+      };
     };
-};
+  };
 
-template <typename Flag> struct move_allocator_base
-{
+  template <typename Flag> struct move_allocator_base
+  {
     struct propagate_on_container_move_assignment
     {
-        enum
-        {
-            value = Flag::is_propagate_on_move
-        };
+      enum
+      {
+        value = Flag::is_propagate_on_move
+      };
     };
-};
+  };
 
-namespace {
-// boostinspect:nounnamed
-bool force_equal_allocator_value = false;
-}
+  namespace {
+    // boostinspect:nounnamed
+    bool force_equal_allocator_value = false;
+  }
 
-struct force_equal_allocator
-{
+  struct force_equal_allocator
+  {
     bool old_value_;
 
     explicit force_equal_allocator(bool value)
         : old_value_(force_equal_allocator_value)
     {
-        force_equal_allocator_value = value;
+      force_equal_allocator_value = value;
     }
 
     ~force_equal_allocator() { force_equal_allocator_value = old_value_; }
-};
+  };
 
-template <typename T> struct cxx11_allocator_base
-{
+  template <typename T> struct cxx11_allocator_base
+  {
     int tag_;
     int selected_;
 
@@ -162,20 +162,20 @@ template <typename T> struct cxx11_allocator_base
 
     explicit cxx11_allocator_base(int t) : tag_(t), selected_(0)
     {
-        detail::tracker.allocator_ref();
+      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();
+      detail::tracker.allocator_ref();
     }
 
     cxx11_allocator_base(cxx11_allocator_base const& x)
         : tag_(x.tag_), selected_(x.selected_)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     ~cxx11_allocator_base() { detail::tracker.allocator_unref(); }
@@ -186,71 +186,71 @@ template <typename T> struct cxx11_allocator_base
 
     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;
+      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, 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 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);
+      // 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);
+      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)...);
+      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();
+      detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+      p->~T();
     }
 
     size_type max_size() const
     {
-        return (std::numeric_limits<size_type>::max)();
+      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 = propagate_swap, typename Enable = void>
+  struct cxx11_allocator;
 
-template <typename T, typename Flags>
-struct cxx11_allocator<T, Flags,
+  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;
+      typedef cxx11_allocator<U, Flags> other;
     };
 #endif
 
@@ -268,32 +268,32 @@ struct cxx11_allocator<T, Flags,
     // to avoid undefined behaviour.
     bool operator==(cxx11_allocator const& x) const
     {
-        return force_equal_allocator_value || (this->tag_ == x.tag_);
+      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,
+  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;
+      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;
+      typedef cxx11_allocator<U, Flags> other;
     };
 #endif
 
@@ -311,34 +311,34 @@ struct cxx11_allocator<T, Flags,
     // to avoid undefined behaviour.
     bool operator==(cxx11_allocator const& x) const
     {
-        return force_equal_allocator_value || (this->tag_ == x.tag_);
+      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,
+  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.
+  // Function to check how many times an allocator has been selected,
+  // return 0 for other allocators.
 
-struct convert_from_anything
-{
+  struct convert_from_anything
+  {
     template <typename T> convert_from_anything(T const&) {}
-};
+  };
 
-inline int selected_count(convert_from_anything) { return 0; }
+  inline int selected_count(convert_from_anything) { return 0; }
 
-template <typename T, typename Flags>
-int selected_count(cxx11_allocator<T, Flags> const& x)
-{
+  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 d0286797..07f343fb 100644
--- a/test/objects/exception.hpp
+++ b/test/objects/exception.hpp
@@ -18,735 +18,734 @@
 #include <new>
 
 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);
+  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
-{
-    enum
+    struct true_type
     {
+      enum
+      {
         value = true
+      };
     };
-};
 
-struct false_type
-{
-    enum
+    struct false_type
     {
+      enum
+      {
         value = false
+      };
     };
-};
 
-class object : private counted_object
-{
-  public:
-    int tag1_, tag2_;
-
-    explicit object() : tag1_(0), tag2_(0)
+    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.");
+          UNORDERED_EPOINT("Mock object default constructor.");
         }
-    }
+      }
 
-    explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
-    {
+      explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
+      {
         UNORDERED_SCOPE(object::object(int))
         {
-            UNORDERED_EPOINT("Mock object constructor by value.");
+          UNORDERED_EPOINT("Mock object constructor by value.");
         }
-    }
+      }
 
-    object(object const& x) : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
-    {
+      object(object const& x)
+          : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+      {
         UNORDERED_SCOPE(object::object(object))
         {
-            UNORDERED_EPOINT("Mock object copy constructor.");
+          UNORDERED_EPOINT("Mock object copy constructor.");
         }
-    }
+      }
 
-    ~object()
-    {
+      ~object()
+      {
         tag1_ = -1;
         tag2_ = -1;
-    }
+      }
 
-    object& operator=(object const& x)
-    {
+      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.");
+          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)
-    {
+      friend bool operator==(object const& x1, object const& x2)
+      {
         UNORDERED_SCOPE(operator==(object, object))
         {
-            UNORDERED_EPOINT("Mock object equality operator.");
+          UNORDERED_EPOINT("Mock object equality operator.");
         }
 
         return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
-    }
+      }
 
-    friend bool operator!=(object const& x1, object const& x2)
-    {
+      friend bool operator!=(object const& x1, object const& x2)
+      {
         UNORDERED_SCOPE(operator!=(object, object))
         {
-            UNORDERED_EPOINT("Mock object inequality operator.");
+          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)
-    {
+      // 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)
-    {
+      friend object generate(object const*, random_generator g)
+      {
         int* x = 0;
         return object(::test::generate(x, g), ::test::generate(x, g));
-    }
+      }
 
-    friend std::ostream& operator<<(std::ostream& out, object const& o)
-    {
+      friend std::ostream& operator<<(std::ostream& out, object const& o)
+      {
         return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
-    }
-};
+      }
+    };
 
-std::pair<object, object> generate(
-    std::pair<object, object> const*, random_generator g)
-{
-    int* x = 0;
-    return std::make_pair(
+    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)));
-}
+    }
 
-class hash
-{
-    int tag_;
-
-  public:
-    hash(int t = 0) : tag_(t)
+    class hash
     {
+      int tag_;
+
+    public:
+      hash(int t = 0) : tag_(t)
+      {
         UNORDERED_SCOPE(hash::object())
         {
-            UNORDERED_EPOINT("Mock hash default constructor.");
+          UNORDERED_EPOINT("Mock hash default constructor.");
         }
-    }
+      }
 
-    hash(hash const& x) : tag_(x.tag_)
-    {
+      hash(hash const& x) : tag_(x.tag_)
+      {
         UNORDERED_SCOPE(hash::hash(hash))
         {
-            UNORDERED_EPOINT("Mock hash copy constructor.");
+          UNORDERED_EPOINT("Mock hash copy constructor.");
         }
-    }
+      }
 
-    hash& operator=(hash const& x)
-    {
+      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.");
+          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
-    {
+      std::size_t operator()(object const& x) const
+      {
         UNORDERED_SCOPE(hash::operator()(object))
         {
-            UNORDERED_EPOINT("Mock hash function.");
+          UNORDERED_EPOINT("Mock hash function.");
         }
 
         return hash_impl(x);
-    }
+      }
 
-    std::size_t operator()(std::pair<object, object> const& x) const
-    {
+      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.");
+          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
-    {
+      std::size_t hash_impl(object const& x) const
+      {
         int result;
         switch (tag_) {
         case 1:
-            result = x.tag1_;
-            break;
+          result = x.tag1_;
+          break;
         case 2:
-            result = x.tag2_;
-            break;
+          result = x.tag2_;
+          break;
         default:
-            result = x.tag1_ + x.tag2_;
+          result = x.tag1_ + x.tag2_;
         }
         return static_cast<std::size_t>(result);
-    }
+      }
 
-    friend bool operator==(hash const& x1, hash const& x2)
-    {
+      friend bool operator==(hash const& x1, hash const& x2)
+      {
         UNORDERED_SCOPE(operator==(hash, hash))
         {
-            UNORDERED_EPOINT("Mock hash equality function.");
+          UNORDERED_EPOINT("Mock hash equality function.");
         }
         return x1.tag_ == x2.tag_;
-    }
+      }
 
-    friend bool operator!=(hash const& x1, hash const& x2)
-    {
+      friend bool operator!=(hash const& x1, hash const& x2)
+      {
         UNORDERED_SCOPE(hash::operator!=(hash, hash))
         {
-            UNORDERED_EPOINT("Mock hash inequality function.");
+          UNORDERED_EPOINT("Mock hash inequality function.");
         }
         return x1.tag_ != x2.tag_;
-    }
-};
+      }
+    };
 
-class less
-{
-    int tag_;
-
-  public:
-    less(int t = 0) : tag_(t) {}
-
-    less(less const& x) : tag_(x.tag_) {}
-
-    bool operator()(object const& x1, object const& x2) const
+    class less
     {
+      int tag_;
+
+    public:
+      less(int t = 0) : tag_(t) {}
+
+      less(less const& x) : tag_(x.tag_) {}
+
+      bool operator()(object const& x1, object const& x2) const
+      {
         return less_impl(x1, x2);
-    }
+      }
 
-    bool operator()(std::pair<object, object> const& x1,
+      bool operator()(std::pair<object, object> const& x1,
         std::pair<object, object> const& x2) const
-    {
+      {
         if (less_impl(x1.first, x2.first)) {
-            return true;
+          return true;
         }
         if (!less_impl(x1.first, x2.first)) {
-            return false;
+          return false;
         }
         return less_impl(x1.second, x2.second);
-    }
+      }
 
-    bool less_impl(object const& x1, object const& x2) const
-    {
+      bool less_impl(object const& x1, object const& x2) const
+      {
         switch (tag_) {
         case 1:
-            return x1.tag1_ < x2.tag1_;
+          return x1.tag1_ < x2.tag1_;
         case 2:
-            return x1.tag2_ < x2.tag2_;
+          return x1.tag2_ < x2.tag2_;
         default:
-            return x1 < x2;
+          return x1 < x2;
         }
-    }
+      }
 
-    friend bool operator==(less const& x1, less const& x2)
-    {
+      friend bool operator==(less const& x1, less const& x2)
+      {
         return x1.tag_ == x2.tag_;
-    }
+      }
 
-    friend bool operator!=(less const& x1, less const& x2)
-    {
+      friend bool operator!=(less const& x1, less const& x2)
+      {
         return x1.tag_ != x2.tag_;
-    }
-};
+      }
+    };
 
-class equal_to
-{
-    int tag_;
-
-  public:
-    equal_to(int t = 0) : tag_(t)
+    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.");
+          UNORDERED_EPOINT("Mock equal_to default constructor.");
         }
-    }
+      }
 
-    equal_to(equal_to const& x) : tag_(x.tag_)
-    {
+      equal_to(equal_to const& x) : tag_(x.tag_)
+      {
         UNORDERED_SCOPE(equal_to::equal_to(equal_to))
         {
-            UNORDERED_EPOINT("Mock equal_to copy constructor.");
+          UNORDERED_EPOINT("Mock equal_to copy constructor.");
         }
-    }
+      }
 
-    equal_to& operator=(equal_to const& x)
-    {
+      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.");
+          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
-    {
+      bool operator()(object const& x1, object const& x2) const
+      {
         UNORDERED_SCOPE(equal_to::operator()(object, object))
         {
-            UNORDERED_EPOINT("Mock equal_to function.");
+          UNORDERED_EPOINT("Mock equal_to function.");
         }
 
         return equal_impl(x1, x2);
-    }
+      }
 
-    bool operator()(std::pair<object, object> const& x1,
+      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>))
+          std::pair<object, object>, std::pair<object, object>))
         {
-            UNORDERED_EPOINT("Mock equal_to function.");
+          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
-    {
+      bool equal_impl(object const& x1, object const& x2) const
+      {
         switch (tag_) {
         case 1:
-            return x1.tag1_ == x2.tag1_;
+          return x1.tag1_ == x2.tag1_;
         case 2:
-            return x1.tag2_ == x2.tag2_;
+          return x1.tag2_ == x2.tag2_;
         default:
-            return x1 == x2;
+          return x1 == x2;
         }
-    }
+      }
 
-    friend bool operator==(equal_to const& x1, equal_to const& 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.");
+          UNORDERED_EPOINT("Mock equal_to equality function.");
         }
         return x1.tag_ == x2.tag_;
-    }
+      }
 
-    friend bool operator!=(equal_to const& x1, equal_to const& x2)
-    {
+      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.");
+          UNORDERED_EPOINT("Mock equal_to inequality function.");
         }
         return x1.tag_ != x2.tag_;
-    }
+      }
 
-    friend less create_compare(equal_to x) { return less(x.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;
+      friend less create_compare(equal_to x) { return less(x.tag_); }
     };
 
-    explicit allocator(int t = 0) : tag_(t)
+    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;
+      };
+
+      explicit allocator(int t = 0) : tag_(t)
+      {
         UNORDERED_SCOPE(allocator::allocator())
         {
-            UNORDERED_EPOINT("Mock allocator default constructor.");
+          UNORDERED_EPOINT("Mock allocator default constructor.");
         }
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
-    {
+      template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
+      {
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    allocator(allocator const& x) : tag_(x.tag_)
-    {
+      allocator(allocator const& x) : tag_(x.tag_)
+      {
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    ~allocator() { test::detail::tracker.allocator_unref(); }
+      ~allocator() { test::detail::tracker.allocator_unref(); }
 
-    allocator& operator=(allocator const& x)
-    {
+      allocator& operator=(allocator const& x)
+      {
         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.
+      // 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)
-    {
+      pointer address(reference r)
+      {
         // UNORDERED_SCOPE(allocator::address(reference)) {
         //    UNORDERED_EPOINT("Mock allocator address function.");
         //}
         return pointer(&r);
-    }
+      }
 
-    const_pointer address(const_reference 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)
-    {
+      pointer allocate(size_type n)
+      {
         T* ptr = 0;
         UNORDERED_SCOPE(allocator::allocate(size_type))
         {
-            UNORDERED_EPOINT("Mock allocator allocate function.");
+          UNORDERED_EPOINT("Mock allocator allocate function.");
 
-            using namespace std;
-            ptr = (T*)malloc(n * sizeof(T));
-            if (!ptr)
-                throw std::bad_alloc();
+          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*)
-    {
+      pointer allocate(size_type n, void const*)
+      {
         T* ptr = 0;
         UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer))
         {
-            UNORDERED_EPOINT("Mock allocator allocate function.");
+          UNORDERED_EPOINT("Mock allocator allocate function.");
 
-            using namespace std;
-            ptr = (T*)malloc(n * sizeof(T));
-            if (!ptr)
-                throw std::bad_alloc();
+          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)
-    {
+      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);
+          test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+          using namespace std;
+          free(p);
         }
-    }
+      }
 
-    void construct(pointer p, T const& t)
-    {
+      void construct(pointer p, T const& t)
+      {
         UNORDERED_SCOPE(allocator::construct(T*, T))
         {
-            UNORDERED_EPOINT("Mock allocator construct function.");
-            new (p) T(t);
+          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)
-    {
+      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)...);
+          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)
-    {
+      void destroy(T* p)
+      {
         test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
         p->~T();
-    }
+      }
 
-    size_type max_size() const
-    {
+      size_type max_size() const
+      {
         UNORDERED_SCOPE(allocator::construct(pointer, T))
         {
-            UNORDERED_EPOINT("Mock allocator max_size function.");
+          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;
-};
-
-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;
+      typedef true_type propagate_on_container_copy_assignment;
+      typedef true_type propagate_on_container_move_assignment;
+      typedef true_type propagate_on_container_swap;
     };
 
-    explicit allocator2(int t = 0) : tag_(t)
+    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;
+      };
+
+      explicit allocator2(int t = 0) : tag_(t)
+      {
         UNORDERED_SCOPE(allocator2::allocator2())
         {
-            UNORDERED_EPOINT("Mock allocator2 default constructor.");
+          UNORDERED_EPOINT("Mock allocator2 default constructor.");
         }
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    allocator2(allocator<T> const& x) : tag_(x.tag_)
-    {
+      allocator2(allocator<T> const& x) : tag_(x.tag_)
+      {
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
-    {
+      template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+      {
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    allocator2(allocator2 const& x) : tag_(x.tag_)
-    {
+      allocator2(allocator2 const& x) : tag_(x.tag_)
+      {
         test::detail::tracker.allocator_ref();
-    }
+      }
 
-    ~allocator2() { test::detail::tracker.allocator_unref(); }
+      ~allocator2() { test::detail::tracker.allocator_unref(); }
 
-    allocator2& operator=(allocator2 const&) { return *this; }
+      allocator2& operator=(allocator2 const&) { 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.
+      // 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)
-    {
+      pointer address(reference r)
+      {
         // UNORDERED_SCOPE(allocator2::address(reference)) {
         //    UNORDERED_EPOINT("Mock allocator2 address function.");
         //}
         return pointer(&r);
-    }
+      }
 
-    const_pointer address(const_reference 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)
-    {
+      pointer allocate(size_type n)
+      {
         T* ptr = 0;
         UNORDERED_SCOPE(allocator2::allocate(size_type))
         {
-            UNORDERED_EPOINT("Mock allocator2 allocate function.");
+          UNORDERED_EPOINT("Mock allocator2 allocate function.");
 
-            using namespace std;
-            ptr = (T*)malloc(n * sizeof(T));
-            if (!ptr)
-                throw std::bad_alloc();
+          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*)
-    {
+      pointer allocate(size_type n, void const*)
+      {
         T* ptr = 0;
         UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer))
         {
-            UNORDERED_EPOINT("Mock allocator2 allocate function.");
+          UNORDERED_EPOINT("Mock allocator2 allocate function.");
 
-            using namespace std;
-            ptr = (T*)malloc(n * sizeof(T));
-            if (!ptr)
-                throw std::bad_alloc();
+          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)
-    {
+      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);
+          test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+          using namespace std;
+          free(p);
         }
-    }
+      }
 
-    void construct(pointer p, T const& t)
-    {
+      void construct(pointer p, T const& t)
+      {
         UNORDERED_SCOPE(allocator2::construct(T*, T))
         {
-            UNORDERED_EPOINT("Mock allocator2 construct function.");
-            new (p) T(t);
+          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)
-    {
+      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)...);
+          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)
-    {
+      void destroy(T* p)
+      {
         test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
         p->~T();
-    }
+      }
 
-    size_type max_size() const
-    {
+      size_type max_size() const
+      {
         UNORDERED_SCOPE(allocator2::construct(pointer, T))
         {
-            UNORDERED_EPOINT("Mock allocator2 max_size function.");
+          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_);
     }
 
-    typedef false_type propagate_on_container_copy_assignment;
-    typedef false_type propagate_on_container_move_assignment;
-    typedef false_type propagate_on_container_swap;
-};
+    // It's pretty much impossible to write a compliant swap when these
+    // two can throw. So they don't.
 
-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 equality 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_;
-}
-}
+    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_;
+    }
+  }
 }
 
 namespace test {
-template <typename X> struct equals_to_compare;
-template <> struct equals_to_compare<test::exception::equal_to>
-{
+  template <typename X> struct equals_to_compare;
+  template <> struct equals_to_compare<test::exception::equal_to>
+  {
     typedef test::exception::less type;
-};
+  };
 }
 
 // Workaround for ADL deficient compilers
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 namespace test {
-test::exception::object generate(
+  test::exception::object generate(
     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> generate(
     std::pair<test::exception::object, test::exception::object> const* x,
     random_generator g)
-{
+  {
     return test::exception::generate(x, g);
-}
+  }
 }
 #endif
 
diff --git a/test/objects/fwd.hpp b/test/objects/fwd.hpp
index dda08892..802b95af 100644
--- a/test/objects/fwd.hpp
+++ b/test/objects/fwd.hpp
@@ -7,11 +7,11 @@
 #define BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER
 
 namespace test {
-class object;
-class hash;
-class less;
-class equal_to;
-template <class T> class allocator;
+  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 c1fa5b4f..867a263e 100644
--- a/test/objects/minimal.hpp
+++ b/test/objects/minimal.hpp
@@ -26,579 +26,591 @@
 #endif
 
 namespace test {
-namespace minimal {
-class destructible;
-class copy_constructible;
-class copy_constructible_equality_comparable;
-class default_assignable;
-class assignable;
+  namespace minimal {
+    class destructible;
+    class copy_constructible;
+    class copy_constructible_equality_comparable;
+    class default_assignable;
+    class assignable;
 
-struct ampersand_operator_used
-{
-    ampersand_operator_used() { BOOST_TEST(false); }
-};
+    struct ampersand_operator_used
+    {
+      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;
+    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
-{
-    operator int() const { return 0; }
-};
+    struct constructor_param
+    {
+      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 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
+    {
+    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&) {}
+    class copy_constructible_equality_comparable
+    {
+    public:
+      copy_constructible_equality_comparable(constructor_param const&) {}
 
-    copy_constructible_equality_comparable(
+      copy_constructible_equality_comparable(
         copy_constructible_equality_comparable const&)
-    {
-    }
+      {
+      }
 
-    ~copy_constructible_equality_comparable() {}
+      ~copy_constructible_equality_comparable() {}
 
-    void dummy_member() const {}
-  private:
-    copy_constructible_equality_comparable& operator=(
+      void dummy_member() const {}
+    private:
+      copy_constructible_equality_comparable& operator=(
         copy_constructible_equality_comparable const&);
-    copy_constructible_equality_comparable() {}
+      copy_constructible_equality_comparable() {}
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-    ampersand_operator_used operator&() const
-    {
+      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)
+    {
+      return true;
+    }
 
-bool operator!=(copy_constructible_equality_comparable,
-    copy_constructible_equality_comparable)
-{
-    return false;
-}
+    bool operator!=(copy_constructible_equality_comparable,
+      copy_constructible_equality_comparable)
+    {
+      return false;
+    }
 
-class default_assignable
-{
-  public:
-    default_assignable(constructor_param const&) {}
+    class default_assignable
+    {
+    public:
+      default_assignable(constructor_param const&) {}
 
-    default_assignable() {}
+      default_assignable() {}
 
-    default_assignable(default_assignable const&) {}
+      default_assignable(default_assignable const&) {}
 
-    default_assignable& operator=(default_assignable const&) { return *this; }
+      default_assignable& operator=(default_assignable const&) { return *this; }
 
-    ~default_assignable() {}
+      ~default_assignable() {}
 
-    void dummy_member() const {}
+      void dummy_member() const {}
 
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-    ampersand_operator_used operator&() const
-    {
+      ampersand_operator_used operator&() const
+      {
         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() {}
+    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
-    {
+      ampersand_operator_used operator&() const
+      {
         return ampersand_operator_used();
-    }
+      }
 #endif
-};
+    };
 
-struct movable_init
-{
-};
+    struct movable_init
+    {
+    };
 
-class movable1
-{
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+    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 {}
-};
+    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
-    {
+      ampersand_operator_used operator&() const
+      {
         return ampersand_operator_used();
-    }
+      }
 #endif
-};
+    };
 
-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() {}
+    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; }
+      bool operator()(T const&, T const&) const { return true; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-    ampersand_operator_used operator&() const
-    {
+      ampersand_operator_used operator&() const
+      {
         return ampersand_operator_used();
-    }
+      }
 #endif
-};
+    };
 
-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
-{
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-    template <typename T> friend class ptr;
-
-  private:
-#endif
-
-    void* ptr_;
-
-  public:
-    void_ptr() : ptr_(0) {}
-
-    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_; }
-
-    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
-{
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-    template <typename T> friend class const_ptr;
-
-  private:
-#endif
-
-    void* ptr_;
-
-  public:
-    void_const_ptr() : ptr_(0) {}
-
-    template <typename T>
-    explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
+    struct void_ptr
     {
-    }
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+      template <typename T> friend class 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_; }
+    private:
+#endif
 
-    bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
-    bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-};
+      void* ptr_;
 
-template <class T> class ptr
-{
-    friend class allocator<T>;
-    friend class const_ptr<T>;
-    friend struct void_ptr;
+    public:
+      void_ptr() : ptr_(0) {}
 
-    T* ptr_;
+      template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
 
-    ptr(T* x) : ptr_(x) {}
-  public:
-    ptr() : ptr_(0) {}
-    explicit ptr(void_ptr const& x) : ptr_((T*)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_; }
 
-    T& operator*() const { return *ptr_; }
-    T* operator->() const { return ptr_; }
-    ptr& operator++()
+      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
     {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+      template <typename T> friend class const_ptr;
+
+    private:
+#endif
+
+      void* ptr_;
+
+    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
+    {
+      friend class allocator<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 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_; }
+      }
+      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_; }
+      // 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_; }
+      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
-    {
+      ampersand_operator_used operator&() const
+      {
         return ampersand_operator_used();
-    }
+      }
 #endif
-};
+    };
 
-template <class T> class const_ptr
-{
-    friend class allocator<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++()
+    template <class T> class const_ptr
     {
+      friend class allocator<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 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)
-    {
+      }
+      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_; }
+      }
+      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_; }
+      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
-    {
+      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;
     };
 
-    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)
+    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;
+      };
+
+      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)
+      {
         return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-    }
+      }
 
-    template <class Y> pointer allocate(size_type n, const_ptr<Y>)
-    {
+      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 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)
-    {
+      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; }
+  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
-    {
+      ampersand_operator_used operator&() const
+      {
         return ampersand_operator_used();
-    }
+      }
 #endif
-};
-
-template <class T> class allocator<T const>
-{
-  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;
-    // Maybe these two should be const_ptr<T>
-    typedef ptr<T const> pointer;
-    typedef const_ptr<T const> const_pointer;
-    typedef T const& reference;
-    typedef T const& const_reference;
-    typedef T const value_type;
-
-    template <class U> struct rebind
-    {
-        typedef allocator<U> other;
     };
 
-    allocator() {}
-    template <class Y> allocator(allocator<Y> const&) {}
-    allocator(allocator const&) {}
-    ~allocator() {}
-
-    const_pointer address(const_reference r) { return const_pointer(&r); }
-
-    pointer allocate(size_type n)
+    template <class T> class allocator<T const>
     {
+    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;
+      // Maybe these two should be const_ptr<T>
+      typedef ptr<T const> pointer;
+      typedef const_ptr<T const> const_pointer;
+      typedef T const& reference;
+      typedef T const& const_reference;
+      typedef T const value_type;
+
+      template <class U> struct rebind
+      {
+        typedef allocator<U> other;
+      };
+
+      allocator() {}
+      template <class Y> allocator(allocator<Y> const&) {}
+      allocator(allocator const&) {}
+      ~allocator() {}
+
+      const_pointer address(const_reference r) { return const_pointer(&r); }
+
+      pointer allocate(size_type n)
+      {
         return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
-    }
+      }
 
-    template <class Y> pointer allocate(size_type n, const_ptr<Y>)
-    {
+      template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+      {
         return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
-    }
+      }
 
-    void deallocate(pointer p, size_type) { ::operator delete((void*)p.ptr_); }
+      void deallocate(pointer p, size_type)
+      {
+        ::operator delete((void*)p.ptr_);
+      }
 
-    void construct(T const* p, T const& t) { new ((void*)p) T(t); }
+      void construct(T const* p, T const& t) { new ((void*)p) T(t); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <class... Args>
-    void construct(T const* p, BOOST_FWD_REF(Args)... args)
-    {
+      template <class... Args>
+      void construct(T const* p, BOOST_FWD_REF(Args)... args)
+      {
         new ((void*)p) T(boost::forward<Args>(args)...);
-    }
+      }
 #endif
 
-    void destroy(T const* p) { p->~T(); }
+      void destroy(T const* 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; }
+  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
-    {
+      ampersand_operator_used operator&() const
+      {
         return ampersand_operator_used();
-    }
+      }
 #endif
-};
+    };
 
-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)
+    template <class T>
+    inline bool operator==(allocator<T> const&, allocator<T> const&)
     {
-        return static_cast<T*>(::operator new(n * sizeof(T)));
+      return true;
     }
 
-    template <class Y> T* allocate(std::size_t n, const_ptr<Y>)
+    template <class T>
+    inline bool operator!=(allocator<T> const&, allocator<T> const&)
     {
-        return static_cast<T*>(::operator new(n * sizeof(T)));
+      return false;
     }
 
-    void deallocate(T* p, std::size_t) { ::operator delete((void*)p); }
+    template <class T> void swap(allocator<T>&, allocator<T>&) {}
 
-    void construct(T* p, T const& t) { new ((void*)p) T(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 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); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <class... Args> void construct(T* p, BOOST_FWD_REF(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>&) {}
+  }
 }
 
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 namespace boost {
 #else
 namespace test {
-namespace minimal {
+  namespace minimal {
 #endif
-std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
-{
+  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)
diff --git a/test/objects/test.hpp b/test/objects/test.hpp
index e0e155f9..8c87bc26 100644
--- a/test/objects/test.hpp
+++ b/test/objects/test.hpp
@@ -14,25 +14,25 @@
 #include <cstddef>
 
 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(
+  // 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*) {}
+  inline void ignore_variable(void const*) {}
 
-class object : private counted_object
-{
+  class object : private counted_object
+  {
     friend class hash;
     friend class equal_to;
     friend class less;
@@ -43,40 +43,40 @@ class object : private counted_object
 
     ~object()
     {
-        tag1_ = -1;
-        tag2_ = -1;
+      tag1_ = -1;
+      tag2_ = -1;
     }
 
     friend bool operator==(object const& x1, object const& x2)
     {
-        return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+      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_;
+      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_);
+      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));
+      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_ << ")";
+      return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
     }
-};
+  };
 
-class movable : private counted_object
-{
+  class movable : private counted_object
+  {
     friend class hash;
     friend class equal_to;
     friend class less;
@@ -89,74 +89,74 @@ class movable : private counted_object
     movable(movable const& x)
         : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
     {
-        BOOST_TEST(x.tag1_ != -1);
+      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;
+      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;
+      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;
+      BOOST_TEST(x.tag1_ != -1);
+      tag1_ = x.tag1_;
+      tag2_ = x.tag2_;
+      x.tag1_ = -1;
+      x.tag2_ = -1;
+      return *this;
     }
 
     ~movable()
     {
-        tag1_ = -1;
-        tag2_ = -1;
+      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_;
+      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_;
+      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_);
+      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));
+      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_ << ")";
+      return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
     }
-};
+  };
 
-class implicitly_convertible : private counted_object
-{
+  class implicitly_convertible : private counted_object
+  {
     int tag1_, tag2_;
 
   public:
@@ -170,22 +170,22 @@ class implicitly_convertible : private counted_object
     operator movable() const { return movable(tag1_, tag2_); }
 
     friend implicitly_convertible generate(
-        implicitly_convertible const*, random_generator g)
+      implicitly_convertible const*, random_generator g)
     {
-        int* x = 0;
-        return implicitly_convertible(generate(x, g), generate(x, g));
+      int* x = 0;
+      return implicitly_convertible(generate(x, g), generate(x, g));
     }
 
     friend std::ostream& operator<<(
-        std::ostream& out, implicitly_convertible const& o)
+      std::ostream& out, implicitly_convertible const& o)
     {
-        return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+      return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
     }
-};
+  };
 
-// Note: This is a deliberately bad hash function.
-class hash
-{
+  // Note: This is a deliberately bad hash function.
+  class hash
+  {
     int type_;
 
   public:
@@ -193,69 +193,69 @@ class hash
 
     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);
+      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);
+      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);
+      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_;
+      return x1.type_ == x2.type_;
     }
 
     friend bool operator!=(hash const& x1, hash const& x2)
     {
-        return x1.type_ != x2.type_;
+      return x1.type_ != x2.type_;
     }
-};
+  };
 
-std::size_t hash_value(test::object const& x) { return hash()(x); }
+  std::size_t hash_value(test::object const& x) { return hash()(x); }
 
-std::size_t hash_value(test::movable const& x) { return hash()(x); }
+  std::size_t hash_value(test::movable const& x) { return hash()(x); }
 
-class less
-{
+  class less
+  {
     int type_;
 
   public:
@@ -263,38 +263,38 @@ class less
 
     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;
-        }
+      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; }
 
     friend bool operator==(less const& x1, less const& x2)
     {
-        return x1.type_ == x2.type_;
+      return x1.type_ == x2.type_;
     }
-};
+  };
 
-class equal_to
-{
+  class equal_to
+  {
     int type_;
 
   public:
@@ -302,48 +302,48 @@ class equal_to
 
     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;
-        }
+      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; }
 
     friend bool operator==(equal_to const& x1, equal_to const& x2)
     {
-        return x1.type_ == x2.type_;
+      return x1.type_ == x2.type_;
     }
 
     friend bool operator!=(equal_to const& x1, equal_to const& x2)
     {
-        return x1.type_ != x2.type_;
+      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.
+  // 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
-{
+  template <class T> class allocator1
+  {
   public:
     int tag_;
 
@@ -351,60 +351,60 @@ template <class T> class allocator1
 
     template <class U> struct rebind
     {
-        typedef allocator1<U> other;
+      typedef allocator1<U> other;
     };
 
     explicit allocator1(int t = 0) : tag_(t)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     template <class Y> allocator1(allocator1<Y> const& x) : tag_(x.tag_)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     allocator1(allocator1 const& x) : tag_(x.tag_)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     ~allocator1() { detail::tracker.allocator_unref(); }
 
     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;
+      T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
     }
 
     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;
+      T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
     }
 
     void deallocate(T* p, std::size_t n)
     {
-        detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
-        ::operator delete((void*)p);
+      detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+      ::operator delete((void*)p);
     }
 
 #if BOOST_UNORDERED_CXX11_CONSTRUCTION
     template <typename U, typename... Args> void construct(U* p, Args&&... args)
     {
-        detail::tracker.track_construct((void*)p, sizeof(U), tag_);
-        new (p) U(boost::forward<Args>(args)...);
+      detail::tracker.track_construct((void*)p, sizeof(U), tag_);
+      new (p) U(boost::forward<Args>(args)...);
     }
 
     template <typename U> void destroy(U* p)
     {
-        detail::tracker.track_destroy((void*)p, sizeof(U), tag_);
-        p->~U();
+      detail::tracker.track_destroy((void*)p, sizeof(U), tag_);
+      p->~U();
 
-        // Work around MSVC buggy unused parameter warning.
-        ignore_variable(&p);
+      // Work around MSVC buggy unused parameter warning.
+      ignore_variable(&p);
     }
 #else
   private:
@@ -429,18 +429,18 @@ template <class T> class allocator1
 
     enum
     {
-        is_select_on_copy = false,
-        is_propagate_on_swap = false,
-        is_propagate_on_assign = false,
-        is_propagate_on_move = false
+      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;
 
@@ -460,10 +460,10 @@ struct void_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;
 
@@ -486,10 +486,10 @@ class void_const_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 <class T> class ptr
+  {
     friend class allocator2<T>;
     friend class const_ptr<T>;
     friend struct void_ptr;
@@ -505,14 +505,14 @@ template <class T> class ptr
     T* operator->() const { return ptr_; }
     ptr& operator++()
     {
-        ++ptr_;
-        return *this;
+      ++ptr_;
+      return *this;
     }
     ptr operator++(int)
     {
-        ptr tmp(*this);
-        ++ptr_;
-        return tmp;
+      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_); }
@@ -529,10 +529,10 @@ template <class T> class 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 T> class const_ptr
+  {
     friend class allocator2<T>;
     friend struct const_void_ptr;
 
@@ -548,19 +548,19 @@ template <class T> class const_ptr
     T const* operator->() const { return ptr_; }
     const_ptr& operator++()
     {
-        ++ptr_;
-        return *this;
+      ++ptr_;
+      return *this;
     }
     const_ptr operator++(int)
     {
-        const_ptr tmp(*this);
-        ++ptr_;
-        return tmp;
+      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_);
+      return ptr<T>(s + p.ptr_);
     }
     T const& operator[](int s) const { return ptr_[s]; }
     bool operator!() const { return !ptr_; }
@@ -572,10 +572,10 @@ template <class T> class const_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
-{
+  template <class T> class allocator2
+  {
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
   public:
 #else
@@ -596,22 +596,22 @@ template <class T> class allocator2
 
     template <class U> struct rebind
     {
-        typedef allocator2<U> other;
+      typedef allocator2<U> other;
     };
 
     explicit allocator2(int t = 0) : tag_(t)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     allocator2(allocator2 const& x) : tag_(x.tag_)
     {
-        detail::tracker.allocator_ref();
+      detail::tracker.allocator_ref();
     }
 
     ~allocator2() { detail::tracker.allocator_unref(); }
@@ -622,47 +622,47 @@ template <class T> class allocator2
 
     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 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;
+      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_);
+      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);
+      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)...);
+      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();
+      detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+      p->~T();
     }
 
     size_type max_size() const
     {
-        return (std::numeric_limits<size_type>::max)();
+      return (std::numeric_limits<size_type>::max)();
     }
 
     bool operator==(allocator2 const& x) const { return tag_ == x.tag_; }
@@ -671,26 +671,26 @@ template <class T> class allocator2
 
     enum
     {
-        is_select_on_copy = false,
-        is_propagate_on_swap = false,
-        is_propagate_on_assign = false,
-        is_propagate_on_move = false
+      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(
+  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(
+  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 dac415c4..9b8738c2 100644
--- a/test/unordered/allocator_traits.cpp
+++ b/test/unordered/allocator_traits.cpp
@@ -12,76 +12,76 @@
 // Boilerplate
 
 #define ALLOCATOR_METHODS(name)                                                \
-    template <typename U> struct rebind                                        \
-    {                                                                          \
-        typedef name<U> other;                                                 \
-    };                                                                         \
+  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; }                          \
+  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;                                                 \
-    };                                                                         \
+  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; }                          \
+  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
-    };
+  enum
+  {
+    value = true
+  };
 };
 struct no_type
 {
-    enum
-    {
-        value = false
-    };
+  enum
+  {
+    value = false
+  };
 };
 
 // For tracking calls...
@@ -91,193 +91,190 @@ void reset() { selected = 0; }
 
 template <typename Allocator> int call_select()
 {
-    typedef boost::unordered::detail::allocator_traits<Allocator> traits;
-    Allocator a;
+  typedef boost::unordered::detail::allocator_traits<Allocator> traits;
+  Allocator a;
 
-    reset();
-    BOOST_TEST(traits::select_on_container_copy_construction(a) == a);
-    return selected;
+  reset();
+  BOOST_TEST(traits::select_on_container_copy_construction(a) == a);
+  return selected;
 }
 
 // Empty allocator test
 
 template <typename T> struct empty_allocator
 {
-    typedef T value_type;
-    ALLOCATOR_METHODS(empty_allocator)
+  typedef T value_type;
+  ALLOCATOR_METHODS(empty_allocator)
 };
 
 void test_empty_allocator()
 {
-    typedef empty_allocator<int> allocator;
-    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+  typedef empty_allocator<int> allocator;
+  typedef boost::unordered::detail::allocator_traits<allocator> traits;
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>::value));
+  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::pointer, int*>::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);
-    BOOST_TEST(!traits::propagate_on_container_swap::value);
-    BOOST_TEST(call_select<allocator>() == 0);
+  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::value_type, int>::value));
+  BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 0);
 }
 
 // allocator 1
 
 template <typename T> struct allocator1
 {
-    typedef T value_type;
-    ALLOCATOR_METHODS(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;
+  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
-    {
-        ++selected;
-        return allocator1<T>();
-    }
+  allocator1<T> select_on_container_copy_construction() const
+  {
+    ++selected;
+    return allocator1<T>();
+  }
 };
 
 void test_allocator1()
 {
-    typedef allocator1<int> allocator;
-    typedef boost::unordered::detail::allocator_traits<allocator> traits;
+  typedef allocator1<int> allocator;
+  typedef boost::unordered::detail::allocator_traits<allocator> traits;
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>::value));
+  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::pointer, int*>::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);
-    BOOST_TEST(traits::propagate_on_container_swap::value);
-    BOOST_TEST(call_select<allocator>() == 1);
+  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::value_type, int>::value));
+  BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 1);
 }
 
 // allocator 2
 
 template <typename Alloc> struct allocator2_base
 {
-    Alloc select_on_container_copy_construction() const
-    {
-        ++selected;
-        return Alloc();
-    }
+  Alloc select_on_container_copy_construction() const
+  {
+    ++selected;
+    return Alloc();
+  }
 };
 
 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;
+  typedef T value_type;
+  typedef T* pointer;
+  typedef T const* const_pointer;
+  typedef std::size_t size_type;
 
-    ALLOCATOR_METHODS(allocator2)
+  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;
+  typedef no_type propagate_on_container_copy_assignment;
+  typedef no_type propagate_on_container_move_assignment;
+  typedef no_type propagate_on_container_swap;
 };
 
 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::pointer, int*>::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);
-    BOOST_TEST(!traits::propagate_on_container_swap::value);
-    BOOST_TEST(call_select<allocator>() == 1);
+  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::pointer, int*>::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);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 1);
 }
 
 // allocator 3
 
 template <typename T> struct ptr
 {
-    T* value_;
+  T* value_;
 
-    ptr(void* v) : value_((T*)v) {}
-    T& operator*() const { return *value_; }
+  ptr(void* v) : value_((T*)v) {}
+  T& operator*() const { return *value_; }
 };
 
 template <> struct ptr<void>
 {
-    void* value_;
-    ptr(void* v) : value_(v) {}
+  void* value_;
+  ptr(void* v) : value_(v) {}
 };
 
 template <> struct ptr<const void>
 {
-    void const* value_;
-    ptr(void const* v) : value_(v) {}
+  void const* value_;
+  ptr(void const* v) : value_(v) {}
 };
 
 template <typename T> struct allocator3
 {
-    typedef T value_type;
-    typedef ptr<T> pointer;
-    typedef ptr<T const> const_pointer;
-    typedef unsigned short size_type;
+  typedef T value_type;
+  typedef ptr<T> pointer;
+  typedef ptr<T const> const_pointer;
+  typedef unsigned short size_type;
 
-    ALLOCATOR_METHODS_TYPEDEFS(allocator3)
+  ALLOCATOR_METHODS_TYPEDEFS(allocator3)
 
-    typedef yes_type propagate_on_container_copy_assignment;
-    typedef no_type propagate_on_container_move_assignment;
+  typedef yes_type propagate_on_container_copy_assignment;
+  typedef no_type propagate_on_container_move_assignment;
 
-    allocator3<T> select_on_container_copy_construction() const
-    {
-        ++selected;
-        return allocator3<T>();
-    }
+  allocator3<T> select_on_container_copy_construction() const
+  {
+    ++selected;
+    return allocator3<T>();
+  }
 };
 
 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::pointer, ptr<int> >::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);
-    BOOST_TEST(!traits::propagate_on_container_swap::value);
-    BOOST_TEST(call_select<allocator>() == 1);
+  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::pointer, ptr<int> >::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);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 1);
 }
 
 int main()
 {
-    test_empty_allocator();
-    test_allocator1();
-    test_allocator2();
-    test_allocator3();
-    return boost::report_errors();
+  test_empty_allocator();
+  test_allocator1();
+  test_allocator2();
+  test_allocator3();
+  return boost::report_errors();
 }
diff --git a/test/unordered/assign_tests.cpp b/test/unordered/assign_tests.cpp
index 3aee2198..d0d7a669 100644
--- a/test/unordered/assign_tests.cpp
+++ b/test/unordered/assign_tests.cpp
@@ -23,51 +23,51 @@
 
 namespace assign_tests {
 
-test::seed_t initialize_seed(96785);
+  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;
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.1\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x;
-        x = x;
-        BOOST_TEST(x.empty());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      T x;
+      x = x;
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.2\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
-        T x(v.begin(), v.end());
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end());
 
-        test::ordered<T> tracker = test::create_ordered(x);
-        tracker.insert_range(v.begin(), v.end());
+      test::ordered<T> tracker = test::create_ordered(x);
+      tracker.insert_range(v.begin(), v.end());
 
-        x = x;
-        tracker.compare(x);
+      x = x;
+      tracker.compare(x);
 
-        T y;
-        y.max_load_factor(x.max_load_factor() / 20);
-        float mlf = x.max_load_factor();
-        y = x;
-        tracker.compare(x);
-        tracker.compare(y);
-        BOOST_TEST(x.max_load_factor() == mlf);
-        BOOST_TEST(y.max_load_factor() == mlf);
-        BOOST_TEST(y.load_factor() <= y.max_load_factor());
+      T y;
+      y.max_load_factor(x.max_load_factor() / 20);
+      float mlf = x.max_load_factor();
+      y = x;
+      tracker.compare(x);
+      tracker.compare(y);
+      BOOST_TEST(x.max_load_factor() == mlf);
+      BOOST_TEST(y.max_load_factor() == mlf);
+      BOOST_TEST(y.load_factor() <= y.max_load_factor());
     }
-}
+  }
 
-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);
     BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
@@ -79,196 +79,196 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.0 - empty container\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x1(0, hf1, eq1);
-        T x2(0, hf2, eq2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        test::check_container(x1, x2);
+      T x1(0, hf1, eq1);
+      T x2(0, hf2, eq2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      test::check_container(x1, x2);
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
-        T x1(v.begin(), v.end(), 0, hf1, eq1);
-        T x2(0, hf2, eq2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        test::check_container(x1, v);
-        test::check_container(x2, v);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+      test::random_values<T> v(1000, generator);
+      T x1(v.begin(), v.end(), 0, hf1, eq1);
+      T x2(0, hf2, eq2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      test::check_container(x1, v);
+      test::check_container(x2, v);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1a\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v1(0, generator);
-        test::random_values<T> v2(1000, generator);
-        T x1(0, hf2, eq2);
-        T x2(v2.begin(), v2.end(), 0, hf1, eq1);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x1.hash_function(), hf2));
-        BOOST_TEST(test::equivalent(x1.key_eq(), eq2));
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf2));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq2));
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+      test::random_values<T> v1(0, generator);
+      test::random_values<T> v2(1000, generator);
+      T x1(0, hf2, eq2);
+      T x2(v2.begin(), v2.end(), 0, hf1, eq1);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x1.hash_function(), hf2));
+      BOOST_TEST(test::equivalent(x1.key_eq(), eq2));
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf2));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq2));
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.2\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v1(100, generator), v2(100, generator);
-        T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
-        T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        if (allocator_type::is_propagate_on_assign) {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        } else {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
-        }
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+      test::random_values<T> v1(100, generator), v2(100, generator);
+      T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
+      T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      if (allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+      }
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.3\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v1(100, generator), v2(1000, generator);
-        T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
-        T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        if (allocator_type::is_propagate_on_assign) {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        } else {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
-        }
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+      test::random_values<T> v1(100, generator), v2(1000, generator);
+      T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
+      T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      if (allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+      }
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.4\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v1(1000, generator), v2(100, generator);
-        T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
-        T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        if (allocator_type::is_propagate_on_assign) {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        } else {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
-        }
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+      test::random_values<T> v1(1000, generator), v2(100, generator);
+      T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
+      T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      if (allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+      }
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
-}
+  }
 
-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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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;
+  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;
-}
+  }
 
-UNORDERED_AUTO_TEST(check_traits)
-{
+  UNORDERED_AUTO_TEST(check_traits)
+  {
     BOOST_TEST(!is_propagate(test_set));
     BOOST_TEST(is_propagate(test_set_prop_assign));
     BOOST_TEST(!is_propagate(test_set_no_prop_assign));
-}
+  }
 
-UNORDERED_TEST(assign_tests1,
+  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))(
+      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(
+  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)))
+                     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)
-{
+  UNORDERED_AUTO_TEST(assign_default_initializer_list)
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
     std::initializer_list<std::pair<int const, int> > init;
     boost::unordered_map<int, int> x1;
@@ -277,13 +277,13 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list)
     BOOST_TEST(!x1.empty());
     x1 = init;
     BOOST_TEST(x1.empty());
-}
+  }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-UNORDERED_AUTO_TEST(assign_initializer_list)
-{
+  UNORDERED_AUTO_TEST(assign_initializer_list)
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
 
     boost::unordered_set<int> x;
@@ -292,7 +292,7 @@ UNORDERED_AUTO_TEST(assign_initializer_list)
     x = {1, 2, -10};
     BOOST_TEST(x.find(10) == x.end());
     BOOST_TEST(x.find(-10) != x.end());
-}
+  }
 
 #endif
 }
diff --git a/test/unordered/at_tests.cpp b/test/unordered/at_tests.cpp
index a948aeff..4f2af3ce 100644
--- a/test/unordered/at_tests.cpp
+++ b/test/unordered/at_tests.cpp
@@ -14,8 +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;
@@ -24,14 +24,14 @@ UNORDERED_AUTO_TEST(at_tests)
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check empty container" << std::endl;
 
     try {
-        x.at("one");
-        BOOST_ERROR("Should have thrown.");
+      x.at("one");
+      BOOST_ERROR("Should have thrown.");
     } catch (std::out_of_range) {
     }
 
     try {
-        x_const.at("one");
-        BOOST_ERROR("Should have thrown.");
+      x_const.at("one");
+      BOOST_ERROR("Should have thrown.");
     } catch (std::out_of_range) {
     }
 
@@ -50,19 +50,19 @@ UNORDERED_AUTO_TEST(at_tests)
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check missing element" << std::endl;
 
     try {
-        x.at("three");
-        BOOST_ERROR("Should have thrown.");
+      x.at("three");
+      BOOST_ERROR("Should have thrown.");
     } catch (std::out_of_range) {
     }
 
     try {
-        x_const.at("three");
-        BOOST_ERROR("Should have thrown.");
+      x_const.at("three");
+      BOOST_ERROR("Should have thrown.");
     } 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 9cb5bdd4..60a48887 100644
--- a/test/unordered/bucket_tests.cpp
+++ b/test/unordered/bucket_tests.cpp
@@ -23,10 +23,10 @@
 
 namespace bucket_tests {
 
-test::seed_t initialize_seed(54635);
+  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_;
 
     typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
@@ -37,60 +37,59 @@ template <class X> void tests(X*, test::random_generator generator)
 
     BOOST_TEST(x.bucket_count() <= x.max_bucket_count());
     if (!(x.bucket_count() <= x.max_bucket_count())) {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM << x.bucket_count()
-                                       << "<=" << x.max_bucket_count() << "\n";
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << 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 = v.begin(),
+           end = v.end();
          it != end; ++it) {
-        size_type bucket = x.bucket(test::get_key<X>(*it));
+      size_type bucket = x.bucket(test::get_key<X>(*it));
 
-        BOOST_TEST(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)) {
-                ++lit;
-            }
-            BOOST_TEST(lit != lend);
+      BOOST_TEST(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)) {
+          ++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))));
-        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.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::unordered_multimap<test::object, test::object, test::hash,
+  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,
+  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;
+  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 863b56c1..4f8f701d 100644
--- a/test/unordered/compile_map.cpp
+++ b/test/unordered/compile_map.cpp
@@ -19,211 +19,203 @@
 // Explicit instantiation to catch compile-time errors
 
 #define INSTANTIATE(type)                                                      \
-    template class boost::unordered::detail::instantiate_##type
+  template class boost::unordered::detail::instantiate_##type
 
 INSTANTIATE(map)<int, int, boost::hash<int>, std::equal_to<int>,
-    test::minimal::allocator<int> >;
+  test::minimal::allocator<int> >;
 INSTANTIATE(multimap)<int const, int const, boost::hash<int>,
-    std::equal_to<int>, test::minimal::allocator<int> >;
+  std::equal_to<int>, test::minimal::allocator<int> >;
 
-INSTANTIATE(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<int> >;
+INSTANTIATE(
+  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<int> >;
 INSTANTIATE(multimap)<test::minimal::assignable, test::minimal::assignable,
-    test::minimal::hash<test::minimal::assignable>,
-    test::minimal::equal_to<test::minimal::assignable>,
-    test::minimal::allocator<int> >;
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
 
 UNORDERED_AUTO_TEST(test0)
 {
-    test::minimal::constructor_param x;
+  test::minimal::constructor_param x;
 
-    typedef std::pair<test::minimal::assignable const,
-        test::minimal::assignable>
-        value_type;
-    value_type value(x, x);
+  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
+    value_type;
+  value_type value(x, x);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
-    boost::unordered_map<int, int> int_map;
+  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,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<value_type> >
-        map;
+  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;
 
-    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);
+  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);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
-    boost::unordered_multimap<int, int> int_multimap;
+  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,
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<value_type> >
-        multimap;
+  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;
 
-    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);
+  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)
 {
-    typedef std::pair<
-        test::minimal::copy_constructible_equality_comparable const,
-        test::minimal::copy_constructible_equality_comparable>
-        value_type;
+  typedef std::pair<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> 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;
+  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;
 
-    equality_test(int_map);
-    equality_test(int_map2);
-    equality_test(map);
+  equality_test(int_map);
+  equality_test(int_map2);
+  equality_test(map);
 
-    boost::unordered_multimap<int, int> int_multimap;
+  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;
+  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;
 
-    equality_test(int_multimap);
-    equality_test(int_multimap2);
-    equality_test(multimap);
+  equality_test(int_multimap);
+  equality_test(int_multimap2);
+  equality_test(multimap);
 }
 
 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);
+  boost::hash<int> hash;
+  std::equal_to<int> equal_to;
+  int value = 0;
+  std::pair<int const, int> map_value(0, 0);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
-    boost::unordered_map<int, int> map;
+  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);
-    unordered_copyable_test(map, value, map_value, hash, equal_to);
-    unordered_map_functions(map, value, value);
+  unordered_unique_test(map, map_value);
+  unordered_map_test(map, value, value);
+  unordered_copyable_test(map, value, map_value, hash, equal_to);
+  unordered_map_functions(map, value, value);
 
-    unordered_unique_test(map2, map_value);
-    unordered_map_test(map2, value, value);
-    unordered_copyable_test(map2, value, map_value, hash, equal_to);
-    unordered_map_functions(map2, value, value);
+  unordered_unique_test(map2, map_value);
+  unordered_map_test(map2, value, value);
+  unordered_copyable_test(map2, value, map_value, hash, equal_to);
+  unordered_map_functions(map2, value, value);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
-    boost::unordered_multimap<int, int> multimap;
+  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);
-    unordered_copyable_test(multimap, value, map_value, hash, equal_to);
+  unordered_equivalent_test(multimap, map_value);
+  unordered_map_test(multimap, value, value);
+  unordered_copyable_test(multimap, value, map_value, hash, equal_to);
 
-    unordered_equivalent_test(multimap2, map_value);
-    unordered_map_test(multimap2, value, value);
-    unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
+  unordered_equivalent_test(multimap2, map_value);
+  unordered_map_test(multimap2, value, value);
+  unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::constructor_param x;
+  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);
+  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);
 
-    typedef std::pair<test::minimal::assignable const,
-        test::minimal::assignable>
-        map_value_type;
-    map_value_type map_value(assignable, assignable);
+  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
+    map_value_type;
+  map_value_type map_value(assignable, assignable);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
-    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;
+  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;
 
-    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);
+  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,
-        test::minimal::default_assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> >
-        map2;
+  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::default_assignable default_assignable;
+  test::minimal::default_assignable default_assignable;
 
-    unordered_map_functions(map2, assignable, default_assignable);
+  unordered_map_functions(map2, assignable, default_assignable);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
-    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;
+  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;
 
-    unordered_equivalent_test(multimap, map_value);
-    unordered_map_test(multimap, assignable, assignable);
-    unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
-    unordered_map_member_test(multimap, map_value);
+  unordered_equivalent_test(multimap, map_value);
+  unordered_map_test(multimap, assignable, assignable);
+  unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
+  unordered_map_member_test(multimap, map_value);
 }
 
 // Test for ambiguity when using key convertible from iterator
@@ -231,31 +223,31 @@ UNORDERED_AUTO_TEST(test2)
 
 struct lwg2059_key
 {
-    int value;
+  int value;
 
-    template <typename T> lwg2059_key(T v) : value(v) {}
+  template <typename T> lwg2059_key(T v) : value(v) {}
 };
 
 std::size_t hash_value(lwg2059_key x)
 {
-    return static_cast<std::size_t>(x.value);
+  return static_cast<std::size_t>(x.value);
 }
 
 bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
 
 UNORDERED_AUTO_TEST(lwg2059)
 {
-    {
-        boost::unordered_map<lwg2059_key, int> x;
-        x.emplace(lwg2059_key(10), 5);
-        x.erase(x.begin());
-    }
+  {
+    boost::unordered_map<lwg2059_key, int> x;
+    x.emplace(lwg2059_key(10), 5);
+    x.erase(x.begin());
+  }
 
-    {
-        boost::unordered_multimap<lwg2059_key, int> x;
-        x.emplace(lwg2059_key(10), 5);
-        x.erase(x.begin());
-    }
+  {
+    boost::unordered_multimap<lwg2059_key, int> x;
+    x.emplace(lwg2059_key(10), 5);
+    x.erase(x.begin());
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/compile_set.cpp b/test/unordered/compile_set.cpp
index 9ea71f73..0c6fa555 100644
--- a/test/unordered/compile_set.cpp
+++ b/test/unordered/compile_set.cpp
@@ -19,274 +19,271 @@
 // Explicit instantiation to catch compile-time errors
 
 #define INSTANTIATE(type)                                                      \
-    template class boost::unordered::detail::instantiate_##type
+  template class boost::unordered::detail::instantiate_##type
 
 INSTANTIATE(set)<int, boost::hash<int>, std::equal_to<int>,
-    test::minimal::allocator<int> >;
+  test::minimal::allocator<int> >;
 INSTANTIATE(multiset)<int const, boost::hash<int>, std::equal_to<int>,
-    test::minimal::allocator<int> >;
+  test::minimal::allocator<int> >;
 
 INSTANTIATE(set)<test::minimal::assignable const,
-    test::minimal::hash<test::minimal::assignable>,
-    test::minimal::equal_to<test::minimal::assignable>,
-    test::minimal::allocator<int> >;
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
 INSTANTIATE(multiset)<test::minimal::assignable,
-    test::minimal::hash<test::minimal::assignable>,
-    test::minimal::equal_to<test::minimal::assignable>,
-    test::minimal::allocator<int> >;
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
 
 UNORDERED_AUTO_TEST(test0)
 {
-    test::minimal::constructor_param x;
+  test::minimal::constructor_param x;
 
-    test::minimal::assignable assignable(x);
+  test::minimal::assignable assignable(x);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
-    boost::unordered_set<int> int_set;
+  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,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> >
-        set;
+  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;
 
-    container_test(int_set, 0);
-    container_test(int_set2, 0);
-    container_test(set, assignable);
+  container_test(int_set, 0);
+  container_test(int_set2, 0);
+  container_test(set, assignable);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-    boost::unordered_multiset<int> int_multiset;
+  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,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> >
-        multiset;
+  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;
 
-    container_test(int_multiset, 0);
-    container_test(int_multiset2, 0);
-    container_test(multiset, assignable);
+  container_test(int_multiset, 0);
+  container_test(int_multiset2, 0);
+  container_test(multiset, assignable);
 }
 
 UNORDERED_AUTO_TEST(equality_tests)
 {
-    typedef test::minimal::copy_constructible_equality_comparable value_type;
+  typedef test::minimal::copy_constructible_equality_comparable value_type;
 
-    boost::unordered_set<int> int_set;
+  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;
+  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;
 
-    equality_test(int_set);
-    equality_test(int_set2);
-    equality_test(set);
+  equality_test(int_set);
+  equality_test(int_set2);
+  equality_test(set);
 
-    boost::unordered_multiset<int> int_multiset;
+  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;
+  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;
 
-    equality_test(int_multiset);
-    equality_test(int_multiset2);
-    equality_test(multiset);
+  equality_test(int_multiset);
+  equality_test(int_multiset2);
+  equality_test(multiset);
 }
 
 UNORDERED_AUTO_TEST(test1)
 {
-    boost::hash<int> hash;
-    std::equal_to<int> equal_to;
-    int value = 0;
+  boost::hash<int> hash;
+  std::equal_to<int> equal_to;
+  int value = 0;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
 
-    boost::unordered_set<int> set;
+  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);
-    unordered_copyable_test(set, value, value, hash, equal_to);
+  unordered_unique_test(set, value);
+  unordered_set_test(set, value);
+  unordered_copyable_test(set, value, value, hash, equal_to);
 
-    unordered_unique_test(set2, value);
-    unordered_set_test(set2, value);
-    unordered_copyable_test(set2, value, value, hash, equal_to);
+  unordered_unique_test(set2, value);
+  unordered_set_test(set2, value);
+  unordered_copyable_test(set2, value, value, hash, equal_to);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
 
-    boost::unordered_multiset<int> multiset;
+  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);
-    unordered_copyable_test(multiset, value, value, hash, equal_to);
+  unordered_equivalent_test(multiset, value);
+  unordered_set_test(multiset, value);
+  unordered_copyable_test(multiset, value, value, hash, equal_to);
 
-    unordered_equivalent_test(multiset2, value);
-    unordered_set_test(multiset2, value);
-    unordered_copyable_test(multiset2, value, value, hash, equal_to);
+  unordered_equivalent_test(multiset2, value);
+  unordered_set_test(multiset2, value);
+  unordered_copyable_test(multiset2, value, value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::constructor_param x;
+  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);
+  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);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
-    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;
+  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;
 
-    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);
+  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);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-    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;
+  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;
 
-    unordered_equivalent_test(multiset, assignable);
-    unordered_set_test(multiset, assignable);
-    unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
-    unordered_set_member_test(multiset, assignable);
+  unordered_equivalent_test(multiset, assignable);
+  unordered_set_test(multiset, assignable);
+  unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
+  unordered_set_member_test(multiset, assignable);
 }
 
 UNORDERED_AUTO_TEST(movable1_tests)
 {
-    test::minimal::constructor_param x;
+  test::minimal::constructor_param x;
 
-    test::minimal::movable1 movable1(x);
-    test::minimal::hash<test::minimal::movable1> hash(x);
-    test::minimal::equal_to<test::minimal::movable1> equal_to(x);
+  test::minimal::movable1 movable1(x);
+  test::minimal::hash<test::minimal::movable1> hash(x);
+  test::minimal::equal_to<test::minimal::movable1> equal_to(x);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
-    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;
+  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;
 
-    // unordered_unique_test(set, movable1);
-    unordered_set_test(set, movable1);
-    unordered_movable_test(set, movable1, movable1, hash, equal_to);
+  // unordered_unique_test(set, movable1);
+  unordered_set_test(set, movable1);
+  unordered_movable_test(set, movable1, movable1, hash, equal_to);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-    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;
+  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;
 
-    // unordered_equivalent_test(multiset, movable1);
-    unordered_set_test(multiset, movable1);
-    unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
+  // unordered_equivalent_test(multiset, movable1);
+  unordered_set_test(multiset, movable1);
+  unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(movable2_tests)
 {
-    test::minimal::constructor_param x;
+  test::minimal::constructor_param x;
 
-    test::minimal::movable2 movable2(x);
-    test::minimal::hash<test::minimal::movable2> hash(x);
-    test::minimal::equal_to<test::minimal::movable2> equal_to(x);
+  test::minimal::movable2 movable2(x);
+  test::minimal::hash<test::minimal::movable2> hash(x);
+  test::minimal::equal_to<test::minimal::movable2> equal_to(x);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
-    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;
+  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;
 
-    // unordered_unique_test(set, movable2);
-    unordered_set_test(set, movable2);
-    unordered_movable_test(set, movable2, movable2, hash, equal_to);
+  // unordered_unique_test(set, movable2);
+  unordered_set_test(set, movable2);
+  unordered_movable_test(set, movable2, movable2, hash, equal_to);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-    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;
+  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;
 
-    // unordered_equivalent_test(multiset, movable2);
-    unordered_set_test(multiset, movable2);
-    unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
+  // unordered_equivalent_test(multiset, movable2);
+  unordered_set_test(multiset, movable2);
+  unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(destructible_tests)
 {
-    test::minimal::constructor_param x;
+  test::minimal::constructor_param x;
 
-    test::minimal::destructible destructible(x);
-    test::minimal::hash<test::minimal::destructible> hash(x);
-    test::minimal::equal_to<test::minimal::destructible> equal_to(x);
+  test::minimal::destructible destructible(x);
+  test::minimal::hash<test::minimal::destructible> hash(x);
+  test::minimal::equal_to<test::minimal::destructible> equal_to(x);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
-    boost::unordered_set<test::minimal::destructible,
-        test::minimal::hash<test::minimal::destructible>,
-        test::minimal::equal_to<test::minimal::destructible> >
-        set;
+  boost::unordered_set<test::minimal::destructible,
+    test::minimal::hash<test::minimal::destructible>,
+    test::minimal::equal_to<test::minimal::destructible> >
+    set;
 
-    unordered_destructible_test(set);
+  unordered_destructible_test(set);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-    boost::unordered_multiset<test::minimal::destructible,
-        test::minimal::hash<test::minimal::destructible>,
-        test::minimal::equal_to<test::minimal::destructible> >
-        multiset;
+  boost::unordered_multiset<test::minimal::destructible,
+    test::minimal::hash<test::minimal::destructible>,
+    test::minimal::equal_to<test::minimal::destructible> >
+    multiset;
 
-    unordered_destructible_test(multiset);
+  unordered_destructible_test(multiset);
 }
 
 // Test for ambiguity when using key convertible from iterator
@@ -294,31 +291,31 @@ UNORDERED_AUTO_TEST(destructible_tests)
 
 struct lwg2059_key
 {
-    int value;
+  int value;
 
-    template <typename T> lwg2059_key(T v) : value(v) {}
+  template <typename T> lwg2059_key(T v) : value(v) {}
 };
 
 std::size_t hash_value(lwg2059_key x)
 {
-    return static_cast<std::size_t>(x.value);
+  return static_cast<std::size_t>(x.value);
 }
 
 bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
 
 UNORDERED_AUTO_TEST(lwg2059)
 {
-    {
-        boost::unordered_set<lwg2059_key> x;
-        x.emplace(lwg2059_key(10));
-        x.erase(x.begin());
-    }
+  {
+    boost::unordered_set<lwg2059_key> x;
+    x.emplace(lwg2059_key(10));
+    x.erase(x.begin());
+  }
 
-    {
-        boost::unordered_multiset<lwg2059_key> x;
-        x.emplace(lwg2059_key(10));
-        x.erase(x.begin());
-    }
+  {
+    boost::unordered_multiset<lwg2059_key> x;
+    x.emplace(lwg2059_key(10));
+    x.erase(x.begin());
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/compile_tests.hpp b/test/unordered/compile_tests.hpp
index af913614..2c7b4dd3 100644
--- a/test/unordered/compile_tests.hpp
+++ b/test/unordered/compile_tests.hpp
@@ -37,9 +37,9 @@ template <class T> T implicit_construct() { return {}; }
 #else
 template <class T> int implicit_construct()
 {
-    T x;
-    sink(x);
-    return 0;
+  T x;
+  sink(x);
+  return 0;
 }
 #endif
 
@@ -51,616 +51,615 @@ template <class T> int implicit_construct()
 
 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 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;
-    typedef BOOST_DEDUCED_TYPENAME X::const_reference const_reference;
+  typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+  typedef BOOST_DEDUCED_TYPENAME X::reference reference;
+  typedef BOOST_DEDUCED_TYPENAME X::const_reference const_reference;
 
-    typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
 
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
-    // value_type
+  // value_type
 
-    BOOST_STATIC_ASSERT((boost::is_same<T, value_type>::value));
-    boost::function_requires<boost::CopyConstructibleConcept<X> >();
+  BOOST_STATIC_ASSERT((boost::is_same<T, value_type>::value));
+  boost::function_requires<boost::CopyConstructibleConcept<X> >();
 
-    // reference_type / const_reference_type
+  // reference_type / const_reference_type
 
-    BOOST_STATIC_ASSERT((boost::is_same<T&, reference>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<T const&, const_reference>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<T&, reference>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<T const&, const_reference>::value));
 
-    // iterator
+  // iterator
 
-    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::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));
 
-    // const_iterator
+  // const_iterator
 
-    boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<T, const_iterator_value_type>::value));
+  boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+  BOOST_STATIC_ASSERT((boost::is_same<T, const_iterator_value_type>::value));
 
-    // node_type
+  // node_type
 
-    BOOST_STATIC_ASSERT((boost::is_same<allocator_type,
-        BOOST_DEDUCED_TYPENAME node_type::allocator_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<allocator_type,
+    BOOST_DEDUCED_TYPENAME node_type::allocator_type>::value));
 
-    // difference_type
+  // difference_type
 
-    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,
-        const_iterator_difference_type>::value));
+  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, const_iterator_difference_type>::value));
 
-    // size_type
+  // size_type
 
-    BOOST_STATIC_ASSERT(!std::numeric_limits<size_type>::is_signed);
-    BOOST_STATIC_ASSERT(std::numeric_limits<size_type>::is_integer);
+  BOOST_STATIC_ASSERT(!std::numeric_limits<size_type>::is_signed);
+  BOOST_STATIC_ASSERT(std::numeric_limits<size_type>::is_integer);
 
-    // 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)());
-    difference_type converted_diff(static_cast<difference_type>(max_diff));
-    BOOST_TEST((std::numeric_limits<difference_type>::max)() == converted_diff);
+  // 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)());
+  difference_type converted_diff(static_cast<difference_type>(max_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<difference_type>::max)()));
+  BOOST_TEST(
+    static_cast<comparison_type>((std::numeric_limits<size_type>::max)()) >
+    static_cast<comparison_type>(
+      (std::numeric_limits<difference_type>::max)()));
 
 // Constructors
 
 // 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
-    // constructor is implicit, but it is defined that way in the concrete
-    // container specification.
-    X u_implicit = {};
-    sink(u_implicit);
+  // It isn't specified in the container requirements that the no argument
+  // constructor is implicit, but it is defined that way in the concrete
+  // container specification.
+  X u_implicit = {};
+  sink(u_implicit);
 #endif
 
-    X u;
-    BOOST_TEST(u.size() == 0);
-    BOOST_TEST(X().size() == 0);
+  X u;
+  BOOST_TEST(u.size() == 0);
+  BOOST_TEST(X().size() == 0);
 
-    X a, b;
-    X a_const;
+  X a, b;
+  X a_const;
 
-    sink(X(a));
-    X u2(a);
-    X u3 = a;
-    X u4(rvalue(a_const));
-    X u5 = rvalue(a_const);
+  sink(X(a));
+  X u2(a);
+  X u3 = a;
+  X u4(rvalue(a_const));
+  X u5 = rvalue(a_const);
 
-    a.swap(b);
-    boost::swap(a, b);
-    test::check_return_type<X>::equals_ref(r = a);
+  a.swap(b);
+  boost::swap(a, b);
+  test::check_return_type<X>::equals_ref(r = a);
 
-    // Allocator
+  // Allocator
 
-    test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+  test::check_return_type<allocator_type>::equals(a_const.get_allocator());
 
-    allocator_type m = a.get_allocator();
-    sink(X(m));
-    X c(m);
-    sink(X(a_const, m));
-    X c2(a_const, m);
-    sink(X(rvalue(a_const), m));
-    X c3(rvalue(a_const), m);
+  allocator_type m = a.get_allocator();
+  sink(X(m));
+  X c(m);
+  sink(X(a_const, m));
+  X c2(a_const, m);
+  sink(X(rvalue(a_const), m));
+  X c3(rvalue(a_const), m);
 
-    // node_type
+  // node_type
 
-    implicit_construct<node_type const>();
+  implicit_construct<node_type const>();
 #if !BOOST_COMP_GNUC || BOOST_COMP_GNUC >= BOOST_VERSION_NUMBER(4, 8, 0)
-    TEST_NOEXCEPT_EXPR(node_type());
+  TEST_NOEXCEPT_EXPR(node_type());
 #endif
 
-    node_type n1;
-    node_type n2(rvalue_default<node_type>());
+  node_type n1;
+  node_type n2(rvalue_default<node_type>());
 #if !BOOST_COMP_GNUC || BOOST_COMP_GNUC >= BOOST_VERSION_NUMBER(4, 8, 0)
-    TEST_NOEXCEPT_EXPR(node_type(boost::move(n1)));
+  TEST_NOEXCEPT_EXPR(node_type(boost::move(n1)));
 #endif
-    node_type n3;
-    n3 = boost::move(n2);
-    n1.swap(n3);
-    swap(n1, n3);
-    // TODO: noexcept for swap?
-    // value, key, mapped tests in map and set specific testing.
+  node_type n3;
+  n3 = boost::move(n2);
+  n1.swap(n3);
+  swap(n1, n3);
+  // TODO: noexcept for swap?
+  // value, key, mapped tests in map and set specific testing.
 
-    node_type const n_const;
-    BOOST_TEST(n_const ? 0 : 1);
-    TEST_NOEXCEPT_EXPR(n_const ? 0 : 1);
-    test::check_return_type<bool>::equals(!n_const);
-    test::check_return_type<bool>::equals(n_const.empty());
-    TEST_NOEXCEPT_EXPR(!n_const);
-    TEST_NOEXCEPT_EXPR(n_const.empty());
+  node_type const n_const;
+  BOOST_TEST(n_const ? 0 : 1);
+  TEST_NOEXCEPT_EXPR(n_const ? 0 : 1);
+  test::check_return_type<bool>::equals(!n_const);
+  test::check_return_type<bool>::equals(n_const.empty());
+  TEST_NOEXCEPT_EXPR(!n_const);
+  TEST_NOEXCEPT_EXPR(n_const.empty());
 
-    // Avoid unused variable warnings:
+  // Avoid unused variable warnings:
 
-    sink(u);
-    sink(u2);
-    sink(u3);
-    sink(u4);
-    sink(u5);
-    sink(c);
-    sink(c2);
-    sink(c3);
+  sink(u);
+  sink(u2);
+  sink(u3);
+  sink(u4);
+  sink(u5);
+  sink(c);
+  sink(c2);
+  sink(c3);
 }
 
 template <class X> void unordered_destructible_test(X&)
 {
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
 
-    X x1;
+  X x1;
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    X x2(rvalue_default<X>());
-    X x3 = rvalue_default<X>();
+  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>();
 #endif
 
-    X* ptr = new X();
-    X& a1 = *ptr;
-    (&a1)->~X();
-    ::operator delete((void*)(&a1));
+  X* ptr = new X();
+  X& a1 = *ptr;
+  (&a1)->~X();
+  ::operator delete((void*)(&a1));
 
-    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());
-    test::check_return_type<const_iterator>::equals(a.cbegin());
-    test::check_return_type<const_iterator>::equals(a_const.cbegin());
-    test::check_return_type<iterator>::equals(a.end());
-    test::check_return_type<const_iterator>::equals(a_const.end());
-    test::check_return_type<const_iterator>::equals(a.cend());
-    test::check_return_type<const_iterator>::equals(a_const.cend());
+  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());
+  test::check_return_type<const_iterator>::equals(a.cbegin());
+  test::check_return_type<const_iterator>::equals(a_const.cbegin());
+  test::check_return_type<iterator>::equals(a.end());
+  test::check_return_type<const_iterator>::equals(a_const.end());
+  test::check_return_type<const_iterator>::equals(a.cend());
+  test::check_return_type<const_iterator>::equals(a_const.cend());
 
-    a.swap(b);
-    boost::swap(a, b);
+  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());
+  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());
 
-    // Allocator
+  // Allocator
 
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
-    test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  test::check_return_type<allocator_type>::equals(a_const.get_allocator());
 }
 
 template <class X, class Key> void unordered_set_test(X& r, Key const&)
 {
-    typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
-    typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+  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, key_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type, key_type>::value));
 
-    // iterator pointer / const_pointer_type
+  // iterator pointer / const_pointer_type
 
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    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 X::iterator iterator;
+  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;
 
-    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));
 
-    typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type;
-    BOOST_STATIC_ASSERT((boost::is_same<value_type, node_value_type>::value));
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type;
+  BOOST_STATIC_ASSERT((boost::is_same<value_type, node_value_type>::value));
 
-    // Call node_type functions.
+  // Call node_type functions.
 
-    test::minimal::constructor_param v;
-    Key k_lvalue(v);
-    r.emplace(boost::move(k_lvalue));
-    node_type n1 = r.extract(r.begin());
-    test::check_return_type<value_type>::equals_ref(n1.value());
+  test::minimal::constructor_param v;
+  Key k_lvalue(v);
+  r.emplace(boost::move(k_lvalue));
+  node_type n1 = r.extract(r.begin());
+  test::check_return_type<value_type>::equals_ref(n1.value());
 }
 
 template <class X, class Key, class T>
 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;
+  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
+  // iterator pointer / const_pointer_type
 
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    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 X::iterator iterator;
+  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;
 
-    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*, 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));
 
-    typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type;
-    typedef BOOST_DEDUCED_TYPENAME node_type::mapped_type node_mapped_type;
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type;
+  typedef BOOST_DEDUCED_TYPENAME node_type::mapped_type node_mapped_type;
 
-    BOOST_STATIC_ASSERT((boost::is_same<Key, node_key_type>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<T, node_mapped_type>::value));
-    // Superfluous,but just to make sure.
-    BOOST_STATIC_ASSERT((!boost::is_const<node_key_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<Key, node_key_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<T, node_mapped_type>::value));
+  // Superfluous,but just to make sure.
+  BOOST_STATIC_ASSERT((!boost::is_const<node_key_type>::value));
 
-    // Calling functions
+  // Calling functions
 
-    r.insert(std::pair<Key const, T>(k, v));
-    r.insert(r.begin(), std::pair<Key const, T>(k, v));
-    std::pair<Key const, T> const value(k, v);
-    r.insert(value);
-    r.insert(r.end(), value);
+  r.insert(std::pair<Key const, T>(k, v));
+  r.insert(r.begin(), std::pair<Key const, T>(k, v));
+  std::pair<Key const, T> const value(k, v);
+  r.insert(value);
+  r.insert(r.end(), value);
 
-    Key k_lvalue(k);
-    T v_lvalue(v);
+  Key k_lvalue(k);
+  T v_lvalue(v);
 
-    // Emplace
+  // Emplace
 
-    r.emplace(k, v);
-    r.emplace(k_lvalue, v_lvalue);
-    r.emplace(rvalue(k), rvalue(v));
+  r.emplace(k, 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));
 
-    // Emplace with hint
+  // Emplace with hint
 
-    r.emplace_hint(r.begin(), k, v);
-    r.emplace_hint(r.begin(), k_lvalue, v_lvalue);
-    r.emplace_hint(r.begin(), rvalue(k), rvalue(v));
+  r.emplace_hint(r.begin(), k, v);
+  r.emplace_hint(r.begin(), k_lvalue, v_lvalue);
+  r.emplace_hint(r.begin(), rvalue(k), rvalue(v));
 
-    r.emplace_hint(r.begin(), boost::unordered::piecewise_construct,
-        boost::make_tuple(k), boost::make_tuple(v));
+  r.emplace_hint(r.begin(), boost::unordered::piecewise_construct,
+    boost::make_tuple(k), boost::make_tuple(v));
 
-    // Extract
+  // Extract
 
-    test::check_return_type<node_type>::equals(r.extract(r.begin()));
+  test::check_return_type<node_type>::equals(r.extract(r.begin()));
 
-    r.emplace(k, v);
-    test::check_return_type<node_type>::equals(r.extract(k));
+  r.emplace(k, v);
+  test::check_return_type<node_type>::equals(r.extract(k));
 
-    r.emplace(k, v);
-    node_type n1 = r.extract(r.begin());
-    test::check_return_type<key_type>::equals_ref(n1.key());
-    test::check_return_type<T>::equals_ref(n1.mapped());
+  r.emplace(k, v);
+  node_type n1 = r.extract(r.begin());
+  test::check_return_type<key_type>::equals_ref(n1.key());
+  test::check_return_type<T>::equals_ref(n1.mapped());
 
-    node_type n2 = boost::move(n1);
-    r.insert(boost::move(n2));
-    r.insert(r.extract(r.begin()));
-    n2 = r.extract(r.begin());
-    r.insert(r.begin(), boost::move(n2));
-    r.insert(r.end(), r.extract(r.begin()));
+  node_type n2 = boost::move(n1);
+  r.insert(boost::move(n2));
+  r.insert(r.extract(r.begin()));
+  n2 = r.extract(r.begin());
+  r.insert(r.begin(), boost::move(n2));
+  r.insert(r.end(), r.extract(r.begin()));
 
-    node_type n = r.extract(r.begin());
-    test::check_return_type<node_key_type>::equals_ref(n.key());
-    test::check_return_type<node_mapped_type>::equals_ref(n.mapped());
+  node_type n = r.extract(r.begin());
+  test::check_return_type<node_key_type>::equals_ref(n.key());
+  test::check_return_type<node_mapped_type>::equals_ref(n.mapped());
 }
 
 template <class X> void equality_test(X& r)
 {
-    X const a = r, b = r;
+  X const a = r, b = r;
 
-    test::check_return_type<bool>::equals(a == b);
-    test::check_return_type<bool>::equals(a != b);
-    test::check_return_type<bool>::equals(boost::operator==(a, b));
-    test::check_return_type<bool>::equals(boost::operator!=(a, b));
+  test::check_return_type<bool>::equals(a == b);
+  test::check_return_type<bool>::equals(a != b);
+  test::check_return_type<bool>::equals(boost::operator==(a, b));
+  test::check_return_type<bool>::equals(boost::operator!=(a, b));
 }
 
 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));
+  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));
 
-    typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME X::insert_return_type insert_return_type;
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME X::insert_return_type insert_return_type;
 
-    // insert_return_type
+  // insert_return_type
 
-    // TODO;
-    // boost::function_requires<boost::MoveConstructibleConcept<insert_return_type>
-    // >();
-    // TODO;
-    // boost::function_requires<boost::MoveAssignableConcept<insert_return_type>
-    // >();
-    boost::function_requires<
-        boost::DefaultConstructibleConcept<insert_return_type> >();
-    // TODO:
-    // boost::function_requires<boost::DestructibleConcept<insert_return_type>
-    // >();
-    insert_return_type insert_return, insert_return2;
-    test::check_return_type<bool>::equals(insert_return.inserted);
-    test::check_return_type<iterator>::equals(insert_return.position);
-    test::check_return_type<node_type>::equals_ref(insert_return.node);
-    boost::swap(insert_return, insert_return2);
+  // TODO;
+  // boost::function_requires<boost::MoveConstructibleConcept<insert_return_type>
+  // >();
+  // TODO;
+  // boost::function_requires<boost::MoveAssignableConcept<insert_return_type>
+  // >();
+  boost::function_requires<
+    boost::DefaultConstructibleConcept<insert_return_type> >();
+  // TODO:
+  // boost::function_requires<boost::DestructibleConcept<insert_return_type>
+  // >();
+  insert_return_type insert_return, insert_return2;
+  test::check_return_type<bool>::equals(insert_return.inserted);
+  test::check_return_type<iterator>::equals(insert_return.position);
+  test::check_return_type<node_type>::equals_ref(insert_return.node);
+  boost::swap(insert_return, insert_return2);
 }
 
 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));
-    test::check_return_type<iterator>::equals(r.emplace(t));
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  test::check_return_type<iterator>::equals(r.insert(t));
+  test::check_return_type<iterator>::equals(r.emplace(t));
 }
 
 template <class X, class Key, class T>
 void unordered_map_functions(X&, Key const& k, T const& v)
 {
-    typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
-    X a;
-    test::check_return_type<mapped_type>::equals_ref(a[k]);
-    test::check_return_type<mapped_type>::equals_ref(a[rvalue(k)]);
-    test::check_return_type<mapped_type>::equals_ref(a.at(k));
-    test::check_return_type<std::pair<iterator, bool> >::equals(
-        a.try_emplace(k, v));
-    test::check_return_type<std::pair<iterator, bool> >::equals(
-        a.try_emplace(rvalue(k), v));
-    test::check_return_type<iterator>::equals(a.try_emplace(a.begin(), k, v));
-    test::check_return_type<iterator>::equals(
-        a.try_emplace(a.begin(), rvalue(k), v));
-    test::check_return_type<std::pair<iterator, bool> >::equals(
-        a.insert_or_assign(k, v));
-    test::check_return_type<std::pair<iterator, bool> >::equals(
-        a.insert_or_assign(rvalue(k), v));
-    test::check_return_type<iterator>::equals(
-        a.insert_or_assign(a.begin(), k, v));
-    test::check_return_type<iterator>::equals(
-        a.insert_or_assign(a.begin(), rvalue(k), v));
+  X a;
+  test::check_return_type<mapped_type>::equals_ref(a[k]);
+  test::check_return_type<mapped_type>::equals_ref(a[rvalue(k)]);
+  test::check_return_type<mapped_type>::equals_ref(a.at(k));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.try_emplace(k, v));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.try_emplace(rvalue(k), v));
+  test::check_return_type<iterator>::equals(a.try_emplace(a.begin(), k, v));
+  test::check_return_type<iterator>::equals(
+    a.try_emplace(a.begin(), rvalue(k), v));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.insert_or_assign(k, v));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.insert_or_assign(rvalue(k), v));
+  test::check_return_type<iterator>::equals(
+    a.insert_or_assign(a.begin(), k, v));
+  test::check_return_type<iterator>::equals(
+    a.insert_or_assign(a.begin(), rvalue(k), v));
 
-    X const b = a;
-    test::check_return_type<mapped_type const>::equals_ref(b.at(k));
+  X const b = a;
+  test::check_return_type<mapped_type const>::equals_ref(b.at(k));
 }
 
 template <class X, class Key, class Hash, class Pred>
 void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
 {
-    unordered_destructible_test(x);
+  unordered_destructible_test(x);
 
-    typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-    typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
-    typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
-    typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+  typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+  typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
+  typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
+  typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
 
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    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 X::iterator iterator;
+  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::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
-        iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<iterator>::type
-        iterator_reference;
+  typedef BOOST_DEDUCED_TYPENAME 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
+    iterator_pointer;
+  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
-        local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
-        local_iterator>::type local_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
+    local_iterator_pointer;
+  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
-        const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
-        const_iterator>::type const_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
+    const_iterator_pointer;
+  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 X::allocator_type allocator_type;
+  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_STATIC_ASSERT((boost::is_same<Key, key_type>::value));
+  // 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));
+  BOOST_STATIC_ASSERT((boost::is_same<Hash, hasher>::value));
+  test::check_return_type<std::size_t>::equals(hf(k));
 
-    BOOST_STATIC_ASSERT((boost::is_same<Pred, key_equal>::value));
-    test::check_return_type<bool>::convertible(eq(k, k));
+  BOOST_STATIC_ASSERT((boost::is_same<Pred, key_equal>::value));
+  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::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::function_requires<
-        boost::InputIteratorConcept<const_local_iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_category,
-        const_iterator_category>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_difference,
-        const_iterator_difference>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_pointer,
-        const_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_reference,
-        const_iterator_reference>::value));
+  boost::function_requires<
+    boost::InputIteratorConcept<const_local_iterator> >();
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_category,
+    const_iterator_category>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_difference,
+    const_iterator_difference>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_pointer,
+    const_iterator_pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_reference,
+    const_iterator_reference>::value));
 
-    X a;
-    allocator_type m = a.get_allocator();
+  X a;
+  allocator_type m = a.get_allocator();
 
-    // Constructors
+  // Constructors
 
-    X(10, hf, eq);
-    X a1(10, hf, eq);
-    X(10, hf);
-    X a2(10, hf);
-    X(10);
-    X a3(10);
-    X();
-    X a4;
+  X(10, hf, eq);
+  X a1(10, hf, eq);
+  X(10, hf);
+  X a2(10, hf);
+  X(10);
+  X a3(10);
+  X();
+  X a4;
 
-    X(10, hf, eq, m);
-    X a1a(10, hf, eq, m);
-    X(10, hf, m);
-    X a2a(10, hf, m);
-    X(10, m);
-    X a3a(10, m);
-    (X(m));
-    X a4a(m);
+  X(10, hf, eq, m);
+  X a1a(10, hf, eq, m);
+  X(10, hf, m);
+  X a2a(10, hf, m);
+  X(10, m);
+  X a3a(10, m);
+  (X(m));
+  X a4a(m);
 
-    test::check_return_type<size_type>::equals(a.erase(k));
+  test::check_return_type<size_type>::equals(a.erase(k));
 
-    const_iterator q1 = a.cbegin(), q2 = a.cend();
-    test::check_return_type<iterator>::equals(a.erase(q1, q2));
+  const_iterator q1 = a.cbegin(), q2 = a.cend();
+  test::check_return_type<iterator>::equals(a.erase(q1, q2));
 
-    TEST_NOEXCEPT_EXPR(a.clear());
-    a.clear();
+  TEST_NOEXCEPT_EXPR(a.clear());
+  a.clear();
 
-    X const b;
+  X const b;
 
-    test::check_return_type<hasher>::equals(b.hash_function());
-    test::check_return_type<key_equal>::equals(b.key_eq());
+  test::check_return_type<hasher>::equals(b.hash_function());
+  test::check_return_type<key_equal>::equals(b.key_eq());
 
-    test::check_return_type<iterator>::equals(a.find(k));
-    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));
-    test::check_return_type<std::pair<const_iterator, const_iterator> >::equals(
-        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));
-    test::check_return_type<size_type>::equals(b.bucket_size(0));
+  test::check_return_type<iterator>::equals(a.find(k));
+  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));
+  test::check_return_type<std::pair<const_iterator, const_iterator> >::equals(
+    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));
+  test::check_return_type<size_type>::equals(b.bucket_size(0));
 
-    test::check_return_type<local_iterator>::equals(a.begin(0));
-    test::check_return_type<const_local_iterator>::equals(b.begin(0));
-    test::check_return_type<local_iterator>::equals(a.end(0));
-    test::check_return_type<const_local_iterator>::equals(b.end(0));
+  test::check_return_type<local_iterator>::equals(a.begin(0));
+  test::check_return_type<const_local_iterator>::equals(b.begin(0));
+  test::check_return_type<local_iterator>::equals(a.end(0));
+  test::check_return_type<const_local_iterator>::equals(b.end(0));
 
-    test::check_return_type<const_local_iterator>::equals(a.cbegin(0));
-    test::check_return_type<const_local_iterator>::equals(b.cbegin(0));
-    test::check_return_type<const_local_iterator>::equals(a.cend(0));
-    test::check_return_type<const_local_iterator>::equals(b.cend(0));
+  test::check_return_type<const_local_iterator>::equals(a.cbegin(0));
+  test::check_return_type<const_local_iterator>::equals(b.cbegin(0));
+  test::check_return_type<const_local_iterator>::equals(a.cend(0));
+  test::check_return_type<const_local_iterator>::equals(b.cend(0));
 
-    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.rehash(100);
+  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.rehash(100);
 
-    a.merge(a2);
+  a.merge(a2);
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    a.merge(rvalue_default<X>());
+  a.merge(rvalue_default<X>());
 #endif
 
-    // Avoid unused variable warnings:
+  // Avoid unused variable warnings:
 
-    sink(a);
-    sink(a1);
-    sink(a2);
-    sink(a3);
-    sink(a4);
-    sink(a1a);
-    sink(a2a);
-    sink(a3a);
-    sink(a4a);
+  sink(a);
+  sink(a1);
+  sink(a2);
+  sink(a3);
+  sink(a4);
+  sink(a1a);
+  sink(a2a);
+  sink(a3a);
+  sink(a4a);
 }
 
 template <class X, class Key, class T, class Hash, class Pred>
 void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
 {
-    unordered_test(x, k, hf, eq);
+  unordered_test(x, k, hf, eq);
 
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
-    X a;
-    allocator_type m = a.get_allocator();
+  X a;
+  allocator_type m = a.get_allocator();
 
-    BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
-    BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
+  BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
+  BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
 
-    // Constructors
+  // Constructors
 
-    X(i, j, 10, hf, eq);
-    X a5(i, j, 10, hf, eq);
-    X(i, j, 10, hf);
-    X a6(i, j, 10, hf);
-    X(i, j, 10);
-    X a7(i, j, 10);
-    X(i, j);
-    X a8(i, j);
+  X(i, j, 10, hf, eq);
+  X a5(i, j, 10, hf, eq);
+  X(i, j, 10, hf);
+  X a6(i, j, 10, hf);
+  X(i, j, 10);
+  X a7(i, j, 10);
+  X(i, j);
+  X a8(i, j);
 
-    X(i, j, 10, hf, eq, m);
-    X a5a(i, j, 10, hf, eq, m);
-    X(i, j, 10, hf, m);
-    X a6a(i, j, 10, hf, m);
-    X(i, j, 10, m);
-    X a7a(i, j, 10, m);
+  X(i, j, 10, hf, eq, m);
+  X a5a(i, j, 10, hf, eq, m);
+  X(i, j, 10, hf, m);
+  X a6a(i, j, 10, hf, m);
+  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);
@@ -668,172 +667,171 @@ void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
 // sink(a8a);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    std::size_t min_buckets = 10;
-    X({t});
-    X({t}, min_buckets);
-    X({t}, min_buckets, hf);
-    X({t}, min_buckets, hf, eq);
-    // X({t}, m);
-    X({t}, min_buckets, m);
-    X({t}, min_buckets, hf, m);
-    X({t}, min_buckets, hf, eq, m);
+  std::size_t min_buckets = 10;
+  X({t});
+  X({t}, min_buckets);
+  X({t}, min_buckets, hf);
+  X({t}, min_buckets, hf, eq);
+  // X({t}, m);
+  X({t}, min_buckets, m);
+  X({t}, min_buckets, hf, m);
+  X({t}, min_buckets, hf, eq, m);
 #endif
 
-    X const b;
-    sink(X(b));
-    X a9(b);
-    a = b;
+  X const b;
+  sink(X(b));
+  X a9(b);
+  a = b;
 
-    sink(X(b, m));
-    X a9a(b, m);
+  sink(X(b, m));
+  X a9a(b, m);
 
-    X b1;
-    b1.insert(t);
-    X a9b(b1);
-    sink(a9b);
-    X a9c(b1, m);
-    sink(a9c);
+  X b1;
+  b1.insert(t);
+  X a9b(b1);
+  sink(a9b);
+  X a9c(b1, m);
+  sink(a9c);
 
-    const_iterator q = a.cbegin();
+  const_iterator q = a.cbegin();
 
-    test::check_return_type<iterator>::equals(a.insert(q, t));
-    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
+  test::check_return_type<iterator>::equals(a.insert(q, t));
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
 
-    a.insert(i, j);
+  a.insert(i, j);
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    std::initializer_list<T> list = {t};
-    a.insert(list);
-    a.insert({t, t, t});
+  std::initializer_list<T> list = {t};
+  a.insert(list);
+  a.insert({t, t, t});
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1900) &&                                   \
-    (!defined(__clang__) || __clang_major__ >= 4 ||                            \
-        (__clang_major__ == 3 && __clang_minor__ >= 4))
-    a.insert({});
-    a.insert({t});
-    a.insert({t, t});
+  (!defined(__clang__) || __clang_major__ >= 4 ||                              \
+    (__clang_major__ == 3 && __clang_minor__ >= 4))
+  a.insert({});
+  a.insert({t});
+  a.insert({t, t});
 #endif
 #endif
 
-    X a10;
-    a10.insert(t);
-    q = a10.cbegin();
-    test::check_return_type<iterator>::equals(a10.erase(q));
+  X a10;
+  a10.insert(t);
+  q = a10.cbegin();
+  test::check_return_type<iterator>::equals(a10.erase(q));
 
-    // Avoid unused variable warnings:
+  // Avoid unused variable warnings:
 
-    sink(a);
-    sink(a5);
-    sink(a6);
-    sink(a7);
-    sink(a8);
-    sink(a9);
-    sink(a5a);
-    sink(a6a);
-    sink(a7a);
-    sink(a9a);
+  sink(a);
+  sink(a5);
+  sink(a6);
+  sink(a7);
+  sink(a8);
+  sink(a9);
+  sink(a5a);
+  sink(a6a);
+  sink(a7a);
+  sink(a9a);
 
-    typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
-    node_type const n_const = a.extract(a.begin());
-    test::check_return_type<allocator_type>::equals(n_const.get_allocator());
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  node_type const n_const = a.extract(a.begin());
+  test::check_return_type<allocator_type>::equals(n_const.get_allocator());
 }
 
 template <class X, class Key, class T, class Hash, class Pred>
 void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
 {
-    unordered_test(x, k, hf, eq);
+  unordered_test(x, k, hf, eq);
 
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    X x1(rvalue_default<X>());
-    X x2(boost::move(x1));
-    x1 = rvalue_default<X>();
-    x2 = boost::move(x1);
+  X x1(rvalue_default<X>());
+  X x2(boost::move(x1));
+  x1 = rvalue_default<X>();
+  x2 = boost::move(x1);
 #endif
 
-    X a;
-    allocator_type m = a.get_allocator();
+  X a;
+  allocator_type m = a.get_allocator();
 
-    test::minimal::constructor_param* i = 0;
-    test::minimal::constructor_param* j = 0;
+  test::minimal::constructor_param* i = 0;
+  test::minimal::constructor_param* j = 0;
 
-    // Constructors
+  // Constructors
 
-    X(i, j, 10, hf, eq);
-    X a5(i, j, 10, hf, eq);
-    X(i, j, 10, hf);
-    X a6(i, j, 10, hf);
-    X(i, j, 10);
-    X a7(i, j, 10);
-    X(i, j);
-    X a8(i, j);
+  X(i, j, 10, hf, eq);
+  X a5(i, j, 10, hf, eq);
+  X(i, j, 10, hf);
+  X a6(i, j, 10, hf);
+  X(i, j, 10);
+  X a7(i, j, 10);
+  X(i, j);
+  X a8(i, j);
 
-    X(i, j, 10, hf, eq, m);
-    X a5a(i, j, 10, hf, eq, m);
-    X(i, j, 10, hf, m);
-    X a6a(i, j, 10, hf, m);
-    X(i, j, 10, m);
-    X a7a(i, j, 10, m);
+  X(i, j, 10, hf, eq, m);
+  X a5a(i, j, 10, hf, eq, m);
+  X(i, j, 10, hf, m);
+  X a6a(i, j, 10, hf, m);
+  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);
 
-    const_iterator q = a.cbegin();
+  const_iterator q = a.cbegin();
 
-    test::minimal::constructor_param v;
-    a.emplace(v);
-    test::check_return_type<iterator>::equals(a.emplace_hint(q, v));
+  test::minimal::constructor_param v;
+  a.emplace(v);
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, v));
 
-    T v1(v);
-    a.emplace(boost::move(v1));
-    T v2(v);
-    a.insert(boost::move(v2));
-    T v3(v);
-    test::check_return_type<iterator>::equals(
-        a.emplace_hint(q, boost::move(v3)));
-    T v4(v);
-    test::check_return_type<iterator>::equals(a.insert(q, boost::move(v4)));
+  T v1(v);
+  a.emplace(boost::move(v1));
+  T v2(v);
+  a.insert(boost::move(v2));
+  T v3(v);
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, boost::move(v3)));
+  T v4(v);
+  test::check_return_type<iterator>::equals(a.insert(q, boost::move(v4)));
 
-    a.insert(i, j);
+  a.insert(i, j);
 
-    X a10;
-    T v5(v);
-    a10.insert(boost::move(v5));
-    q = a10.cbegin();
-    test::check_return_type<iterator>::equals(a10.erase(q));
+  X a10;
+  T v5(v);
+  a10.insert(boost::move(v5));
+  q = a10.cbegin();
+  test::check_return_type<iterator>::equals(a10.erase(q));
 
-    // Avoid unused variable warnings:
+  // Avoid unused variable warnings:
 
-    sink(a);
-    sink(a5);
-    sink(a6);
-    sink(a7);
-    sink(a8);
-    sink(a5a);
-    sink(a6a);
-    sink(a7a);
-    sink(a10);
+  sink(a);
+  sink(a5);
+  sink(a6);
+  sink(a7);
+  sink(a8);
+  sink(a5a);
+  sink(a6a);
+  sink(a7a);
+  sink(a10);
 }
 
 template <class X, class T> void unordered_set_member_test(X& x, T& t)
 {
-    X x1(x);
-    x1.insert(t);
-    x1.begin()->dummy_member();
-    x1.cbegin()->dummy_member();
+  X x1(x);
+  x1.insert(t);
+  x1.begin()->dummy_member();
+  x1.cbegin()->dummy_member();
 }
 
 template <class X, class T> void unordered_map_member_test(X& x, T& t)
 {
-    X x1(x);
-    x1.insert(t);
-    x1.begin()->first.dummy_member();
-    x1.cbegin()->first.dummy_member();
-    x1.begin()->second.dummy_member();
-    x1.cbegin()->second.dummy_member();
+  X x1(x);
+  x1.insert(t);
+  x1.begin()->first.dummy_member();
+  x1.cbegin()->first.dummy_member();
+  x1.begin()->second.dummy_member();
+  x1.cbegin()->second.dummy_member();
 }
diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp
index 4c967ded..0728a1e7 100644
--- a/test/unordered/constructor_tests.cpp
+++ b/test/unordered/constructor_tests.cpp
@@ -20,161 +20,162 @@
 
 namespace constructor_tests {
 
-test::seed_t initialize_seed(356730);
+  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;
 
     UNORDERED_SUB_TEST("Construct 1")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(0, hf, eq);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      T x(0, hf, eq);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 2")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(100, hf);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 100);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      T x(100, hf);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 100);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 3")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(2000);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 2000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      T x(2000);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 2000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 4")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x;
-        BOOST_TEST(x.empty());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      T x;
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 5")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
-        T x(v.begin(), v.end(), 10000, hf, eq);
-        BOOST_TEST(x.bucket_count() >= 10000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end(), 10000, hf, eq);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 6")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(10, generator);
-        T x(v.begin(), v.end(), 10000, hf);
-        BOOST_TEST(x.bucket_count() >= 10000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::random_values<T> v(10, generator);
+      T x(v.begin(), v.end(), 10000, hf);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 7")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(100, generator);
-        T x(v.begin(), v.end(), 100);
-        BOOST_TEST(x.bucket_count() >= 100);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 100);
+      BOOST_TEST(x.bucket_count() >= 100);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 8")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1, generator);
-        T x(v.begin(), v.end());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::random_values<T> v(1, generator);
+      T x(v.begin(), v.end());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 9")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(0, hf, eq, al);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      T x(0, hf, eq, al);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 10")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
-        T x(v.begin(), v.end(), 10000, hf, eq, al);
-        BOOST_TEST(x.bucket_count() >= 10000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end(), 10000, hf, eq, al);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 11")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(al);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      T x(al);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
-}
+  }
 
-template <class T>
-void constructor_tests2(T*, test::random_generator const& generator)
-{
+  template <class T>
+  void constructor_tests2(T*, test::random_generator const& generator)
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
@@ -187,134 +188,135 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     UNORDERED_SUB_TEST("Construct 1")
     {
-        test::check_instances check_;
-        T x(10000, hf1, eq1);
-        BOOST_TEST(x.bucket_count() >= 10000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      test::check_instances check_;
+      T x(10000, hf1, eq1);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 2")
     {
-        test::check_instances check_;
-        T x(100, hf1);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 100);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_equivalent_keys(x);
+      test::check_instances check_;
+      T x(100, hf1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 100);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 3")
     {
-        test::check_instances check_;
-        test::random_values<T> v(100, generator);
-        T x(v.begin(), v.end(), 0, hf1, eq1);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf1, eq1);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 4")
     {
-        test::check_instances check_;
-        test::random_values<T> v(5, generator);
-        T x(v.begin(), v.end(), 1000, hf1);
-        BOOST_TEST(x.bucket_count() >= 1000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::check_instances check_;
+      test::random_values<T> v(5, generator);
+      T x(v.begin(), v.end(), 1000, hf1);
+      BOOST_TEST(x.bucket_count() >= 1000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("Construct 5")
     {
-        test::check_instances check_;
-        test::random_values<T> v(100, generator);
-        T x(v.begin(), v.end(), 0, hf, eq, al1);
-        T y(x.begin(), x.end(), 0, hf1, eq1, al2);
-        test::check_container(x, v);
-        test::check_container(y, x);
-        test::check_equivalent_keys(x);
-        test::check_equivalent_keys(y);
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf, eq, al1);
+      T y(x.begin(), x.end(), 0, hf1, eq1, al2);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
     }
 
     UNORDERED_SUB_TEST("Construct 6")
     {
-        test::check_instances check_;
-        test::random_values<T> v(100, generator);
-        T x(v.begin(), v.end(), 0, hf1, eq1);
-        T y(x.begin(), x.end(), 0, hf, eq);
-        test::check_container(x, v);
-        test::check_container(y, x);
-        test::check_equivalent_keys(x);
-        test::check_equivalent_keys(y);
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf1, eq1);
+      T y(x.begin(), x.end(), 0, hf, eq);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
     }
 
     UNORDERED_SUB_TEST("Construct 7")
     {
-        test::check_instances check_;
-        test::random_values<T> v(100, generator);
-        T x(v.begin(), v.end(), 0, hf1, eq1);
-        T y(x.begin(), 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);
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf1, eq1);
+      T y(x.begin(), 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);
     }
 
     UNORDERED_SUB_TEST("Construct 8 - from input iterator")
     {
-        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);
-        test::check_container(x, v);
-        test::check_container(y, x);
-        test::check_equivalent_keys(x);
-        test::check_equivalent_keys(y);
+      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);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
     }
 
     UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
     {
-        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);
-        test::check_container(x, v);
-        test::check_container(y, x);
-        test::check_equivalent_keys(x);
-        test::check_equivalent_keys(y);
+      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);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
     }
 
     UNORDERED_SUB_TEST("Construct 9")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(100, generator);
-        T x(50);
-        BOOST_TEST(x.bucket_count() >= 50);
-        x.max_load_factor(10);
-        BOOST_TEST(x.bucket_count() >= 50);
-        x.insert(v.begin(), v.end());
-        BOOST_TEST(x.bucket_count() >= 50);
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
+      test::random_values<T> v(100, generator);
+      T x(50);
+      BOOST_TEST(x.bucket_count() >= 50);
+      x.max_load_factor(10);
+      BOOST_TEST(x.bucket_count() >= 50);
+      x.insert(v.begin(), v.end());
+      BOOST_TEST(x.bucket_count() >= 50);
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
     }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -322,126 +324,126 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     UNORDERED_SUB_TEST("Initializer list construct 1")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(list);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      T x(list);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
     UNORDERED_SUB_TEST("Initializer list construct 2")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(list, 1000);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 1000);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      T x(list, 1000);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 1000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
     UNORDERED_SUB_TEST("Initializer list construct 3")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(list, 10, hf1);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 10);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      T x(list, 10, hf1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 10);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
     UNORDERED_SUB_TEST("Initializer list construct 4")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(list, 10, hf1, eq1);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 10);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      T x(list, 10, hf1, eq1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 10);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
     UNORDERED_SUB_TEST("Initializer list construct 5")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(list, 10, hf1, eq1, al1);
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.bucket_count() >= 10);
-        BOOST_TEST(test::equivalent(x.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x.get_allocator(), al1));
+      T x(list, 10, hf1, eq1, al1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 10);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al1));
     }
 #endif
-}
+  }
 
-template <class T>
-void map_constructor_test(T*, test::random_generator const& generator)
-{
+  template <class T>
+  void map_constructor_test(T*, test::random_generator const& generator)
+  {
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
-        BOOST_DEDUCED_TYPENAME T::mapped_type> >
-        list;
+      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());
 
     test::check_container(x, v);
     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,
+  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;
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
 
-UNORDERED_TEST(constructor_tests1,
+  UNORDERED_TEST(constructor_tests1,
     ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(constructor_tests2,
+  UNORDERED_TEST(constructor_tests2,
     ((test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(map_constructor_test,
+  UNORDERED_TEST(map_constructor_test,
     ((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)
-{
+  UNORDERED_AUTO_TEST(test_default_initializer_list)
+  {
     std::initializer_list<int> init;
     boost::unordered_set<int> x1 = init;
     BOOST_TEST(x1.empty());
-}
+  }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(test_initializer_list)
-{
+  UNORDERED_AUTO_TEST(test_initializer_list)
+  {
     boost::unordered_set<int> x1 = {2, 10, 45, -5};
     BOOST_TEST(x1.find(10) != x1.end());
     BOOST_TEST(x1.find(46) == x1.end());
-}
+  }
 
 #endif
 }
diff --git a/test/unordered/copy_tests.cpp b/test/unordered/copy_tests.cpp
index 5cd5187a..a2afd64b 100644
--- a/test/unordered/copy_tests.cpp
+++ b/test/unordered/copy_tests.cpp
@@ -22,9 +22,9 @@ test::seed_t initialize_seed(9063);
 
 namespace copy_tests {
 
-template <class T>
-void copy_construct_tests1(T*, test::random_generator const& generator)
-{
+  template <class T>
+  void copy_construct_tests1(T*, test::random_generator const& generator)
+  {
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
     BOOST_DEDUCED_TYPENAME T::hasher hf;
@@ -32,58 +32,58 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
     BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x;
-        T y(x);
-        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(x.max_load_factor() == y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-                   (allocator_type::is_select_on_copy));
-        test::check_equivalent_keys(y);
+      T x;
+      T y(x);
+      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(x.max_load_factor() == y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
+      test::random_values<T> v(1000, generator);
 
-        T x(v.begin(), v.end());
-        T y(x);
-        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));
-        test::check_equivalent_keys(y);
+      T x(v.begin(), v.end());
+      T y(x);
+      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));
+      test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        // In this test I drop the original containers max load factor, so it
-        // is much lower than the load factor. The hash table is not allowed
-        // to rehash, but the destination container should probably allocate
-        // enough buckets to decrease the load factor appropriately.
-        test::random_values<T> v(1000, generator);
-        T x(v.begin(), v.end());
-        x.max_load_factor(x.load_factor() / 4);
-        T y(x);
-        test::unordered_equivalence_tester<T> equivalent(x);
-        BOOST_TEST(equivalent(y));
-        // 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));
-        test::check_equivalent_keys(y);
+      // In this test I drop the original containers max load factor, so it
+      // is much lower than the load factor. The hash table is not allowed
+      // to rehash, but the destination container should probably allocate
+      // enough buckets to decrease the load factor appropriately.
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end());
+      x.max_load_factor(x.load_factor() / 4);
+      T y(x);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      // 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));
+      test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
-void copy_construct_tests2(T*, test::random_generator const& generator)
-{
+  template <class T>
+  void copy_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);
@@ -92,117 +92,117 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(10000, hf, eq, al);
-        T y(x);
-        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(x.max_load_factor() == y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-                   (allocator_type::is_select_on_copy));
-        test::check_equivalent_keys(y);
+      T x(10000, hf, eq, al);
+      T y(x);
+      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(x.max_load_factor() == y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        T x(1000, hf, eq, al);
-        T y(x, al2);
-        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(), al2));
-        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-        test::check_equivalent_keys(y);
+      T x(1000, hf, eq, al);
+      T y(x, al2);
+      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(), al2));
+      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
+      test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
+      test::random_values<T> v(1000, generator);
 
-        T x(v.begin(), v.end(), 0, hf, eq, al);
-        T y(x);
-        test::unordered_equivalence_tester<T> equivalent(x);
-        BOOST_TEST(equivalent(y));
-        test::check_equivalent_keys(y);
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-                   (allocator_type::is_select_on_copy));
-        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+      T x(v.begin(), v.end(), 0, hf, eq, al);
+      T y(x);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      test::check_equivalent_keys(y);
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(500, generator);
+      test::random_values<T> v(500, generator);
 
-        T x(v.begin(), v.end(), 0, hf, eq, al);
-        T y(x, al2);
-        test::unordered_equivalence_tester<T> equivalent(x);
-        BOOST_TEST(equivalent(y));
-        test::check_equivalent_keys(y);
-        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      T x(v.begin(), v.end(), 0, hf, eq, al);
+      T y(x, al2);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      test::check_equivalent_keys(y);
+      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
+      BOOST_TEST(test::equivalent(y.get_allocator(), al2));
     }
-}
+  }
 
-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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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;
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
 
-UNORDERED_TEST(copy_construct_tests1,
+  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))(
+      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,
+  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))(
+      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)))
 }
 
diff --git a/test/unordered/detail_tests.cpp b/test/unordered/detail_tests.cpp
index 2af4c4fb..06341ce2 100644
--- a/test/unordered/detail_tests.cpp
+++ b/test/unordered/detail_tests.cpp
@@ -17,86 +17,86 @@
 // Might be too slow if we had larger primes?
 bool is_prime(std::size_t x)
 {
-    if (x == 2) {
-        return true;
-    } else if (x == 1 || x % 2 == 0) {
+  if (x == 2) {
+    return true;
+  } else if (x == 1 || x % 2 == 0) {
+    return false;
+  } else {
+    // y*y <= x had rounding errors, so instead use y <= (x/y).
+    for (std::size_t y = 3; y <= (x / y); y += 2) {
+      if (x % y == 0) {
         return false;
-    } else {
-        // y*y <= x had rounding errors, so instead use y <= (x/y).
-        for (std::size_t y = 3; y <= (x / y); y += 2) {
-            if (x % y == 0) {
-                return false;
-                break;
-            }
-        }
-
-        return true;
+        break;
+      }
     }
+
+    return true;
+  }
 }
 
 void test_next_prime(std::size_t value)
 {
-    std::size_t x = boost::unordered::detail::next_prime(value);
-    BOOST_TEST(is_prime(x));
-    BOOST_TEST(x >= value);
+  std::size_t x = boost::unordered::detail::next_prime(value);
+  BOOST_TEST(is_prime(x));
+  BOOST_TEST(x >= value);
 }
 
 void test_prev_prime(std::size_t value)
 {
-    std::size_t x = boost::unordered::detail::prev_prime(value);
-    BOOST_TEST(is_prime(x));
-    BOOST_TEST(x <= value);
-    if (x > value) {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM << x << "," << value << std::endl;
-    }
+  std::size_t x = boost::unordered::detail::prev_prime(value);
+  BOOST_TEST(is_prime(x));
+  BOOST_TEST(x <= value);
+  if (x > value) {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << x << "," << value << std::endl;
+  }
 }
 
 UNORDERED_AUTO_TEST(next_prime_test)
 {
-    BOOST_TEST(!is_prime(0));
-    BOOST_TEST(!is_prime(1));
-    BOOST_TEST(is_prime(2));
-    BOOST_TEST(is_prime(3));
-    BOOST_TEST(is_prime(13));
-    BOOST_TEST(!is_prime(4));
-    BOOST_TEST(!is_prime(100));
+  BOOST_TEST(!is_prime(0));
+  BOOST_TEST(!is_prime(1));
+  BOOST_TEST(is_prime(2));
+  BOOST_TEST(is_prime(3));
+  BOOST_TEST(is_prime(13));
+  BOOST_TEST(!is_prime(4));
+  BOOST_TEST(!is_prime(100));
 
-    BOOST_TEST(boost::unordered::detail::next_prime(0) > 0);
+  BOOST_TEST(boost::unordered::detail::next_prime(0) > 0);
 
-    // test_prev_prime doesn't work for values less than 17.
-    // Which should be okay, unless an allocator has a really tiny
-    // max_size?
-    const std::size_t min_prime = 17;
+  // test_prev_prime doesn't work for values less than 17.
+  // Which should be okay, unless an allocator has a really tiny
+  // max_size?
+  const std::size_t min_prime = 17;
 
-    // test_next_prime doesn't work for values greater than this,
-    // which might be a problem if you've got terrabytes of memory?
-    // I seriously doubt the container would work well at such sizes
-    // regardless.
-    const std::size_t max_prime = 4294967291ul;
+  // test_next_prime doesn't work for values greater than this,
+  // which might be a problem if you've got terrabytes of memory?
+  // I seriously doubt the container would work well at such sizes
+  // regardless.
+  const std::size_t max_prime = 4294967291ul;
 
-    std::size_t i;
+  std::size_t i;
 
-    BOOST_TEST(is_prime(min_prime));
-    BOOST_TEST(is_prime(max_prime));
+  BOOST_TEST(is_prime(min_prime));
+  BOOST_TEST(is_prime(max_prime));
 
-    for (i = 0; i < 10000; ++i) {
-        if (i < min_prime) {
-            BOOST_TEST(boost::unordered::detail::prev_prime(i) == min_prime);
-        } else {
-            test_prev_prime(i);
-        }
-        test_next_prime(i);
+  for (i = 0; i < 10000; ++i) {
+    if (i < min_prime) {
+      BOOST_TEST(boost::unordered::detail::prev_prime(i) == min_prime);
+    } else {
+      test_prev_prime(i);
     }
+    test_next_prime(i);
+  }
 
-    std::size_t last = i - 1;
-    for (; i > last; last = i, i += i / 5) {
-        if (i > max_prime) {
-            BOOST_TEST(boost::unordered::detail::next_prime(i) == max_prime);
-        } else {
-            test_next_prime(i);
-        }
-        test_prev_prime(i);
+  std::size_t last = i - 1;
+  for (; i > last; last = i, i += i / 5) {
+    if (i > max_prime) {
+      BOOST_TEST(boost::unordered::detail::next_prime(i) == max_prime);
+    } else {
+      test_next_prime(i);
     }
+    test_prev_prime(i);
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/emplace_tests.cpp b/test/unordered/emplace_tests.cpp
index e86a066f..50191f3c 100644
--- a/test/unordered/emplace_tests.cpp
+++ b/test/unordered/emplace_tests.cpp
@@ -19,9 +19,9 @@
 // arguments.
 
 namespace emplace_tests {
-// Constructible with 2 to 10 arguments
-struct emplace_value : private test::counted_object
-{
+  // Constructible with 2 to 10 arguments
+  struct emplace_value : private test::counted_object
+  {
     typedef int A0;
     typedef std::string A1;
     typedef char A2;
@@ -59,40 +59,40 @@ struct emplace_value : private test::counted_object
     }
 
     emplace_value(
-        A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3, A4 const& b4)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
     {
@@ -100,79 +100,79 @@ struct emplace_value : private test::counted_object
 
     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;
+      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;
-        }
-        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 != 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;
     }
 
   private:
     emplace_value();
     emplace_value(emplace_value const&);
-};
+  };
 
-UNORDERED_AUTO_TEST(emplace_set)
-{
+  UNORDERED_AUTO_TEST(emplace_set)
+  {
     test::check_instances check_;
 
     typedef boost::unordered_set<emplace_value, boost::hash<emplace_value> >
-        container;
+      container;
     typedef container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
@@ -233,12 +233,12 @@ UNORDERED_AUTO_TEST(emplace_set)
     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));
+      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);
 
@@ -247,15 +247,15 @@ UNORDERED_AUTO_TEST(emplace_set)
     BOOST_TEST(x.count(v2) == 1);
     BOOST_TEST(x.count(v3) == 1);
     BOOST_TEST(x.count(v4) == 1);
-}
+  }
 
-UNORDERED_AUTO_TEST(emplace_multiset)
-{
+  UNORDERED_AUTO_TEST(emplace_multiset)
+  {
     test::check_instances check_;
 
     typedef boost::unordered_multiset<emplace_value,
-        boost::hash<emplace_value> >
-        container;
+      boost::hash<emplace_value> >
+      container;
     typedef container::iterator iterator;
     container x(10);
     iterator i1, i2;
@@ -326,15 +326,15 @@ UNORDERED_AUTO_TEST(emplace_multiset)
     BOOST_TEST_EQ(x.count(v1), 1u);
     BOOST_TEST_EQ(x.count(v2), 2u);
     BOOST_TEST_EQ(x.count(v3), 2u);
-}
+  }
 
-UNORDERED_AUTO_TEST(emplace_map)
-{
+  UNORDERED_AUTO_TEST(emplace_map)
+  {
     test::check_instances check_;
 
     typedef boost::unordered_map<emplace_value, emplace_value,
-        boost::hash<emplace_value> >
-        container;
+      boost::hash<emplace_value> >
+      container;
     typedef container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
@@ -345,8 +345,8 @@ UNORDERED_AUTO_TEST(emplace_map)
     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::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);
@@ -355,8 +355,8 @@ UNORDERED_AUTO_TEST(emplace_map)
     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::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);
@@ -371,8 +371,8 @@ UNORDERED_AUTO_TEST(emplace_map)
     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::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);
@@ -384,29 +384,29 @@ UNORDERED_AUTO_TEST(emplace_map)
 
     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::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::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::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)
-{
+  UNORDERED_AUTO_TEST(emplace_multimap)
+  {
     test::check_instances check_;
 
     typedef boost::unordered_multimap<emplace_value, emplace_value,
-        boost::hash<emplace_value> >
-        container;
+      boost::hash<emplace_value> >
+      container;
     typedef container::iterator iterator;
     container x(10);
     iterator i1, i2, i3, i4;
@@ -416,8 +416,8 @@ UNORDERED_AUTO_TEST(emplace_multimap)
     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::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);
@@ -426,8 +426,8 @@ UNORDERED_AUTO_TEST(emplace_multimap)
 
     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::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);
@@ -440,8 +440,8 @@ UNORDERED_AUTO_TEST(emplace_multimap)
     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::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);
@@ -450,24 +450,24 @@ UNORDERED_AUTO_TEST(emplace_multimap)
 
     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"));
+      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));
+      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::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);
-}
+  }
 
-UNORDERED_AUTO_TEST(try_emplace)
-{
+  UNORDERED_AUTO_TEST(try_emplace)
+  {
     test::check_instances check_;
 
     typedef boost::unordered_map<int, emplace_value> container;
@@ -509,11 +509,11 @@ UNORDERED_AUTO_TEST(try_emplace)
 
     BOOST_TEST(r2.first == x.try_emplace(r2.first, k2, 808709, "what"));
     BOOST_TEST(
-        r2.first ==
-        x.try_emplace(r2.first, k2, 10, "xxx", 'a', 4, 5, 6, 7, 8, 9, 10));
+      r2.first ==
+      x.try_emplace(r2.first, k2, 10, "xxx", 'a', 4, 5, 6, 7, 8, 9, 10));
     BOOST_TEST(r2.first->second == m2);
     BOOST_TEST_EQ(x.size(), 2u);
-}
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/equality_tests.cpp b/test/unordered/equality_tests.cpp
index 7daea70c..2d14d337 100644
--- a/test/unordered/equality_tests.cpp
+++ b/test/unordered/equality_tests.cpp
@@ -15,8 +15,8 @@
 #include "../helpers/test.hpp"
 
 namespace equality_tests {
-struct mod_compare
-{
+  struct mod_compare
+  {
     bool alt_hash_;
 
     explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
@@ -25,50 +25,49 @@ struct mod_compare
 
     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);
+      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);                                              \
-    }
+  {                                                                            \
+    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);                                              \
-    }
+  {                                                                            \
+    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);                                              \
-    }
+  {                                                                            \
+    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);                                              \
-    }
+  {                                                                            \
+    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)                                     \
-    map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
+  map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
 
-UNORDERED_AUTO_TEST(equality_size_tests)
-{
+  UNORDERED_AUTO_TEST(equality_size_tests)
+  {
     boost::unordered_set<int> x1, x2;
     BOOST_TEST(x1 == x2);
     BOOST_TEST(!(x1 != x2));
@@ -88,61 +87,61 @@ UNORDERED_AUTO_TEST(equality_size_tests)
     BOOST_TEST(!(x1 == x2));
     BOOST_TEST(x2 != x1);
     BOOST_TEST(!(x2 == x1));
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_key_value_tests)
-{
+  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_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_group_size_test)
-{
+  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)))
+      ((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)))
-}
+      ((20)(1))((10)(1))((10)(1)), ==, ((10)(1))((20)(1))((10)(1)))
+  }
 
-UNORDERED_AUTO_TEST(equality_map_value_test)
-{
+  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_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_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));
-}
+      (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.
+  // 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)
-{
+  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));
@@ -159,7 +158,7 @@ UNORDERED_AUTO_TEST(equality_different_hash_test)
     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 8e48d68c..22edf3be 100644
--- a/test/unordered/equivalent_keys_tests.cpp
+++ b/test/unordered/equivalent_keys_tests.cpp
@@ -20,60 +20,60 @@
 template <class Container, class Iterator>
 void test_equal_insertion(Iterator begin, Iterator end)
 {
-    typedef test::ordered<Container> tracker;
+  typedef test::ordered<Container> tracker;
 
-    Container x1;
-    tracker x2 = test::create_ordered(x1);
+  Container x1;
+  tracker x2 = test::create_ordered(x1);
 
-    for (Iterator it = begin; it != end; ++it) {
-        x1.insert(*it);
-        x2.insert(*it);
-        x2.compare_key(x1, *it);
-    }
+  for (Iterator it = begin; it != end; ++it) {
+    x1.insert(*it);
+    x2.insert(*it);
+    x2.compare_key(x1, *it);
+  }
 
-    x2.compare(x1);
-    test::check_equivalent_keys(x1);
+  x2.compare(x1);
+  test::check_equivalent_keys(x1);
 }
 
 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;
+  typedef boost::unordered_set<int> set;
+  typedef boost::unordered_multiset<int> multiset;
 
-    test_equal_insertion<set>(values[0], values[0] + 1);
-    test_equal_insertion<set>(values[1], values[1] + 2);
-    test_equal_insertion<set>(values[2], values[2] + 2);
-    test_equal_insertion<set>(values[3], values[3] + 2);
-    test_equal_insertion<set>(values[4], values[4] + 3);
+  test_equal_insertion<set>(values[0], values[0] + 1);
+  test_equal_insertion<set>(values[1], values[1] + 2);
+  test_equal_insertion<set>(values[2], values[2] + 2);
+  test_equal_insertion<set>(values[3], values[3] + 2);
+  test_equal_insertion<set>(values[4], values[4] + 3);
 
-    test_equal_insertion<multiset>(values[0], values[0] + 1);
-    test_equal_insertion<multiset>(values[1], values[1] + 2);
-    test_equal_insertion<multiset>(values[2], values[2] + 2);
-    test_equal_insertion<multiset>(values[3], values[3] + 2);
-    test_equal_insertion<multiset>(values[4], values[4] + 3);
+  test_equal_insertion<multiset>(values[0], values[0] + 1);
+  test_equal_insertion<multiset>(values[1], values[1] + 2);
+  test_equal_insertion<multiset>(values[2], values[2] + 2);
+  test_equal_insertion<multiset>(values[3], values[3] + 2);
+  test_equal_insertion<multiset>(values[4], values[4] + 3);
 }
 
 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[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));
+  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[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));
 
-    for (int i = 0; i < 5; ++i)
-        test_equal_insertion<boost::unordered_map<int, int> >(
-            v[i].begin(), v[i].end());
+  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)
-        test_equal_insertion<boost::unordered_multimap<int, int> >(
-            v[i2].begin(), v[i2].end());
+  for (int i2 = 0; i2 < 5; ++i2)
+    test_equal_insertion<boost::unordered_multimap<int, int> >(
+      v[i2].begin(), v[i2].end());
 }
 
 RUN_TESTS()
diff --git a/test/unordered/erase_equiv_tests.cpp b/test/unordered/erase_equiv_tests.cpp
index 64510394..95185ed4 100644
--- a/test/unordered/erase_equiv_tests.cpp
+++ b/test/unordered/erase_equiv_tests.cpp
@@ -27,109 +27,108 @@
 
 struct write_pair_type
 {
-    template <class X1, class X2>
-    void operator()(std::pair<X1, X2> const& x) const
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second
-                                       << ")";
-    }
+  template <class X1, class X2>
+  void operator()(std::pair<X1, X2> const& x) const
+  {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second << ")";
+  }
 } write_pair;
 
 template <class Container> void write_container(Container const& x)
 {
-    std::for_each(x.begin(), x.end(), write_pair);
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+  std::for_each(x.begin(), x.end(), write_pair);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 // Make everything collide - for testing erase in a single bucket.
 struct collision_hash
 {
-    std::size_t operator()(int) const { return 0; }
+  std::size_t operator()(int) const { return 0; }
 };
 
 // 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.
 struct collision3_hash
 {
-    std::size_t operator()(int x) const { return static_cast<std::size_t>(x); }
+  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;
+  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;
+  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;
+  test::allocator2<std::pair<int const, int> > >
+  collide_map3;
 typedef collide_map::value_type collide_value;
 typedef test::list<collide_value> collide_list;
 
 UNORDERED_AUTO_TEST(empty_range_tests)
 {
-    collide_map x;
-    x.erase(x.begin(), x.end());
-    x.erase(x.begin(), x.begin());
-    x.erase(x.end(), x.end());
-    test::check_equivalent_keys(x);
+  collide_map x;
+  x.erase(x.begin(), x.end());
+  x.erase(x.begin(), x.begin());
+  x.erase(x.end(), x.end());
+  test::check_equivalent_keys(x);
 }
 
 UNORDERED_AUTO_TEST(single_item_tests)
 {
-    collide_list init;
-    init.push_back(collide_value(1, 1));
+  collide_list init;
+  init.push_back(collide_value(1, 1));
 
-    collide_map x(init.begin(), init.end());
-    x.erase(x.begin(), x.begin());
-    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
-    test::check_equivalent_keys(x);
-    x.erase(x.end(), x.end());
-    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
-    test::check_equivalent_keys(x);
-    x.erase(x.begin(), x.end());
-    BOOST_TEST(x.count(1) == 0 && x.size() == 0);
-    test::check_equivalent_keys(x);
+  collide_map x(init.begin(), init.end());
+  x.erase(x.begin(), x.begin());
+  BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+  test::check_equivalent_keys(x);
+  x.erase(x.end(), x.end());
+  BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+  test::check_equivalent_keys(x);
+  x.erase(x.begin(), x.end());
+  BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+  test::check_equivalent_keys(x);
 }
 
 UNORDERED_AUTO_TEST(two_equivalent_item_tests)
 {
-    collide_list init;
-    init.push_back(collide_value(1, 1));
-    init.push_back(collide_value(1, 2));
+  collide_list init;
+  init.push_back(collide_value(1, 1));
+  init.push_back(collide_value(1, 2));
 
-    {
-        collide_map x(init.begin(), init.end());
-        x.erase(x.begin(), x.end());
-        BOOST_TEST(x.count(1) == 0 && x.size() == 0);
-        test::check_equivalent_keys(x);
-    }
+  {
+    collide_map x(init.begin(), init.end());
+    x.erase(x.begin(), x.end());
+    BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+    test::check_equivalent_keys(x);
+  }
 
-    {
-        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);
-        test::check_equivalent_keys(x);
-    }
+  {
+    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);
+    test::check_equivalent_keys(x);
+  }
 
-    {
-        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);
-        test::check_equivalent_keys(x);
-    }
+  {
+    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);
+    test::check_equivalent_keys(x);
+  }
 }
 
 // More automated tests...
@@ -137,89 +136,88 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
 template <class Range1, class Range2>
 bool compare(Range1 const& x, Range2 const& y)
 {
-    collide_list a(x.begin(), x.end());
-    collide_list b(y.begin(), y.end());
-    a.sort();
-    b.sort();
-    return a == b;
+  collide_list a(x.begin(), x.end());
+  collide_list b(y.begin(), y.end());
+  a.sort();
+  b.sort();
+  return a == b;
 }
 
 template <class Container>
 bool general_erase_range_test(Container& x, std::size_t start, std::size_t end)
 {
-    collide_list l(x.begin(), x.end());
+  collide_list l(x.begin(), x.end());
 
-    l.erase(test::next(l.begin(), start), test::next(l.begin(), end));
-    x.erase(test::next(x.begin(), start), test::next(x.begin(), end));
+  l.erase(test::next(l.begin(), start), test::next(l.begin(), end));
+  x.erase(test::next(x.begin(), start), test::next(x.begin(), end));
 
-    test::check_equivalent_keys(x);
-    return compare(l, x);
+  test::check_equivalent_keys(x);
+  return compare(l, 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) {
-            Container y(x);
-            collide_list init(y.begin(), y.end());
-            if (!general_erase_range_test(y, position, position + length)) {
-                BOOST_ERROR("general_erase_range_test failed.");
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase: [" << position << ","
-                                               << position + length << ")\n";
-                write_container(init);
-                write_container(y);
-            }
-        }
+  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)) {
+        BOOST_ERROR("general_erase_range_test failed.");
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase: [" << position << ","
+                                       << position + length << ")\n";
+        write_container(init);
+        write_container(y);
+      }
     }
+  }
 }
 
 template <class Container>
 void x_by_y_erase_range_tests(Container*, int values, int duplicates)
 {
-    Container y;
+  Container y;
 
-    for (int i = 0; i < values; ++i) {
-        for (int j = 0; j < duplicates; ++j) {
-            y.insert(collide_value(i, j));
-        }
+  for (int i = 0; i < values; ++i) {
+    for (int j = 0; j < duplicates; ++j) {
+      y.insert(collide_value(i, j));
     }
+  }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Values: " << values
-                                   << ", Duplicates: " << duplicates << "\n";
-    erase_subrange_tests(y);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Values: " << values
+                                 << ", Duplicates: " << duplicates << "\n";
+  erase_subrange_tests(y);
 }
 
 template <class Container>
 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) {
-            x_by_y_erase_range_tests(x, i, 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)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide_tests:\n";
-    collide_map m;
-    exhaustive_erase_tests((collide_map*)0, 4, 4);
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide_tests:\n";
+  collide_map m;
+  exhaustive_erase_tests((collide_map*)0, 4, 4);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 UNORDERED_AUTO_TEST(exhaustive_collide2_tests)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide2_tests:\n";
-    exhaustive_erase_tests((collide_map2*)0, 8, 4);
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide2_tests:\n";
+  exhaustive_erase_tests((collide_map2*)0, 8, 4);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 UNORDERED_AUTO_TEST(exhaustive_collide3_tests)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide3_tests:\n";
-    exhaustive_erase_tests((collide_map3*)0, 8, 4);
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide3_tests:\n";
+  exhaustive_erase_tests((collide_map3*)0, 8, 4);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 RUN_TESTS()
diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp
index 843e64f2..ec26ab2d 100644
--- a/test/unordered/erase_tests.cpp
+++ b/test/unordered/erase_tests.cpp
@@ -22,254 +22,251 @@
 
 namespace erase_tests {
 
-test::seed_t initialize_seed(85638);
+  test::seed_t initialize_seed(85638);
 
-template <class Container>
-void erase_tests1(Container*, test::random_generator generator)
-{
+  template <class Container>
+  void erase_tests1(Container*, test::random_generator generator)
+  {
     typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase by key.\n";
     {
-        test::check_instances check_;
+      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) {
-            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);
-        }
+      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) {
+        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);
+      }
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(begin()).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(1000, 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());
-            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);
-        }
-        BOOST_TEST(x.empty());
+      test::random_values<Container> v(1000, 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());
+        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);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random position).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(1000, generator);
-        Container x(v.begin(), v.end());
-        std::size_t size = x.size();
-        int iterations = 0;
-        while (size > 0 && !x.empty()) {
-            std::size_t index = test::random_value(x.size());
-            c_iterator prev, pos, next;
-            if (index == 0) {
-                prev = pos = x.begin();
-            } 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);
-            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));
-            BOOST_TEST(x.count(key) == count - 1);
-            if (x.count(key) != count - 1) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
-                                               << x.count(key) << std::endl;
-            }
-            BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0)
-                test::check_equivalent_keys(x);
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        std::size_t index = test::random_value(x.size());
+        c_iterator prev, pos, next;
+        if (index == 0) {
+          prev = pos = x.begin();
+        } else {
+          prev = test::next(x.begin(), index - 1);
+          pos = test::next(prev);
         }
-        BOOST_TEST(x.empty());
+        next = test::next(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));
+        BOOST_TEST(x.count(key) == count - 1);
+        if (x.count(key) != count - 1) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => " << x.count(key)
+                                         << std::endl;
+        }
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(ranges).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(500, generator);
-        Container x(v.begin(), v.end());
+      test::random_values<Container> v(500, generator);
+      Container x(v.begin(), v.end());
 
-        std::size_t size = x.size();
+      std::size_t size = x.size();
 
-        // I'm actually stretching it a little here, as the standard says it
-        // returns 'the iterator immediately following the erase elements'
-        // and if nothing is erased, then there's nothing to follow. But I
-        // think this is the only sensible option...
-        BOOST_TEST(x.erase(x.end(), x.end()) == x.end());
-        BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin());
-        BOOST_TEST(x.size() == size);
-        test::check_equivalent_keys(x);
+      // I'm actually stretching it a little here, as the standard says it
+      // returns 'the iterator immediately following the erase elements'
+      // and if nothing is erased, then there's nothing to follow. But I
+      // think this is the only sensible option...
+      BOOST_TEST(x.erase(x.end(), x.end()) == x.end());
+      BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin());
+      BOOST_TEST(x.size() == size);
+      test::check_equivalent_keys(x);
 
-        BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.begin() == x.end());
-        test::check_equivalent_keys(x);
+      BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.begin() == x.end());
+      test::check_equivalent_keys(x);
 
-        BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
-        test::check_equivalent_keys(x);
+      BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
+      test::check_equivalent_keys(x);
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random ranges).\n";
     {
-        test::check_instances check_;
-        Container x;
+      test::check_instances check_;
+      Container x;
 
-        for (int i = 0; i < 100; ++i) {
-            test::random_values<Container> v(1000, generator);
-            x.insert(v.begin(), v.end());
+      for (int i = 0; i < 100; ++i) {
+        test::random_values<Container> v(1000, generator);
+        x.insert(v.begin(), v.end());
 
-            // Note that erase only invalidates the erased iterators.
-            std::vector<c_iterator> iterators;
-            for (c_iterator it = x.cbegin(); it != x.cend(); ++it) {
-                iterators.push_back(it);
-            }
-            iterators.push_back(x.cend());
-
-            while (iterators.size() > 1) {
-                std::size_t start = test::random_value(iterators.size());
-                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));
-
-                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) {
-                    BOOST_TEST(i1 == *i2);
-                    ++i2;
-                }
-                BOOST_TEST(x.cend() == *i2);
-
-                test::check_equivalent_keys(x);
-            }
-            BOOST_TEST(x.empty());
+        // Note that erase only invalidates the erased iterators.
+        std::vector<c_iterator> iterators;
+        for (c_iterator it = x.cbegin(); it != x.cend(); ++it) {
+          iterators.push_back(it);
         }
+        iterators.push_back(x.cend());
+
+        while (iterators.size() > 1) {
+          std::size_t start = test::random_value(iterators.size());
+          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));
+
+          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) {
+            BOOST_TEST(i1 == *i2);
+            ++i2;
+          }
+          BOOST_TEST(x.cend() == *i2);
+
+          test::check_equivalent_keys(x);
+        }
+        BOOST_TEST(x.empty());
+      }
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(begin()).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(1000, 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());
-            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);
-        }
-        BOOST_TEST(x.empty());
+      test::random_values<Container> v(1000, 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());
+        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);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(random position).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(1000, generator);
-        Container x(v.begin(), v.end());
-        std::size_t size = x.size();
-        int iterations = 0;
-        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) {
-                prev = pos = x.begin();
-            } 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);
-            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));
-            BOOST_TEST(x.count(key) == count - 1);
-            if (x.count(key) != count - 1) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
-                                               << x.count(key) << std::endl;
-            }
-            BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0)
-                test::check_equivalent_keys(x);
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      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) {
+          prev = pos = x.begin();
+        } else {
+          prev = test::next(x.begin(), index - 1);
+          pos = test::next(prev);
         }
-        BOOST_TEST(x.empty());
+        next = test::next(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));
+        BOOST_TEST(x.count(key) == count - 1);
+        if (x.count(key) != count - 1) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => " << x.count(key)
+                                         << std::endl;
+        }
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "clear().\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(500, generator);
-        Container x(v.begin(), v.end());
-        x.clear();
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.begin() == x.end());
+      test::random_values<Container> v(500, generator);
+      Container x(v.begin(), v.end());
+      x.clear();
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.begin() == x.end());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\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,
+  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;
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     erase_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
-                      (default_generator)(generate_collisions)(limited_range)))
+                    (default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/extract_tests.cpp b/test/unordered/extract_tests.cpp
index b4f1e801..ae305881 100644
--- a/test/unordered/extract_tests.cpp
+++ b/test/unordered/extract_tests.cpp
@@ -21,118 +21,118 @@
 
 namespace extract_tests {
 
-test::seed_t initialize_seed(85638);
+  test::seed_t initialize_seed(85638);
 
-template <class Container>
-void extract_tests1(Container*, test::random_generator generator)
-{
+  template <class Container>
+  void extract_tests1(Container*, test::random_generator generator)
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Extract by key.\n";
     {
-        test::check_instances check_;
+      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) {
-            std::size_t count = x.count(test::get_key<Container>(*it));
-            std::size_t old_size = x.size();
-            std::size_t new_count = count ? count - 1 : count;
-            std::size_t new_size = count ? old_size - 1 : old_size;
-            typename Container::node_type n =
-                x.extract(test::get_key<Container>(*it));
-            BOOST_TEST((n ? true : false) == (count ? true : false));
-            BOOST_TEST(x.size() == new_size);
-            BOOST_TEST(x.count(test::get_key<Container>(*it)) == new_count);
-            if (!new_count) {
-                BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
-            } else {
-                BOOST_TEST(x.find(test::get_key<Container>(*it)) != x.end());
-            }
-            if (++iterations % 20 == 0)
-                test::check_equivalent_keys(x);
+      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) {
+        std::size_t count = x.count(test::get_key<Container>(*it));
+        std::size_t old_size = x.size();
+        std::size_t new_count = count ? count - 1 : count;
+        std::size_t new_size = count ? old_size - 1 : old_size;
+        typename Container::node_type n =
+          x.extract(test::get_key<Container>(*it));
+        BOOST_TEST((n ? true : false) == (count ? true : false));
+        BOOST_TEST(x.size() == new_size);
+        BOOST_TEST(x.count(test::get_key<Container>(*it)) == new_count);
+        if (!new_count) {
+          BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
+        } else {
+          BOOST_TEST(x.find(test::get_key<Container>(*it)) != x.end());
         }
-        BOOST_TEST(x.empty());
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(begin()).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(1000, 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());
-            std::size_t count = x.count(key);
-            typename Container::node_type n = x.extract(x.begin());
-            BOOST_TEST(n);
-            --size;
-            BOOST_TEST(x.count(key) == count - 1);
-            BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0)
-                test::check_equivalent_keys(x);
-        }
-        BOOST_TEST(x.empty());
+      test::random_values<Container> v(1000, 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());
+        std::size_t count = x.count(key);
+        typename Container::node_type n = x.extract(x.begin());
+        BOOST_TEST(n);
+        --size;
+        BOOST_TEST(x.count(key) == count - 1);
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(random position).\n";
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<Container> v(1000, generator);
-        Container x(v.begin(), v.end());
-        std::size_t size = x.size();
-        int iterations = 0;
-        while (size > 0 && !x.empty()) {
-            using namespace std;
-            int index = rand() % (int)x.size();
-            BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
-            if (index == 0) {
-                prev = pos = x.begin();
-            } else {
-                prev = boost::next(x.begin(), index - 1);
-                pos = boost::next(prev);
-            }
-            next = boost::next(pos);
-            BOOST_DEDUCED_TYPENAME Container::key_type key =
-                test::get_key<Container>(*pos);
-            std::size_t count = x.count(key);
-            typename Container::node_type n = x.extract(pos);
-            BOOST_TEST(n);
-            --size;
-            if (size > 0)
-                BOOST_TEST(
-                    index == 0 ? next == x.begin() : next == boost::next(prev));
-            BOOST_TEST(x.count(key) == count - 1);
-            BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0)
-                test::check_equivalent_keys(x);
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        using namespace std;
+        int index = rand() % (int)x.size();
+        BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
+        if (index == 0) {
+          prev = pos = x.begin();
+        } else {
+          prev = boost::next(x.begin(), index - 1);
+          pos = boost::next(prev);
         }
-        BOOST_TEST(x.empty());
+        next = boost::next(pos);
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*pos);
+        std::size_t count = x.count(key);
+        typename Container::node_type n = x.extract(pos);
+        BOOST_TEST(n);
+        --size;
+        if (size > 0)
+          BOOST_TEST(
+            index == 0 ? next == x.begin() : next == boost::next(prev));
+        BOOST_TEST(x.count(key) == count - 1);
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\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,
+  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::default_generator;
+  using test::generate_collisions;
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     extract_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
-                        (default_generator)(generate_collisions)))
+                      (default_generator)(generate_collisions)))
 }
 
 RUN_TESTS()
diff --git a/test/unordered/find_tests.cpp b/test/unordered/find_tests.cpp
index c6ac6742..b9a38238 100644
--- a/test/unordered/find_tests.cpp
+++ b/test/unordered/find_tests.cpp
@@ -18,109 +18,106 @@
 
 namespace find_tests {
 
-test::seed_t initialize_seed(78937);
+  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;
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<X> v(500, generator);
-        X x(v.begin(), v.end());
-        X const& x_const = x;
-        test::ordered<X> tracker = test::create_ordered(x);
-        tracker.insert_range(v.begin(), v.end());
+      test::random_values<X> v(500, generator);
+      X x(v.begin(), v.end());
+      X const& x_const = x;
+      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) {
-            BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
-            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)));
-            BOOST_TEST(pos != x.end());
-            BOOST_TEST(
-                pos != x.end() && x.key_eq()(key, test::get_key<X>(*pos)));
+      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);
+        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)));
+        BOOST_TEST(pos != x.end());
+        BOOST_TEST(pos != x.end() && x.key_eq()(key, test::get_key<X>(*pos)));
 
-            BOOST_TEST(x.count(key) == tracker.count(key));
+        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_const.equal_range(key),
-                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) {
-            BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
-            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);
-                std::pair<iterator, iterator> range = x.equal_range(key);
-                BOOST_TEST(range.first == range.second);
-            }
+        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);
+      }
+
+      test::random_values<X> v2(500, generator);
+      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()) {
+          BOOST_TEST(x.find(key) == x.end());
+          BOOST_TEST(x_const.find(key) == x_const.end());
+          BOOST_TEST(x.count(key) == 0);
+          std::pair<iterator, iterator> range = x.equal_range(key);
+          BOOST_TEST(range.first == range.second);
         }
+      }
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
+      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) {
-            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);
-            std::pair<iterator, iterator> range = x.equal_range(key);
-            BOOST_TEST(range.first == range.second);
-        }
+      test::random_values<X> v2(5, generator);
+      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);
+        std::pair<iterator, iterator> range = x.equal_range(key);
+        BOOST_TEST(range.first == range.second);
+      }
     }
-}
+  }
 
-struct compatible_key
-{
+  struct compatible_key
+  {
     test::object o_;
 
     compatible_key(test::object const& o) : o_(o) {}
-};
+  };
 
-struct compatible_hash
-{
+  struct compatible_hash
+  {
     test::hash hash_;
 
     std::size_t operator()(compatible_key const& k) const
     {
-        return hash_(k.o_);
+      return hash_(k.o_);
     }
-};
+  };
 
-struct compatible_predicate
-{
+  struct compatible_predicate
+  {
     test::equal_to equal_;
 
     bool operator()(compatible_key const& k1, compatible_key const& k2) const
     {
-        return equal_(k1.o_, k2.o_);
+      return equal_(k1.o_, k2.o_);
     }
-};
+  };
 
-template <class X>
-void find_compatible_keys_test(X*, test::random_generator generator)
-{
+  template <class X>
+  void find_compatible_keys_test(X*, test::random_generator generator)
+  {
     typedef BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-        value_iterator;
+      value_iterator;
     test::random_values<X> v(500, generator);
     X x(v.begin(), v.end());
 
@@ -128,35 +125,35 @@ void find_compatible_keys_test(X*, test::random_generator generator)
     compatible_predicate eq;
 
     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));
+      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) {
-        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_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,
+  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;
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     find_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
-                     (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(find_compatible_keys_test,
+                   (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)))
 }
diff --git a/test/unordered/fwd_map_test.cpp b/test/unordered/fwd_map_test.cpp
index 6f4179d9..ee3028d9 100644
--- a/test/unordered/fwd_map_test.cpp
+++ b/test/unordered/fwd_map_test.cpp
@@ -12,41 +12,41 @@
 template <typename T>
 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)
 {
-    return x == y;
+  return x == y;
 }
 
 template <typename T>
 bool call_not_equals(
-    boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
+  boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
 {
-    return x != y;
+  return x != y;
 }
 
 template <typename T>
 void call_swap(
-    boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
+  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)
+  boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
 {
-    return x == y;
+  return x == y;
 }
 
 template <typename T>
 bool call_not_equals(
-    boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
+  boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
 {
-    return x != y;
+  return x != y;
 }
 
 #include <boost/unordered_map.hpp>
@@ -57,27 +57,27 @@ typedef boost::unordered_multimap<int, int> int_multimap;
 
 UNORDERED_AUTO_TEST(use_map_fwd_declared_function)
 {
-    int_map x, y;
-    x[1] = 2;
-    y[2] = 1;
-    call_swap(x, y);
+  int_map x, y;
+  x[1] = 2;
+  y[2] = 1;
+  call_swap(x, y);
 
-    BOOST_TEST(y.find(1) != y.end() && y.find(1)->second == 2);
-    BOOST_TEST(y.find(2) == y.end());
+  BOOST_TEST(y.find(1) != y.end() && y.find(1)->second == 2);
+  BOOST_TEST(y.find(2) == y.end());
 
-    BOOST_TEST(x.find(1) == x.end());
-    BOOST_TEST(x.find(2) != x.end() && x.find(2)->second == 1);
+  BOOST_TEST(x.find(1) == x.end());
+  BOOST_TEST(x.find(2) != x.end() && x.find(2)->second == 1);
 
-    BOOST_TEST(!call_equals(x, y));
-    BOOST_TEST(call_not_equals(x, y));
+  BOOST_TEST(!call_equals(x, y));
+  BOOST_TEST(call_not_equals(x, y));
 }
 
 UNORDERED_AUTO_TEST(use_multimap_fwd_declared_function)
 {
-    int_multimap x, y;
-    call_swap(x, y);
-    BOOST_TEST(call_equals(x, y));
-    BOOST_TEST(!call_not_equals(x, y));
+  int_multimap x, y;
+  call_swap(x, y);
+  BOOST_TEST(call_equals(x, y));
+  BOOST_TEST(!call_not_equals(x, y));
 }
 
 RUN_TESTS()
diff --git a/test/unordered/fwd_set_test.cpp b/test/unordered/fwd_set_test.cpp
index 9c5b3bbf..0cc687c4 100644
--- a/test/unordered/fwd_set_test.cpp
+++ b/test/unordered/fwd_set_test.cpp
@@ -11,55 +11,55 @@
 
 struct true_type
 {
-    char x[100];
+  char x[100];
 };
 struct false_type
 {
-    char x;
+  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)
 {
-    swap(x, y);
+  swap(x, y);
 }
 
 template <typename T>
 bool call_equals(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
 {
-    return x == y;
+  return x == y;
 }
 
 template <typename T>
 bool call_not_equals(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
 {
-    return x != y;
+  return x != 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)
+  boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
 {
-    return x == y;
+  return x == y;
 }
 
 template <typename T>
 bool call_not_equals(
-    boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
+  boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
 {
-    return x != y;
+  return x != y;
 }
 
 #include "../helpers/test.hpp"
@@ -69,42 +69,42 @@ 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));
+  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)
 {
-    boost::unordered_set<int> x;
-    BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
+  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)
 {
-    int_set x, y;
-    x.insert(1);
-    y.insert(2);
-    call_swap(x, y);
+  int_set x, y;
+  x.insert(1);
+  y.insert(2);
+  call_swap(x, y);
 
-    BOOST_TEST(y.find(1) != y.end());
-    BOOST_TEST(y.find(2) == y.end());
+  BOOST_TEST(y.find(1) != y.end());
+  BOOST_TEST(y.find(2) == y.end());
 
-    BOOST_TEST(x.find(1) == x.end());
-    BOOST_TEST(x.find(2) != x.end());
+  BOOST_TEST(x.find(1) == x.end());
+  BOOST_TEST(x.find(2) != x.end());
 
-    BOOST_TEST(!call_equals(x, y));
-    BOOST_TEST(call_not_equals(x, y));
+  BOOST_TEST(!call_equals(x, y));
+  BOOST_TEST(call_not_equals(x, y));
 }
 
 UNORDERED_AUTO_TEST(use_multiset_fwd_declared_function)
 {
-    int_multiset x, y;
-    call_swap(x, y);
-    BOOST_TEST(call_equals(x, y));
-    BOOST_TEST(!call_not_equals(x, y));
+  int_multiset x, y;
+  call_swap(x, y);
+  BOOST_TEST(call_equals(x, y));
+  BOOST_TEST(!call_not_equals(x, y));
 }
 
 RUN_TESTS()
diff --git a/test/unordered/incomplete_test.cpp b/test/unordered/incomplete_test.cpp
index 860606b3..09afcba6 100644
--- a/test/unordered/incomplete_test.cpp
+++ b/test/unordered/incomplete_test.cpp
@@ -13,52 +13,52 @@
 #include <utility>
 
 namespace x {
-struct D
-{
+  struct D
+  {
     boost::unordered_map<D, D> x;
-};
+  };
 }
 
 namespace incomplete_test {
-// Declare, but don't define some types.
+  // Declare, but don't define some types.
 
-struct value;
-struct hash;
-struct equals;
-template <class T> struct allocator;
+  struct value;
+  struct hash;
+  struct equals;
+  template <class T> struct allocator;
 
-// Declare some instances
+  // Declare some instances
 
-typedef boost::unordered_map<value, value, hash, equals,
+  typedef boost::unordered_map<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     map;
-typedef boost::unordered_multimap<value, value, hash, equals,
+  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> >
+  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.
+  // Now define the types which are stored as members, as they are needed for
+  // declaring struct members.
 
-struct hash
-{
+  struct hash
+  {
     template <typename T> std::size_t operator()(T const&) const { return 0; }
-};
+  };
 
-struct equals
-{
+  struct equals
+  {
     template <typename T> bool operator()(T const&, T const&) const
     {
-        return true;
+      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>
-{
+  // 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>
@@ -70,72 +70,72 @@ template <typename T> struct allocator : std::allocator<T>
     allocator(const std::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.
+  // Declare some members of a structs.
+  //
+  // Incomplete hash, equals and allocator aren't here supported at the
+  // moment.
 
-struct struct1
-{
+  struct struct1
+  {
     boost::unordered_map<struct1, struct1, hash, equals,
-        allocator<std::pair<struct1 const, struct1> > >
-        x;
-};
-struct struct2
-{
+      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
-{
+      allocator<std::pair<struct2 const, struct2> > >
+      x;
+  };
+  struct struct3
+  {
     boost::unordered_set<struct3, hash, equals, allocator<struct3> > x;
-};
-struct struct4
-{
+  };
+  struct struct4
+  {
     boost::unordered_multiset<struct4, hash, equals, allocator<struct4> > x;
-};
+  };
 
-// Now define the value type.
+  // Now define the value type.
 
-struct value
-{
-};
+  struct value
+  {
+  };
 
-// Create some instances.
+  // Create some instances.
 
-incomplete_test::map m1;
-incomplete_test::multimap m2;
-incomplete_test::set s1;
-incomplete_test::multiset s2;
+  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;
+  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.
+  // 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(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&);
+  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&);
+  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
+  // And finally use these
 
-void use_types()
-{
+  void use_types()
+  {
     incomplete_test::value x;
     m1[x] = x;
     m2.insert(std::make_pair(x, x));
@@ -146,28 +146,28 @@ void use_types()
     c2.x.insert(std::make_pair(c2, c2));
     c3.x.insert(c3);
     c4.x.insert(c4);
-}
+  }
 
-// And finally define the operators required for comparing elements.
+  // 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(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; }
+  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; }
+  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.
+  // 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.
 
-    incomplete_test::use_types();
+  incomplete_test::use_types();
 }
diff --git a/test/unordered/insert_hint_tests.cpp b/test/unordered/insert_hint_tests.cpp
index 5b4268bb..658e129c 100644
--- a/test/unordered/insert_hint_tests.cpp
+++ b/test/unordered/insert_hint_tests.cpp
@@ -17,18 +17,18 @@
 #include <set>
 
 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);
     BOOST_TEST_EQ(x.size(), 1u);
     BOOST_TEST_EQ(x.count(10), 1u);
     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);
@@ -36,10 +36,10 @@ UNORDERED_AUTO_TEST(insert_hint_empty2)
     BOOST_TEST_EQ(x.count("hello"), 1u);
     BOOST_TEST_EQ(x.find("hello")->second, 50);
     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");
@@ -47,10 +47,10 @@ UNORDERED_AUTO_TEST(insert_hint_single)
     BOOST_TEST_EQ(x.size(), 2u);
     BOOST_TEST_EQ(x.count("equal"), 2u);
     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,47 +67,47 @@ UNORDERED_AUTO_TEST(insert_hint_single2)
     BOOST_TEST(v0 != v1);
 
     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) {
-            typedef boost::unordered_multiset<std::string> container;
-            container x;
+      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");
-            }
-
-            BOOST_TEST_EQ(x.size(), size);
-
-            container::const_iterator position = x.cbegin();
-            for (unsigned int i = 0; i < offset; ++i) {
-                ++position;
-            }
-
-            x.insert(position, "multiple");
-
-            BOOST_TEST_EQ(x.size(), size + 1u);
-            BOOST_TEST_EQ(x.count("multiple"), size + 1u);
-            test::check_equivalent_keys(x);
+        for (unsigned int i = 0; i < size; ++i) {
+          x.insert("multiple");
         }
-    }
-}
 
-UNORDERED_AUTO_TEST(insert_hint_unique)
-{
+        BOOST_TEST_EQ(x.size(), size);
+
+        container::const_iterator position = x.cbegin();
+        for (unsigned int i = 0; i < offset; ++i) {
+          ++position;
+        }
+
+        x.insert(position, "multiple");
+
+        BOOST_TEST_EQ(x.size(), size + 1u);
+        BOOST_TEST_EQ(x.count("multiple"), size + 1u);
+        test::check_equivalent_keys(x);
+      }
+    }
+  }
+
+  UNORDERED_AUTO_TEST(insert_hint_unique)
+  {
     typedef boost::unordered_set<int> container;
     container x;
     x.insert(x.cbegin(), 10);
     BOOST_TEST_EQ(x.size(), 1u);
     BOOST_TEST_EQ(x.count(10), 1u);
     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);
@@ -122,7 +122,7 @@ UNORDERED_AUTO_TEST(insert_hint_unique_single)
     BOOST_TEST_EQ(x.count(10), 1u);
     BOOST_TEST_EQ(x.count(20), 1u);
     test::check_equivalent_keys(x);
-}
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/insert_node_type_fail.cpp b/test/unordered/insert_node_type_fail.cpp
index 27bab78b..eb34930f 100644
--- a/test/unordered/insert_node_type_fail.cpp
+++ b/test/unordered/insert_node_type_fail.cpp
@@ -9,26 +9,26 @@
 int main()
 {
 #if defined(UNORDERED_TEST_MAP)
-    typedef boost::unordered_map<int, int> container;
-    container x;
-    x.emplace(1, 1);
+  typedef boost::unordered_map<int, int> container;
+  container x;
+  x.emplace(1, 1);
 #elif defined(UNORDERED_TEST_MULTIMAP)
-    typedef boost::unordered_multimap<int, int> container;
-    container x;
+  typedef boost::unordered_multimap<int, int> container;
+  container x;
 #elif defined(UNORDERED_TEST_SET)
-    typedef boost::unordered_set<int> container;
-    container x;
-    x.emplace(1);
+  typedef boost::unordered_set<int> container;
+  container x;
+  x.emplace(1);
 #elif defined(UNORDERED_TEST_MULTISET)
-    typedef boost::unordered_multiset<int> container;
-    container x;
-    x.emplace(1);
+  typedef boost::unordered_multiset<int> container;
+  container x;
+  x.emplace(1);
 #else
 #define UNORDERED_ERROR
 #endif
 
 #if !defined(UNORDERED_ERROR)
-    container::node_type n = x.extract(x.begin());
-    x.insert(n);
+  container::node_type n = x.extract(x.begin());
+  x.insert(n);
 #endif
 }
diff --git a/test/unordered/insert_stable_tests.cpp b/test/unordered/insert_stable_tests.cpp
index 9915c10b..4ea6a84b 100644
--- a/test/unordered/insert_stable_tests.cpp
+++ b/test/unordered/insert_stable_tests.cpp
@@ -13,8 +13,8 @@
 #include "../helpers/test.hpp"
 
 namespace insert_stable {
-struct member
-{
+  struct member
+  {
     int tag1_;
     int tag2_;
 
@@ -23,14 +23,14 @@ struct member
 
     friend bool operator==(member const& x, member const& y)
     {
-        return x.tag1_ == y.tag1_;
+      return x.tag1_ == y.tag1_;
     }
 
     friend bool operator!=(member const& x, member const& y)
     {
-        return x.tag1_ != y.tag1_;
+      return x.tag1_ != y.tag1_;
     }
-};
+  };
 }
 
 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
@@ -39,10 +39,10 @@ namespace boost
 namespace insert_stable
 #endif
 {
-std::size_t hash_value(insert_stable::member const& x)
-{
+  std::size_t hash_value(insert_stable::member const& x)
+  {
     return static_cast<std::size_t>(x.tag1_);
-}
+  }
 }
 
 // This is no longer supported, as there's no longer an efficient way to get to
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index 3f68d316..1a37e357 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -23,11 +23,11 @@
 
 namespace insert_tests {
 
-test::seed_t initialize_seed(243432);
+  test::seed_t initialize_seed(243432);
 
-template <class X>
-void unique_insert_tests1(X*, test::random_generator generator)
-{
+  template <class X>
+  void unique_insert_tests1(X*, test::random_generator generator)
+  {
     test::check_instances check_;
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@@ -35,428 +35,21 @@ void unique_insert_tests1(X*, test::random_generator generator)
 
     UNORDERED_SUB_TEST("insert(value) tests for containers with unique keys")
     {
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
 
-        test::random_values<X> v(1000, generator);
+      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();
-            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);
-
-            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))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
-        }
-
-        test::check_equivalent_keys(x);
-    }
-
-    UNORDERED_SUB_TEST("insert(rvalue) tests for containers with unique keys")
-    {
-        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) {
-
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
-
-            typename X::value_type value = *it;
-            std::pair<iterator, bool> r1 = x.insert(boost::move(value));
-            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))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
-        }
-
-        test::check_equivalent_keys(x);
-    }
-}
-
-template <class X>
-void equivalent_insert_tests1(X*, test::random_generator generator)
-{
-    test::check_instances check_;
-
-    UNORDERED_SUB_TEST(
-        "insert(value) tests for containers with equivalent keys")
-    {
-        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) {
-            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_TEST(*r1 == *r2);
-
-            tracker.compare_key(x, *it);
-
-            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);
-    }
-
-    UNORDERED_SUB_TEST(
-        "insert(rvalue) tests for containers with equivalent keys")
-    {
-        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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
-
-            typename X::value_type value = *it;
-            BOOST_DEDUCED_TYPENAME X::iterator r1 =
-                x.insert(boost::move(value));
-            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))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
-        }
-
-        test::check_equivalent_keys(x);
-    }
-}
-
-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;
-
-    UNORDERED_SUB_TEST("insert(begin(), value) tests")
-    {
-        test::check_instances check_;
-
-        X x;
-        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();
-            float b = x.max_load_factor();
-
-            iterator r1 = x.insert(x.begin(), *it);
-            tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_TEST(*r1 == *r2);
-            tracker.compare_key(x, *it);
-
-            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);
-    }
-
-    UNORDERED_SUB_TEST("insert(end(), value) tests")
-    {
-        test::check_instances check_;
-
-        X x;
-        X const& x_const = x;
-        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();
-            float b = x.max_load_factor();
-
-            const_iterator r1 = x.insert(x_const.end(), *it);
-            tracker_iterator r2 = tracker.insert(tracker.end(), *it);
-            BOOST_TEST(*r1 == *r2);
-            tracker.compare_key(x, *it);
-
-            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);
-    }
-
-    UNORDERED_SUB_TEST("insert(pos, value) tests")
-    {
-        test::check_instances check_;
-
-        X x;
-        const_iterator pos = x.begin();
-        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();
-            float b = x.max_load_factor();
-
-            pos = x.insert(pos, *it);
-            tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_TEST(*pos == *r2);
-            tracker.compare_key(x, *it);
-
-            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);
-    }
-
-    UNORDERED_SUB_TEST("insert(pos, rvalue) tests")
-    {
-        test::check_instances check_;
-
-        X x;
-        const_iterator pos = x.begin();
-        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();
-            float b = x.max_load_factor();
-
-            typename X::value_type value = *it;
-            pos = x.insert(pos, boost::move(value));
-            tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_TEST(*pos == *r2);
-            tracker.compare_key(x, *it);
-
-            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);
-    }
-
-    UNORDERED_SUB_TEST("insert single item range tests")
-    {
-        test::check_instances check_;
-
-        X x;
-        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();
-            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))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
-        }
-
-        tracker.compare(x);
-        test::check_equivalent_keys(x);
-    }
-
-    UNORDERED_SUB_TEST("insert range tests")
-    {
-        test::check_instances check_;
-
-        X x;
-
-        test::random_values<X> v(1000, generator);
-        x.insert(v.begin(), v.end());
-
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
-    }
-
-    UNORDERED_SUB_TEST("insert range with rehash tests")
-    {
-        test::check_instances check_;
-
-        X x;
-
-        test::random_values<X> v(1000, generator);
-
-        x.insert(*v.begin());
-        x.clear();
-
-        x.insert(v.begin(), v.end());
-
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
-    }
-
-    UNORDERED_SUB_TEST("insert input iterator range tests")
-    {
-        test::check_instances check_;
-
-        X x;
-
-        test::random_values<X> v(1000, generator);
-        BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
-            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);
-    }
-
-    UNORDERED_SUB_TEST("insert copy iterator range tests")
-    {
-        test::check_instances check_;
-
-        X x;
-
-        test::random_values<X> v(1000, generator);
-        x.insert(test::copy_iterator(v.begin()), test::copy_iterator(v.end()));
-        test::check_container(x, v);
-
-        test::check_equivalent_keys(x);
-    }
-
-    UNORDERED_SUB_TEST("insert copy iterator range test 2")
-    {
-        test::check_instances check_;
-
-        X x;
-
-        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()));
-
-        test::check_equivalent_keys(x);
-    }
-
-    UNORDERED_SUB_TEST("insert various ranges")
-    {
-        for (int i = 0; i < 100; ++i) {
-            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();) {
-                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;
-                for (std::size_t j = test::random_value(20); j > 0; ++j) {
-                    ++next;
-                    if (next == v.end()) {
-                        break;
-                    }
-                }
-
-                x.insert(it, next);
-                tracker.insert(it, next);
-                it = next;
-
-                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))
-                    BOOST_TEST(x.bucket_count() == old_bucket_count);
-            }
-
-            test::check_equivalent_keys(x);
-        }
-    }
-}
-
-template <class X>
-void unique_emplace_tests1(X*, test::random_generator generator)
-{
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef test::ordered<X> ordered;
-
-    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<iterator, bool> r1 = x.insert(*it);
         std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 =
-            tracker.insert(*it);
+          tracker.insert(*it);
 
         BOOST_TEST(r1.second == r2.second);
         BOOST_TEST(*r1.first == *r2.first);
@@ -465,28 +58,66 @@ void unique_emplace_tests1(X*, test::random_generator generator)
 
         if (static_cast<double>(x.size()) <=
             b * static_cast<double>(old_bucket_count))
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
     }
 
-    tracker.compare(x);
-    test::check_equivalent_keys(x);
-}
+    UNORDERED_SUB_TEST("insert(rvalue) tests for containers with unique keys")
+    {
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
 
-template <class X>
-void equivalent_emplace_tests1(X*, test::random_generator generator)
-{
-    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) {
 
-    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();
         float b = x.max_load_factor();
 
-        BOOST_DEDUCED_TYPENAME X::iterator r1 = x.emplace(*it);
+        typename X::value_type value = *it;
+        std::pair<iterator, bool> r1 = x.insert(boost::move(value));
+        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))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  template <class X>
+  void equivalent_insert_tests1(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    UNORDERED_SUB_TEST(
+      "insert(value) tests for containers with equivalent keys")
+    {
+      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) {
+        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);
+          tracker.insert(*it);
 
         BOOST_TEST(*r1 == *r2);
 
@@ -494,15 +125,312 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
 
         if (static_cast<double>(x.size()) <=
             b * static_cast<double>(old_bucket_count))
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
     }
 
-    tracker.compare(x);
-    test::check_equivalent_keys(x);
-}
+    UNORDERED_SUB_TEST(
+      "insert(rvalue) tests for containers with equivalent keys")
+    {
+      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) {
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        typename X::value_type value = *it;
+        BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(boost::move(value));
+        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))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  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;
+
+    UNORDERED_SUB_TEST("insert(begin(), value) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      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();
+        float b = x.max_load_factor();
+
+        iterator r1 = x.insert(x.begin(), *it);
+        tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
+        BOOST_TEST(*r1 == *r2);
+        tracker.compare_key(x, *it);
+
+        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);
+    }
+
+    UNORDERED_SUB_TEST("insert(end(), value) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      X const& x_const = x;
+      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();
+        float b = x.max_load_factor();
+
+        const_iterator r1 = x.insert(x_const.end(), *it);
+        tracker_iterator r2 = tracker.insert(tracker.end(), *it);
+        BOOST_TEST(*r1 == *r2);
+        tracker.compare_key(x, *it);
+
+        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);
+    }
+
+    UNORDERED_SUB_TEST("insert(pos, value) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      const_iterator pos = x.begin();
+      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();
+        float b = x.max_load_factor();
+
+        pos = x.insert(pos, *it);
+        tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
+        BOOST_TEST(*pos == *r2);
+        tracker.compare_key(x, *it);
+
+        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);
+    }
+
+    UNORDERED_SUB_TEST("insert(pos, rvalue) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      const_iterator pos = x.begin();
+      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();
+        float b = x.max_load_factor();
+
+        typename X::value_type value = *it;
+        pos = x.insert(pos, boost::move(value));
+        tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
+        BOOST_TEST(*pos == *r2);
+        tracker.compare_key(x, *it);
+
+        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);
+    }
+
+    UNORDERED_SUB_TEST("insert single item range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      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();
+        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))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+      x.insert(v.begin(), v.end());
+
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert range with rehash tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+
+      x.insert(*v.begin());
+      x.clear();
+
+      x.insert(v.begin(), v.end());
+
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert input iterator range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+      BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator 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);
+    }
+
+    UNORDERED_SUB_TEST("insert copy iterator range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+      x.insert(test::copy_iterator(v.begin()), test::copy_iterator(v.end()));
+      test::check_container(x, v);
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert copy iterator range test 2")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      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()));
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert various ranges")
+    {
+      for (int i = 0; i < 100; ++i) {
+        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();) {
+          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;
+          for (std::size_t j = test::random_value(20); j > 0; ++j) {
+            ++next;
+            if (next == v.end()) {
+              break;
+            }
+          }
+
+          x.insert(it, next);
+          tracker.insert(it, next);
+          it = next;
+
+          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))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
+        }
+
+        test::check_equivalent_keys(x);
+      }
+    }
+  }
+
+  template <class X>
+  void unique_emplace_tests1(X*, test::random_generator generator)
+  {
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+    typedef test::ordered<X> ordered;
 
-template <class X> void move_emplace_tests(X*, test::random_generator generator)
-{
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -511,25 +439,86 @@ template <class X> void move_emplace_tests(X*, test::random_generator 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();
-        float b = x.max_load_factor();
+      BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
 
-        typename X::value_type value = *it;
-        x.emplace(boost::move(value));
+      std::pair<iterator, bool> r1 = x.emplace(*it);
+      std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 =
         tracker.insert(*it);
-        tracker.compare_key(x, *it);
 
-        if (static_cast<double>(x.size()) <=
-            b * static_cast<double>(old_bucket_count))
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+      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))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
     tracker.compare(x);
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X> void default_emplace_tests(X*, test::random_generator)
-{
+  template <class X>
+  void equivalent_emplace_tests1(X*, test::random_generator generator)
+  {
+    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) {
+      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_TEST(*r1 == *r2);
+
+      tracker.compare_key(x, *it);
+
+      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);
+  }
+
+  template <class X>
+  void move_emplace_tests(X*, test::random_generator generator)
+  {
+    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) {
+
+      BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
+
+      typename X::value_type value = *it;
+      x.emplace(boost::move(value));
+      tracker.insert(*it);
+      tracker.compare_key(x, *it);
+
+      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);
+  }
+
+  template <class X> void default_emplace_tests(X*, test::random_generator)
+  {
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
     bool is_unique = test::has_unique_keys<X>::value;
 
@@ -561,334 +550,325 @@ template <class X> void default_emplace_tests(X*, test::random_generator)
     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)
+  {
     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) {
-        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-        float b = x.max_load_factor();
+      BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
 
-        x[it->first] = it->second;
-        tracker[it->first] = it->second;
+      x[it->first] = it->second;
+      tracker[it->first] = it->second;
 
-        tracker.compare_key(x, *it);
+      tracker.compare_key(x, *it);
 
-        if (static_cast<double>(x.size()) <=
-            b * static_cast<double>(old_bucket_count))
-            BOOST_TEST(x.bucket_count() == 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);
-}
+  }
 
-template <class X> void map_tests2(X*, test::random_generator generator)
-{
+  template <class X> void map_tests2(X*, test::random_generator generator)
+  {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("insert_or_assign")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            std::pair<iterator, bool> r =
-                x.insert_or_assign(it->first, it->second);
-            BOOST_TEST(*r.first == *it);
+        std::pair<iterator, bool> r = x.insert_or_assign(it->first, it->second);
+        BOOST_TEST(*r.first == *it);
 
-            tracker[it->first] = it->second;
-            tracker.compare_key(x, *it);
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
 
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == 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);
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("insert_or_assign(begin)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator r = x.insert_or_assign(x.begin(), it->first, it->second);
-            BOOST_TEST(*r == *it);
+        iterator r = x.insert_or_assign(x.begin(), it->first, it->second);
+        BOOST_TEST(*r == *it);
 
-            tracker[it->first] = it->second;
-            tracker.compare_key(x, *it);
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
 
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == 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);
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("insert_or_assign(end)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator r = x.insert_or_assign(x.end(), it->first, it->second);
-            BOOST_TEST(*r == *it);
+        iterator r = x.insert_or_assign(x.end(), it->first, it->second);
+        BOOST_TEST(*r == *it);
 
-            tracker[it->first] = it->second;
-            tracker.compare_key(x, *it);
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
 
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == 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);
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
     }
 
     UNORDERED_SUB_TEST("insert_or_assign(last)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
-        iterator last = x.begin();
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+      iterator last = x.begin();
 
-        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();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator r = x.insert_or_assign(last, it->first, it->second);
-            BOOST_TEST(*r == *it);
+        iterator r = x.insert_or_assign(last, it->first, it->second);
+        BOOST_TEST(*r == *it);
 
-            tracker[it->first] = it->second;
-            tracker.compare_key(x, *it);
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
 
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
 
-            last = r;
-        }
+        last = r;
+      }
 
-        tracker.compare(x);
-        test::check_equivalent_keys(x);
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
     }
-}
+  }
 
-template <class X> void try_emplace_tests(X*, test::random_generator generator)
-{
+  template <class X>
+  void try_emplace_tests(X*, test::random_generator generator)
+  {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("try_emplace(key, value)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator pos = x.find(it->first);
-            bool found = pos != x.end();
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
 
-            std::pair<typename X::iterator, bool> r =
-                x.try_emplace(it->first, it->second);
-            if (found) {
-                BOOST_TEST(pos == r.first);
-                BOOST_TEST(!r.second);
-            } else {
-                BOOST_TEST(r.second);
-            }
-            BOOST_TEST_EQ(r.first->first, it->first);
-            BOOST_TEST_EQ(r.first->second, it->second);
-
-            tracker.insert(*it);
-            tracker.compare_key(x, *it);
-
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+        std::pair<typename X::iterator, bool> r =
+          x.try_emplace(it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r.first);
+          BOOST_TEST(!r.second);
+        } else {
+          BOOST_TEST(r.second);
         }
+        BOOST_TEST_EQ(r.first->first, it->first);
+        BOOST_TEST_EQ(r.first->second, it->second);
 
-        test::check_equivalent_keys(x);
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        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);
     }
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("try_emplace(begin(), key, value)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator pos = x.find(it->first);
-            bool found = pos != x.end();
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
 
-            typename X::iterator r =
-                x.try_emplace(r.begin(), it->first, it->second);
-            if (found) {
-                BOOST_TEST(pos == r);
-            }
-            BOOST_TEST_EQ(r->first, it->first);
-            BOOST_TEST_EQ(r->second, it->second);
-
-            tracker.insert(*it);
-            tracker.compare_key(x, *it);
-
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+        typename X::iterator r =
+          x.try_emplace(r.begin(), it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r);
         }
+        BOOST_TEST_EQ(r->first, it->first);
+        BOOST_TEST_EQ(r->second, it->second);
 
-        test::check_equivalent_keys(x);
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        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);
     }
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("try_emplace(end(), key, value)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator pos = x.find(it->first);
-            bool found = pos != x.end();
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
 
-            typename X::iterator r =
-                x.try_emplace(r.end(), it->first, it->second);
-            if (found) {
-                BOOST_TEST(pos == r);
-            }
-            BOOST_TEST_EQ(r->first, it->first);
-            BOOST_TEST_EQ(r->second, it->second);
-
-            tracker.insert(*it);
-            tracker.compare_key(x, *it);
-
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+        typename X::iterator r = x.try_emplace(r.end(), it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r);
         }
+        BOOST_TEST_EQ(r->first, it->first);
+        BOOST_TEST_EQ(r->second, it->second);
 
-        test::check_equivalent_keys(x);
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        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);
     }
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("try_emplace(pos, key, value)")
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x;
-        test::ordered<X> tracker = test::create_ordered(x);
+      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) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
-                x.bucket_count();
-            float b = x.max_load_factor();
+      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();
+        float b = x.max_load_factor();
 
-            iterator pos = x.find(it->first);
-            bool found = pos != x.end();
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
 
-            typename X::iterator r = x.try_emplace(pos, it->first, it->second);
-            if (found) {
-                BOOST_TEST(pos == r);
-            }
-            BOOST_TEST_EQ(r->first, it->first);
-            BOOST_TEST_EQ(r->second, it->second);
-
-            tracker.insert(*it);
-            tracker.compare_key(x, *it);
-
-            if (static_cast<double>(x.size()) <
-                b * static_cast<double>(old_bucket_count))
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+        typename X::iterator r = x.try_emplace(pos, it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r);
         }
+        BOOST_TEST_EQ(r->first, it->first);
+        BOOST_TEST_EQ(r->second, it->second);
 
-        test::check_equivalent_keys(x);
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        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);
     }
-}
+  }
 
-// Some tests for when the range's value type doesn't match the container's
-// value type.
+  // Some tests for when the range's value type doesn't match the container's
+  // value type.
 
-template <class X>
-void map_insert_range_test1(X*, test::random_generator generator)
-{
+  template <class X>
+  void map_insert_range_test1(X*, test::random_generator generator)
+  {
     test::check_instances check_;
 
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type,
-        BOOST_DEDUCED_TYPENAME X::mapped_type> >
-        list;
+      BOOST_DEDUCED_TYPENAME X::mapped_type> >
+      list;
     test::random_values<X> v(1000, generator);
     list l(v.begin(), v.end());
 
@@ -896,109 +876,108 @@ void map_insert_range_test1(X*, test::random_generator generator)
     x.insert(l.begin(), l.end());
 
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X>
-void map_insert_range_test2(X*, test::random_generator generator)
-{
+  template <class X>
+  void map_insert_range_test2(X*, test::random_generator generator)
+  {
     test::check_instances check_;
 
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type const,
-        test::implicitly_convertible> >
-        list;
+      test::implicitly_convertible> >
+      list;
     test::random_values<boost::unordered_map<BOOST_DEDUCED_TYPENAME X::key_type,
-        test::implicitly_convertible> >
-        v(1000, generator);
+      test::implicitly_convertible> >
+      v(1000, generator);
     list l(v.begin(), v.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,
+  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,
+  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;
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
 
-UNORDERED_TEST(unique_insert_tests1,
+  UNORDERED_TEST(unique_insert_tests1,
     ((test_set_std_alloc)(test_set)(test_map))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(equivalent_insert_tests1,
+  UNORDERED_TEST(equivalent_insert_tests1,
     ((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,
+  UNORDERED_TEST(unique_emplace_tests1,
     ((test_set_std_alloc)(test_set)(test_map))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(equivalent_emplace_tests1,
+  UNORDERED_TEST(equivalent_emplace_tests1,
     ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(move_emplace_tests,
+  UNORDERED_TEST(move_emplace_tests,
     ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
-        test_multiset)(test_multimap))(
+      test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(default_emplace_tests,
+  UNORDERED_TEST(default_emplace_tests,
     ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
-        test_multiset)(test_multimap))(
+      test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(map_tests,
+  UNORDERED_TEST(map_tests,
     ((test_map))((default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     map_tests2, ((test_map))((default_generator)(generate_collisions)))
 
-UNORDERED_TEST(map_insert_range_test1,
+  UNORDERED_TEST(map_insert_range_test1,
     ((test_multimap_std_alloc)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(map_insert_range_test2,
+  UNORDERED_TEST(map_insert_range_test2,
     ((test_multimap_std_alloc)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-struct initialize_from_two_ints
-{
+  struct initialize_from_two_ints
+  {
     int a, b;
 
     friend std::size_t hash_value(initialize_from_two_ints const& x)
     {
-        return static_cast<std::size_t>(x.a + x.b);
+      return static_cast<std::size_t>(x.a + x.b);
     }
 
     bool operator==(initialize_from_two_ints const& x) const
     {
-        return a == x.a && b == x.b;
+      return a == x.a && b == x.b;
     }
-};
+  };
 
-UNORDERED_AUTO_TEST(insert_initializer_list_set)
-{
+  UNORDERED_AUTO_TEST(insert_initializer_list_set)
+  {
     boost::unordered_set<int> set;
     set.insert({1, 2, 3, 1});
     BOOST_TEST_EQ(set.size(), 3u);
@@ -1032,12 +1011,12 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
     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)
 
-UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
-{
+  UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
+  {
     boost::unordered_multiset<std::string> multiset;
     // multiset.insert({});
     BOOST_TEST(multiset.empty());
@@ -1050,33 +1029,33 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
     BOOST_TEST_EQ(multiset.count("a"), 2u);
     BOOST_TEST_EQ(multiset.count("b"), 1u);
     BOOST_TEST_EQ(multiset.count("c"), 0u);
-}
+  }
 
 #endif
 
-UNORDERED_AUTO_TEST(insert_initializer_list_map)
-{
+  UNORDERED_AUTO_TEST(insert_initializer_list_map)
+  {
     boost::unordered_map<std::string, std::string> map;
     // map.insert({});
     BOOST_TEST(map.empty());
     map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(map.size(), 2u);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
-{
+  UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
+  {
     boost::unordered_multimap<std::string, std::string> multimap;
     // multimap.insert({});
     BOOST_TEST(multimap.empty());
     multimap.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(multimap.size(), 3u);
     BOOST_TEST_EQ(multimap.count("a"), 2u);
-}
+  }
 
 #endif
 
-struct overloaded_constructor
-{
+  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_)
     {
@@ -1086,63 +1065,63 @@ struct overloaded_constructor
 
     bool operator==(overloaded_constructor const& rhs) const
     {
-        return x1 == rhs.x1 && x2 == rhs.x2 && x3 == rhs.x3 && x4 == rhs.x4;
+      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;
-        boost::hash_combine(hash, x.x1);
-        boost::hash_combine(hash, x.x2);
-        boost::hash_combine(hash, x.x3);
-        boost::hash_combine(hash, x.x4);
-        return hash;
+      std::size_t hash = 0;
+      boost::hash_combine(hash, x.x1);
+      boost::hash_combine(hash, x.x2);
+      boost::hash_combine(hash, x.x3);
+      boost::hash_combine(hash, x.x4);
+      return hash;
     }
-};
+  };
 
-UNORDERED_AUTO_TEST(map_emplace_test)
-{
+  UNORDERED_AUTO_TEST(map_emplace_test)
+  {
     {
-        boost::unordered_map<int, overloaded_constructor, test::hash,
-            test::equal_to,
-            test::allocator1<std::pair<int const, overloaded_constructor> > >
-            x;
+      boost::unordered_map<int, overloaded_constructor, test::hash,
+        test::equal_to,
+        test::allocator1<std::pair<int const, overloaded_constructor> > >
+        x;
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-        x.emplace();
-        BOOST_TEST(x.find(0) != x.end() &&
-                   x.find(0)->second == overloaded_constructor());
+      x.emplace();
+      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));
+      x.emplace(2, 3);
+      BOOST_TEST(
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
 
-        x.try_emplace(5);
-        BOOST_TEST(x.find(5) != x.end() &&
-                   x.find(5)->second == overloaded_constructor());
+      x.try_emplace(5);
+      BOOST_TEST(
+        x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
     }
 
     {
-        boost::unordered_multimap<int, overloaded_constructor, test::hash,
-            test::equal_to,
-            test::allocator1<std::pair<int const, overloaded_constructor> > >
-            x;
+      boost::unordered_multimap<int, overloaded_constructor, test::hash,
+        test::equal_to,
+        test::allocator1<std::pair<int const, overloaded_constructor> > >
+        x;
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-        x.emplace();
-        BOOST_TEST(x.find(0) != x.end() &&
-                   x.find(0)->second == overloaded_constructor());
+      x.emplace();
+      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));
+      x.emplace(2, 3);
+      BOOST_TEST(
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
     }
-}
+  }
 
-UNORDERED_AUTO_TEST(set_emplace_test)
-{
+  UNORDERED_AUTO_TEST(set_emplace_test)
+  {
     boost::unordered_set<overloaded_constructor> x;
     overloaded_constructor check;
 
@@ -1170,151 +1149,151 @@ UNORDERED_AUTO_TEST(set_emplace_test)
     x.emplace(7, 8, 9, 10);
     check = overloaded_constructor(7, 8, 9, 10);
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
+  }
 
-struct derived_from_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
-{
+  struct convertible_to_piecewise
+  {
     operator boost::unordered::piecewise_construct_t() const
     {
-        return boost::unordered::piecewise_construct;
+      return boost::unordered::piecewise_construct;
     }
-};
+  };
 
-UNORDERED_AUTO_TEST(map_emplace_test2)
-{
+  UNORDERED_AUTO_TEST(map_emplace_test2)
+  {
     // Emulating piecewise construction with boost::tuple bypasses the
     // allocator's construct method, but still uses test destroy method.
     test::detail::disable_construction_tracking _scoped;
 
     {
-        boost::unordered_map<overloaded_constructor, overloaded_constructor,
-            boost::hash<overloaded_constructor>,
-            std::equal_to<overloaded_constructor>,
-            test::allocator1<std::pair<overloaded_constructor const,
-                overloaded_constructor> > >
-            x;
+      boost::unordered_map<overloaded_constructor, overloaded_constructor,
+        boost::hash<overloaded_constructor>,
+        std::equal_to<overloaded_constructor>,
+        test::allocator1<std::pair<overloaded_constructor const,
+          overloaded_constructor> > >
+        x;
 
-        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(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.find(overloaded_constructor(1))->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.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));
+      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.clear();
+      x.clear();
 
-        x.try_emplace(overloaded_constructor());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
-                   x.find(overloaded_constructor())->second ==
-                       overloaded_constructor());
+      x.try_emplace(overloaded_constructor());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.try_emplace(1);
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
-                   x.find(overloaded_constructor(1))->second ==
-                       overloaded_constructor());
+      x.try_emplace(1);
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
-        x.try_emplace(overloaded_constructor(2, 3), 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.try_emplace(overloaded_constructor(2, 3), 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.clear();
+      x.clear();
 
-        x.try_emplace(x.begin(), overloaded_constructor());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
-                   x.find(overloaded_constructor())->second ==
-                       overloaded_constructor());
+      x.try_emplace(x.begin(), overloaded_constructor());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.try_emplace(x.end(), 1);
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
-                   x.find(overloaded_constructor(1))->second ==
-                       overloaded_constructor());
+      x.try_emplace(x.end(), 1);
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
-        x.try_emplace(x.begin(), overloaded_constructor(2, 3), 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.try_emplace(x.begin(), overloaded_constructor(2, 3), 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));
     }
 
     {
-        boost::unordered_multimap<overloaded_constructor,
-            overloaded_constructor, boost::hash<overloaded_constructor>,
-            std::equal_to<overloaded_constructor>,
-            test::allocator1<std::pair<overloaded_constructor const,
-                overloaded_constructor> > >
-            x;
-
-        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.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));
-
-        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));
-    }
-}
-
-UNORDERED_AUTO_TEST(set_emplace_test2)
-{
-    boost::unordered_set<
-        std::pair<overloaded_constructor, overloaded_constructor> >
+      boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
+        boost::hash<overloaded_constructor>,
+        std::equal_to<overloaded_constructor>,
+        test::allocator1<std::pair<overloaded_constructor const,
+          overloaded_constructor> > >
         x;
+
+      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.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));
+
+      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));
+    }
+  }
+
+  UNORDERED_AUTO_TEST(set_emplace_test2)
+  {
+    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());
+      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));
+      boost::make_tuple(2, 3));
     check =
-        std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
+      std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
+  }
 
 // Use the preprocessor to generate tests using different combinations of
 // boost/std piecewise_construct_t/tuple.
@@ -1346,7 +1325,7 @@ UNORDERED_AUTO_TEST(set_emplace_test2)
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) &&                                      \
-    BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
+  BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
 
 #define PIECEWISE_TEST_NAME std_piecewise_tests
 #define PIECEWISE_NAMESPACE std
@@ -1364,115 +1343,115 @@ RUN_TESTS_QUIET()
 UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
 {
 #if EMULATING_PIECEWISE_CONSTRUCTION
-    test::detail::disable_construction_tracking _scoped;
+  test::detail::disable_construction_tracking _scoped;
 #endif
 
-    {
-        boost::unordered_map<overloaded_constructor, overloaded_constructor,
-            boost::hash<overloaded_constructor>,
-            std::equal_to<overloaded_constructor>,
-            test::allocator1<std::pair<overloaded_constructor const,
-                overloaded_constructor> > >
-            x;
+  {
+    boost::unordered_map<overloaded_constructor, overloaded_constructor,
+      boost::hash<overloaded_constructor>,
+      std::equal_to<overloaded_constructor>,
+      test::allocator1<std::pair<overloaded_constructor const,
+        overloaded_constructor> > >
+      x;
 
-        x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
-            TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
-                   x.find(overloaded_constructor())->second ==
-                       overloaded_constructor());
+    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+      TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
-            TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
-                   x.find(overloaded_constructor(1))->second ==
-                       overloaded_constructor());
+    x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
+      TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor(1)) != x.end() &&
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
-        x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
-            TUPLE_NAMESPACE::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(), TUPLE_NAMESPACE::make_tuple(2, 3),
+      TUPLE_NAMESPACE::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, TUPLE_NAMESPACE::make_tuple(9, 3, 1),
-            TUPLE_NAMESPACE::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));
+    derived_from_piecewise_construct_t d;
+    x.emplace(
+      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::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.clear();
+    x.clear();
 
-        x.try_emplace(overloaded_constructor());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
-                   x.find(overloaded_constructor())->second ==
-                       overloaded_constructor());
+    x.try_emplace(overloaded_constructor());
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.try_emplace(1);
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
-                   x.find(overloaded_constructor(1))->second ==
-                       overloaded_constructor());
+    x.try_emplace(1);
+    BOOST_TEST(
+      x.find(overloaded_constructor(1)) != x.end() &&
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
-        x.try_emplace(overloaded_constructor(2, 3), 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));
-    }
-    {
-        boost::unordered_multimap<overloaded_constructor,
-            overloaded_constructor, boost::hash<overloaded_constructor>,
-            std::equal_to<overloaded_constructor>,
-            test::allocator1<std::pair<overloaded_constructor const,
-                overloaded_constructor> > >
-            x;
+    x.try_emplace(overloaded_constructor(2, 3), 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));
+  }
+  {
+    boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
+      boost::hash<overloaded_constructor>,
+      std::equal_to<overloaded_constructor>,
+      test::allocator1<std::pair<overloaded_constructor const,
+        overloaded_constructor> > >
+      x;
 
-        x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
-            TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
-                   x.find(overloaded_constructor())->second ==
-                       overloaded_constructor());
+    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+      TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
-            TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
-                   x.find(overloaded_constructor(1))->second ==
-                       overloaded_constructor());
+    x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
+      TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor(1)) != x.end() &&
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
-        x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
-            TUPLE_NAMESPACE::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(), TUPLE_NAMESPACE::make_tuple(2, 3),
+      TUPLE_NAMESPACE::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, TUPLE_NAMESPACE::make_tuple(9, 3, 1),
-            TUPLE_NAMESPACE::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));
-    }
+    derived_from_piecewise_construct_t d;
+    x.emplace(
+      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::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(BOOST_PP_CAT(PIECEWISE_TEST_NAME, 2))
 {
 #if EMULATING_PIECEWISE_CONSTRUCTION
-    test::detail::disable_construction_tracking _scoped;
+  test::detail::disable_construction_tracking _scoped;
 #endif
 
-    boost::unordered_set<
-        std::pair<overloaded_constructor, overloaded_constructor> >
-        x;
-    std::pair<overloaded_constructor, overloaded_constructor> check;
+  boost::unordered_set<
+    std::pair<overloaded_constructor, overloaded_constructor> >
+    x;
+  std::pair<overloaded_constructor, overloaded_constructor> check;
 
-    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
-        TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+  x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+    TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+  BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
 
-    x.clear();
-    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
-        TUPLE_NAMESPACE::make_tuple(1), TUPLE_NAMESPACE::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);
+  x.clear();
+  x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+    TUPLE_NAMESPACE::make_tuple(1), TUPLE_NAMESPACE::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);
 }
 
 #undef PIECEWISE_TEST_NAME
diff --git a/test/unordered/link_test_1.cpp b/test/unordered/link_test_1.cpp
index 120bde59..c32c3ac9 100644
--- a/test/unordered/link_test_1.cpp
+++ b/test/unordered/link_test_1.cpp
@@ -11,16 +11,16 @@
 // clang-format on
 
 void foo(boost::unordered_set<int>&, boost::unordered_map<int, int>&,
-    boost::unordered_multiset<int>&, boost::unordered_multimap<int, int>&);
+  boost::unordered_multiset<int>&, boost::unordered_multimap<int, int>&);
 
 int main()
 {
-    boost::unordered_set<int> x1;
-    boost::unordered_map<int, int> x2;
-    boost::unordered_multiset<int> x3;
-    boost::unordered_multimap<int, int> x4;
+  boost::unordered_set<int> x1;
+  boost::unordered_map<int, int> x2;
+  boost::unordered_multiset<int> x3;
+  boost::unordered_multimap<int, int> x4;
 
-    foo(x1, x2, x3, x4);
+  foo(x1, x2, x3, x4);
 
-    return 0;
+  return 0;
 }
diff --git a/test/unordered/link_test_2.cpp b/test/unordered/link_test_2.cpp
index b76da7b0..5ccf60d5 100644
--- a/test/unordered/link_test_2.cpp
+++ b/test/unordered/link_test_2.cpp
@@ -11,20 +11,20 @@
 // 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)
+  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);
-    x2[2] = 2;
-    x3.insert(3);
-    x4.insert(std::make_pair(4, 5));
+  x1.insert(1);
+  x2[2] = 2;
+  x3.insert(3);
+  x4.insert(std::make_pair(4, 5));
 }
diff --git a/test/unordered/load_factor_tests.cpp b/test/unordered/load_factor_tests.cpp
index 6280d977..f59a4547 100644
--- a/test/unordered/load_factor_tests.cpp
+++ b/test/unordered/load_factor_tests.cpp
@@ -21,10 +21,10 @@
 
 namespace load_factor_tests {
 
-test::seed_t initialize_seed(783656);
+  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;
 
     BOOST_TEST(x.max_load_factor() == 1.0);
@@ -36,11 +36,11 @@ template <class X> void set_load_factor_tests(X*)
     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>
-void insert_test(X*, float mlf, test::random_generator generator)
-{
+  template <class X>
+  void insert_test(X*, float mlf, test::random_generator generator)
+  {
     X x;
     x.max_load_factor(mlf);
     float b = x.max_load_factor();
@@ -48,21 +48,21 @@ 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 = values.begin(),
+           end = values.end();
          it != end; ++it) {
-        BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
-                                            old_bucket_count = x.bucket_count();
-        x.insert(*it);
-        if (static_cast<double>(old_size + 1) <=
-            b * static_cast<double>(old_bucket_count))
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+      BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
+                                          old_bucket_count = x.bucket_count();
+      x.insert(*it);
+      if (static_cast<double>(old_size + 1) <=
+          b * static_cast<double>(old_bucket_count))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
-}
+  }
 
-template <class X>
-void load_factor_insert_tests(X* ptr, test::random_generator generator)
-{
+  template <class X>
+  void load_factor_insert_tests(X* ptr, test::random_generator generator)
+  {
     insert_test(ptr, 1.0f, generator);
     insert_test(ptr, 0.1f, generator);
     insert_test(ptr, 100.0f, generator);
@@ -70,22 +70,22 @@ void load_factor_insert_tests(X* ptr, test::random_generator 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);
-}
+      insert_test(ptr, std::numeric_limits<float>::infinity(), generator);
+  }
 
-boost::unordered_set<int>* int_set_ptr;
-boost::unordered_multiset<int>* int_multiset_ptr;
-boost::unordered_map<int, int>* int_map_ptr;
-boost::unordered_multimap<int, int>* int_multimap_ptr;
+  boost::unordered_set<int>* int_set_ptr;
+  boost::unordered_multiset<int>* int_multiset_ptr;
+  boost::unordered_map<int, int>* int_map_ptr;
+  boost::unordered_multimap<int, int>* int_multimap_ptr;
 
-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(set_load_factor_tests,
+  UNORDERED_TEST(set_load_factor_tests,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)))
 
-UNORDERED_TEST(load_factor_insert_tests,
+  UNORDERED_TEST(load_factor_insert_tests,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
 }
diff --git a/test/unordered/merge_tests.cpp b/test/unordered/merge_tests.cpp
index 8d0d4915..0ddfe53e 100644
--- a/test/unordered/merge_tests.cpp
+++ b/test/unordered/merge_tests.cpp
@@ -19,8 +19,8 @@
 
 namespace merge_tests {
 
-UNORDERED_AUTO_TEST(merge_set)
-{
+  UNORDERED_AUTO_TEST(merge_set)
+  {
     boost::unordered_set<int> x;
     boost::unordered_set<int> y;
 
@@ -57,10 +57,10 @@ UNORDERED_AUTO_TEST(merge_set)
 
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
-}
+  }
 
-UNORDERED_AUTO_TEST(merge_multiset)
-{
+  UNORDERED_AUTO_TEST(merge_multiset)
+  {
     boost::unordered_multiset<int> x;
     boost::unordered_multiset<int> y;
 
@@ -97,10 +97,10 @@ UNORDERED_AUTO_TEST(merge_multiset)
 
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
-}
+  }
 
-UNORDERED_AUTO_TEST(merge_set_and_multiset)
-{
+  UNORDERED_AUTO_TEST(merge_set_and_multiset)
+  {
     boost::unordered_set<int> x;
     boost::unordered_multiset<int> y;
 
@@ -137,11 +137,11 @@ UNORDERED_AUTO_TEST(merge_set_and_multiset)
 
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
-}
+  }
 
-template <class X1, class X2>
-void merge_empty_test(X1*, X2*, test::random_generator generator)
-{
+  template <class X1, class X2>
+  void merge_empty_test(X1*, X2*, test::random_generator generator)
+  {
     test::check_instances check_;
 
     test::random_values<X1> v(1000, generator);
@@ -152,11 +152,11 @@ void merge_empty_test(X1*, X2*, test::random_generator generator)
     BOOST_TEST(x2.empty());
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-template <class X>
-void merge_into_empty_test(X*, test::random_generator generator)
-{
+  template <class X>
+  void merge_into_empty_test(X*, test::random_generator generator)
+  {
     test::check_instances check_;
 
     test::random_values<X> v(1000, generator);
@@ -167,12 +167,12 @@ void merge_into_empty_test(X*, test::random_generator generator)
     BOOST_TEST(x2.empty());
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-template <class X1, class X2>
-void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
+  template <class X1, class X2>
+  void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     test::random_values<X1> v1(1000, generator);
@@ -181,17 +181,17 @@ void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     v2.insert(v1.begin(), boost::next(v1.begin(), 100));
 
     X1 x1(v1.begin(), v1.end(), 0, test::hash(hash_equal1),
-        test::equal_to(hash_equal1));
+      test::equal_to(hash_equal1));
     X2 x2(v2.begin(), v2.end(), 0, test::hash(hash_equal2),
-        test::equal_to(hash_equal2));
+      test::equal_to(hash_equal2));
 
     test::ordered<X1> tracker1 = test::create_ordered(x1);
     test::ordered<X2> tracker2 = test::create_ordered(x2);
     tracker1.insert(v1.begin(), v1.end());
     for (typename X2::iterator it = x2.begin(); it != x2.end(); ++it) {
-        if (!tracker1.insert(*it).second) {
-            tracker2.insert(*it);
-        }
+      if (!tracker1.insert(*it).second) {
+        tracker2.insert(*it);
+      }
     }
 
     x1.merge(x2);
@@ -200,12 +200,12 @@ void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     tracker2.compare(x2);
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-template <class X1, class X2>
-void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
+  template <class X1, class X2>
+  void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     test::random_values<X1> v1(1000, generator);
@@ -214,9 +214,9 @@ void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     v2.insert(v1.begin(), boost::next(v1.begin(), 100));
 
     X1 x1(v1.begin(), v1.end(), 0, test::hash(hash_equal1),
-        test::equal_to(hash_equal1));
+      test::equal_to(hash_equal1));
     X2 x2(v2.begin(), v2.end(), 0, test::hash(hash_equal2),
-        test::equal_to(hash_equal2));
+      test::equal_to(hash_equal2));
     x1.merge(x2);
 
     test::ordered<X1> tracker1 = test::create_ordered(x1);
@@ -230,32 +230,32 @@ void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     tracker2.compare(x2);
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-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_multiset<test::movable, test::hash, test::equal_to,
+  boost::unordered_multiset<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_multiset_std_alloc;
 
-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_multimap<test::object, test::object, test::hash,
+  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::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::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::movable, test::movable, test::hash,
+  boost::unordered_multimap<test::movable, test::movable, test::hash,
     test::equal_to, test::allocator2<test::movable> >* test_multimap;
 
-using test::default_generator;
-using test::generate_collisions;
+  using test::default_generator;
+  using test::generate_collisions;
 
-// clang-format off
+  // clang-format off
 UNORDERED_TEST(merge_empty_test,
     ((test_set_std_alloc)(test_multiset_std_alloc))
     ((test_set_std_alloc)(test_multiset_std_alloc))
@@ -335,7 +335,7 @@ UNORDERED_TEST(merge_into_equiv_keys_test,
     ((0)(1)(2))
     ((0)(1)(2))
     ((default_generator)(generate_collisions)))
-// clang-format on
+  // clang-format on
 }
 
 RUN_TESTS()
diff --git a/test/unordered/minimal_allocator.cpp b/test/unordered/minimal_allocator.cpp
index 968f11fb..f80002ca 100644
--- a/test/unordered/minimal_allocator.cpp
+++ b/test/unordered/minimal_allocator.cpp
@@ -11,83 +11,82 @@
 
 template <class Tp> struct SimpleAllocator
 {
-    typedef Tp value_type;
+  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)
-    {
-        return static_cast<Tp*>(::operator new(n * sizeof(Tp)));
-    }
+  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()
 {
-    test::check_instances check_;
+  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));
+  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);
-    BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
-    BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
 
-    // rebind_alloc
-    // rebind_traits
+  // rebind_alloc
+  // rebind_traits
 
-    SimpleAllocator<T> a;
+  SimpleAllocator<T> a;
 
-    T* ptr1 = traits::allocate(a, 1);
-    // T* ptr2 = traits::allocate(a, 1, static_cast<void const*>(ptr1));
+  T* ptr1 = traits::allocate(a, 1);
+  // 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, ptr1, T(10));
+  // traits::construct(a, ptr2, T(30), ptr1);
 
-    BOOST_TEST(*ptr1 == T(10));
-    // BOOST_TEST(*ptr2 == T(30));
+  BOOST_TEST(*ptr1 == T(10));
+  // BOOST_TEST(*ptr2 == T(30));
 
-    traits::destroy(a, ptr1);
-    // traits::destroy(a, ptr2);
+  traits::destroy(a, ptr1);
+  // traits::destroy(a, ptr2);
 
-    // traits::deallocate(a, ptr2, 1);
-    traits::deallocate(a, ptr1, 1);
+  // traits::deallocate(a, ptr2, 1);
+  traits::deallocate(a, ptr1, 1);
 
-    traits::max_size(a);
+  traits::max_size(a);
 }
 
 int main()
 {
-    test_simple_allocator<int>();
-    test_simple_allocator<test::object>();
+  test_simple_allocator<int>();
+  test_simple_allocator<test::object>();
 
-    return boost::report_errors();
+  return boost::report_errors();
 }
diff --git a/test/unordered/move_tests.cpp b/test/unordered/move_tests.cpp
index aa2420e9..13f19d74 100644
--- a/test/unordered/move_tests.cpp
+++ b/test/unordered/move_tests.cpp
@@ -23,90 +23,90 @@
 #endif
 
 namespace move_tests {
-test::seed_t initialize_seed(98624);
+  test::seed_t initialize_seed(98624);
 #if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+  !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)
-{
+  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,
+  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)
-{
+  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);
+      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::check_instances check_;
 
-        test::random_values<T> v(1000, generator);
-        test::object_count count;
-        T y(create(v, count));
+      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);
+      BOOST_TEST(count == test::global_object_count);
 #endif
-        test::check_container(y, v);
-        test::check_equivalent_keys(y);
+      test::check_container(y, v);
+      test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
-void move_assign_tests1(T*, test::random_generator const& generator)
-{
+  template <class T>
+  void move_assign_tests1(T*, test::random_generator const& generator)
+  {
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(500, generator);
-        test::object_count count;
-        T y;
-        y = create(v, count);
+      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);
+      BOOST_TEST(count == test::global_object_count);
 #endif
-        test::check_container(y, v);
-        test::check_equivalent_keys(y);
+      test::check_container(y, v);
+      test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
-void move_construct_tests2(T*, test::random_generator const& generator)
-{
+  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);
@@ -115,71 +115,71 @@ void move_construct_tests2(T*, test::random_generator const& generator)
     test::object_count count;
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<T> v(500, generator);
-        T y(create(v, count, hf, eq, al, 0.5));
+      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);
+      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_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_;
+      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);
+      // 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::check_instances check_;
 
-        test::random_values<T> v(25, generator);
-        T y(create(v, count, hf, eq, al, 1.0), al);
+      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);
+      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);
+      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);
+      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);
+      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)
-{
+  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);
@@ -187,188 +187,185 @@ void move_assign_tests2(T*, test::random_generator const& generator)
     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);
+      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));
-        }
+      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::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);
+      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);
-        }
+      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::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::check_instances check_;
 
-        test::random_values<T> v(500, generator);
-        T y(0, hf, eq, al1);
+      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());
+      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::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));
-        }
+      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::check_instances check_;
 
-        test::random_values<T> v1(1000, generator);
-        test::random_values<T> v2(200, generator);
+      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());
+      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;
+      test::object_count count1 = test::global_object_count;
 
-        T y(v1.begin(), v1.end(), 0, hf, eq, al1);
-        y = boost::move(x);
+      T y(v1.begin(), v1.end(), 0, hf, eq, al1);
+      y = boost::move(x);
 
-        test::object_count count2 = test::global_object_count;
+      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);
-        }
+      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);
+      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,
+  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::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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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))(
+      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,
+  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))(
+      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,
+  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))(
+      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,
+  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))(
+      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)))
 }
 
diff --git a/test/unordered/node_handle_tests.cpp b/test/unordered/node_handle_tests.cpp
index 8ac1878e..357801c9 100644
--- a/test/unordered/node_handle_tests.cpp
+++ b/test/unordered/node_handle_tests.cpp
@@ -18,419 +18,418 @@
 
 UNORDERED_AUTO_TEST(example1)
 {
-    typedef boost::unordered_map<int, std::string>::insert_return_type
-        insert_return_type;
+  typedef boost::unordered_map<int, std::string>::insert_return_type
+    insert_return_type;
 
-    boost::unordered_map<int, std::string> src;
-    src.emplace(1, "one");
-    src.emplace(2, "two");
-    src.emplace(3, "buckle my shoe");
-    boost::unordered_map<int, std::string> dst;
-    dst.emplace(3, "three");
+  boost::unordered_map<int, std::string> src;
+  src.emplace(1, "one");
+  src.emplace(2, "two");
+  src.emplace(3, "buckle my shoe");
+  boost::unordered_map<int, std::string> dst;
+  dst.emplace(3, "three");
 
-    dst.insert(src.extract(src.find(1)));
-    dst.insert(src.extract(2));
-    insert_return_type r = dst.insert(src.extract(3));
+  dst.insert(src.extract(src.find(1)));
+  dst.insert(src.extract(2));
+  insert_return_type r = dst.insert(src.extract(3));
 
-    BOOST_TEST(src.empty());
-    BOOST_TEST(dst.size() == 3);
-    BOOST_TEST(dst[1] == "one");
-    BOOST_TEST(dst[2] == "two");
-    BOOST_TEST(dst[3] == "three");
-    BOOST_TEST(!r.inserted);
-    BOOST_TEST(r.position == dst.find(3));
-    BOOST_TEST(r.node.mapped() == "buckle my shoe");
+  BOOST_TEST(src.empty());
+  BOOST_TEST(dst.size() == 3);
+  BOOST_TEST(dst[1] == "one");
+  BOOST_TEST(dst[2] == "two");
+  BOOST_TEST(dst[3] == "three");
+  BOOST_TEST(!r.inserted);
+  BOOST_TEST(r.position == dst.find(3));
+  BOOST_TEST(r.node.mapped() == "buckle my shoe");
 }
 
 UNORDERED_AUTO_TEST(example2)
 {
-    boost::unordered_set<int> src;
-    src.insert(1);
-    src.insert(3);
-    src.insert(5);
-    boost::unordered_set<int> dst;
-    dst.insert(2);
-    dst.insert(4);
-    dst.insert(5);
-    // dst.merge(src);
-    // Merge src into dst.
-    // src == {5}
-    // dst == {1, 2, 3, 4, 5}
+  boost::unordered_set<int> src;
+  src.insert(1);
+  src.insert(3);
+  src.insert(5);
+  boost::unordered_set<int> dst;
+  dst.insert(2);
+  dst.insert(4);
+  dst.insert(5);
+  // dst.merge(src);
+  // Merge src into dst.
+  // src == {5}
+  // dst == {1, 2, 3, 4, 5}
 }
 
 UNORDERED_AUTO_TEST(example3)
 {
-    typedef boost::unordered_set<int>::iterator iterator;
+  typedef boost::unordered_set<int>::iterator iterator;
 
-    boost::unordered_set<int> src;
-    src.insert(1);
-    src.insert(3);
-    src.insert(5);
-    boost::unordered_set<int> dst;
-    dst.insert(2);
-    dst.insert(4);
-    dst.insert(5);
-    for (iterator i = src.begin(); i != src.end();) {
-        std::pair<iterator, iterator> p = dst.equal_range(*i);
-        if (p.first == p.second)
-            dst.insert(p.first, src.extract(i++));
-        else
-            ++i;
-    }
-    BOOST_TEST(src.size() == 1);
-    BOOST_TEST(*src.begin() == 5);
+  boost::unordered_set<int> src;
+  src.insert(1);
+  src.insert(3);
+  src.insert(5);
+  boost::unordered_set<int> dst;
+  dst.insert(2);
+  dst.insert(4);
+  dst.insert(5);
+  for (iterator i = src.begin(); i != src.end();) {
+    std::pair<iterator, iterator> p = dst.equal_range(*i);
+    if (p.first == p.second)
+      dst.insert(p.first, src.extract(i++));
+    else
+      ++i;
+  }
+  BOOST_TEST(src.size() == 1);
+  BOOST_TEST(*src.begin() == 5);
 
-    std::set<int> dst2(dst.begin(), dst.end());
-    std::set<int>::iterator it = dst2.begin();
-    BOOST_TEST(*it++ == 1);
-    BOOST_TEST(*it++ == 2);
-    BOOST_TEST(*it++ == 3);
-    BOOST_TEST(*it++ == 4);
-    BOOST_TEST(*it++ == 5);
-    BOOST_TEST(it == dst2.end());
+  std::set<int> dst2(dst.begin(), dst.end());
+  std::set<int>::iterator it = dst2.begin();
+  BOOST_TEST(*it++ == 1);
+  BOOST_TEST(*it++ == 2);
+  BOOST_TEST(*it++ == 3);
+  BOOST_TEST(*it++ == 4);
+  BOOST_TEST(*it++ == 5);
+  BOOST_TEST(it == dst2.end());
 }
 
 UNORDERED_AUTO_TEST(failed_insertion_with_hint)
 {
-    {
-        boost::unordered_set<int> src;
-        boost::unordered_set<int> dst;
-        src.emplace(10);
-        src.emplace(20);
-        dst.emplace(10);
-        dst.emplace(20);
+  {
+    boost::unordered_set<int> src;
+    boost::unordered_set<int> dst;
+    src.emplace(10);
+    src.emplace(20);
+    dst.emplace(10);
+    dst.emplace(20);
 
-        boost::unordered_set<int>::node_type nh = src.extract(10);
+    boost::unordered_set<int>::node_type nh = src.extract(10);
 
-        BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
-        BOOST_TEST(nh);
-        BOOST_TEST(!nh.empty());
-        BOOST_TEST(nh.value() == 10);
+    BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.value() == 10);
 
-        BOOST_TEST(dst.insert(dst.find(20), boost::move(nh)) == dst.find(10));
-        BOOST_TEST(nh);
-        BOOST_TEST(!nh.empty());
-        BOOST_TEST(nh.value() == 10);
+    BOOST_TEST(dst.insert(dst.find(20), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.value() == 10);
 
-        BOOST_TEST(src.count(10) == 0);
-        BOOST_TEST(src.count(20) == 1);
-        BOOST_TEST(dst.count(10) == 1);
-        BOOST_TEST(dst.count(20) == 1);
-    }
+    BOOST_TEST(src.count(10) == 0);
+    BOOST_TEST(src.count(20) == 1);
+    BOOST_TEST(dst.count(10) == 1);
+    BOOST_TEST(dst.count(20) == 1);
+  }
 
-    {
-        boost::unordered_map<int, int> src;
-        boost::unordered_map<int, int> dst;
-        src.emplace(10, 30);
-        src.emplace(20, 5);
-        dst.emplace(10, 20);
-        dst.emplace(20, 2);
+  {
+    boost::unordered_map<int, int> src;
+    boost::unordered_map<int, int> dst;
+    src.emplace(10, 30);
+    src.emplace(20, 5);
+    dst.emplace(10, 20);
+    dst.emplace(20, 2);
 
-        boost::unordered_map<int, int>::node_type nh = src.extract(10);
-        BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
-        BOOST_TEST(nh);
-        BOOST_TEST(!nh.empty());
-        BOOST_TEST(nh.key() == 10);
-        BOOST_TEST(nh.mapped() == 30);
-        BOOST_TEST(dst[10] == 20);
+    boost::unordered_map<int, int>::node_type nh = src.extract(10);
+    BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.key() == 10);
+    BOOST_TEST(nh.mapped() == 30);
+    BOOST_TEST(dst[10] == 20);
 
-        BOOST_TEST(dst.insert(dst.find(20), boost::move(nh)) == dst.find(10));
-        BOOST_TEST(nh);
-        BOOST_TEST(!nh.empty());
-        BOOST_TEST(nh.key() == 10);
-        BOOST_TEST(nh.mapped() == 30);
-        BOOST_TEST(dst[10] == 20);
+    BOOST_TEST(dst.insert(dst.find(20), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.key() == 10);
+    BOOST_TEST(nh.mapped() == 30);
+    BOOST_TEST(dst[10] == 20);
 
-        BOOST_TEST(src.count(10) == 0);
-        BOOST_TEST(src.count(20) == 1);
-        BOOST_TEST(dst.count(10) == 1);
-        BOOST_TEST(dst.count(20) == 1);
-    }
-}
-
-template <typename NodeHandle>
-bool node_handle_compare(NodeHandle const& nh,
-    BOOST_DEDUCED_TYPENAME NodeHandle::value_type const& x)
-{
-    return x == nh.value();
+    BOOST_TEST(src.count(10) == 0);
+    BOOST_TEST(src.count(20) == 1);
+    BOOST_TEST(dst.count(10) == 1);
+    BOOST_TEST(dst.count(20) == 1);
+  }
 }
 
 template <typename NodeHandle>
 bool node_handle_compare(
-    NodeHandle const& nh,
-    std::pair<BOOST_DEDUCED_TYPENAME NodeHandle::key_type const,
-        BOOST_DEDUCED_TYPENAME NodeHandle::mapped_type> const& x)
+  NodeHandle const& nh, BOOST_DEDUCED_TYPENAME NodeHandle::value_type const& x)
 {
-    return x.first == nh.key() && x.second == nh.mapped();
+  return x == nh.value();
+}
+
+template <typename NodeHandle>
+bool node_handle_compare(
+  NodeHandle const& nh,
+  std::pair<BOOST_DEDUCED_TYPENAME NodeHandle::key_type const,
+    BOOST_DEDUCED_TYPENAME NodeHandle::mapped_type> const& x)
+{
+  return x.first == nh.key() && x.second == nh.mapped();
 }
 
 template <typename Container> void node_handle_tests_impl(Container& c)
 {
-    typedef BOOST_DEDUCED_TYPENAME Container::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container::node_type node_type;
 
-    BOOST_DEDUCED_TYPENAME Container::value_type value = *c.begin();
+  BOOST_DEDUCED_TYPENAME Container::value_type value = *c.begin();
 
-    node_type n1;
-    BOOST_TEST(!n1);
-    BOOST_TEST(n1.empty());
+  node_type n1;
+  BOOST_TEST(!n1);
+  BOOST_TEST(n1.empty());
 
-    node_type n2 = c.extract(c.begin());
-    BOOST_TEST(n2);
-    BOOST_TEST(!n2.empty());
-    node_handle_compare(n2, value);
+  node_type n2 = c.extract(c.begin());
+  BOOST_TEST(n2);
+  BOOST_TEST(!n2.empty());
+  node_handle_compare(n2, value);
 
-    node_type n3 = boost::move(n2);
-    BOOST_TEST(n3);
-    BOOST_TEST(!n2);
-    node_handle_compare(n3, value);
-    // TODO: Check that n2 doesn't have an allocator?
-    //       Maybe by swapping and observing that the allocator is
-    //       swapped rather than moved?
+  node_type n3 = boost::move(n2);
+  BOOST_TEST(n3);
+  BOOST_TEST(!n2);
+  node_handle_compare(n3, value);
+  // TODO: Check that n2 doesn't have an allocator?
+  //       Maybe by swapping and observing that the allocator is
+  //       swapped rather than moved?
 
-    n1 = boost::move(n3);
-    BOOST_TEST(n1);
-    BOOST_TEST(!n3);
-    node_handle_compare(n1, value);
+  n1 = boost::move(n3);
+  BOOST_TEST(n1);
+  BOOST_TEST(!n3);
+  node_handle_compare(n1, value);
 
-    // Self move-assignment empties the node_handle.
-    n1 = boost::move(n1);
-    BOOST_TEST(!n1);
+  // Self move-assignment empties the node_handle.
+  n1 = boost::move(n1);
+  BOOST_TEST(!n1);
 
-    n3 = boost::move(n3);
-    BOOST_TEST(!n3);
+  n3 = boost::move(n3);
+  BOOST_TEST(!n3);
 
-    BOOST_DEDUCED_TYPENAME Container::value_type value1 = *c.begin();
-    n1 = c.extract(c.begin());
-    BOOST_DEDUCED_TYPENAME Container::value_type value2 = *c.begin();
-    n2 = c.extract(c.begin());
-    n3 = node_type();
+  BOOST_DEDUCED_TYPENAME Container::value_type value1 = *c.begin();
+  n1 = c.extract(c.begin());
+  BOOST_DEDUCED_TYPENAME Container::value_type value2 = *c.begin();
+  n2 = c.extract(c.begin());
+  n3 = node_type();
 
-    node_handle_compare(n1, value1);
-    node_handle_compare(n2, value2);
-    n1.swap(n2);
-    BOOST_TEST(n1);
-    BOOST_TEST(n2);
-    node_handle_compare(n1, value2);
-    node_handle_compare(n2, value1);
+  node_handle_compare(n1, value1);
+  node_handle_compare(n2, value2);
+  n1.swap(n2);
+  BOOST_TEST(n1);
+  BOOST_TEST(n2);
+  node_handle_compare(n1, value2);
+  node_handle_compare(n2, value1);
 
-    BOOST_TEST(n1);
-    BOOST_TEST(!n3);
-    n1.swap(n3);
-    BOOST_TEST(!n1);
-    BOOST_TEST(n3);
-    node_handle_compare(n3, value2);
+  BOOST_TEST(n1);
+  BOOST_TEST(!n3);
+  n1.swap(n3);
+  BOOST_TEST(!n1);
+  BOOST_TEST(n3);
+  node_handle_compare(n3, value2);
 
-    BOOST_TEST(!n1);
-    BOOST_TEST(n2);
-    n1.swap(n2);
-    BOOST_TEST(n1);
-    BOOST_TEST(!n2);
-    node_handle_compare(n1, value1);
+  BOOST_TEST(!n1);
+  BOOST_TEST(n2);
+  n1.swap(n2);
+  BOOST_TEST(n1);
+  BOOST_TEST(!n2);
+  node_handle_compare(n1, value1);
 
-    node_type n4;
-    BOOST_TEST(!n2);
-    BOOST_TEST(!n4);
-    n2.swap(n4);
-    BOOST_TEST(!n2);
-    BOOST_TEST(!n4);
+  node_type n4;
+  BOOST_TEST(!n2);
+  BOOST_TEST(!n4);
+  n2.swap(n4);
+  BOOST_TEST(!n2);
+  BOOST_TEST(!n4);
 }
 
 UNORDERED_AUTO_TEST(node_handle_tests)
 {
-    boost::unordered_set<int> x1;
-    x1.emplace(100);
-    x1.emplace(140);
-    x1.emplace(-55);
-    node_handle_tests_impl(x1);
+  boost::unordered_set<int> x1;
+  x1.emplace(100);
+  x1.emplace(140);
+  x1.emplace(-55);
+  node_handle_tests_impl(x1);
 
-    boost::unordered_map<int, std::string> x2;
-    x2.emplace(10, "ten");
-    x2.emplace(-23, "twenty");
-    x2.emplace(-76, "thirty");
-    node_handle_tests_impl(x2);
+  boost::unordered_map<int, std::string> x2;
+  x2.emplace(10, "ten");
+  x2.emplace(-23, "twenty");
+  x2.emplace(-76, "thirty");
+  node_handle_tests_impl(x2);
 }
 
 template <typename Container1, typename Container2>
 void insert_node_handle_unique(Container1& c1, Container2& c2)
 {
-    typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
-    BOOST_STATIC_ASSERT(boost::is_same<node_type,
-        BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
+  typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(boost::is_same<node_type,
+    BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
 
-    typedef BOOST_DEDUCED_TYPENAME Container1::insert_return_type
-        insert_return_type1;
-    typedef BOOST_DEDUCED_TYPENAME Container2::insert_return_type
-        insert_return_type2;
+  typedef BOOST_DEDUCED_TYPENAME Container1::insert_return_type
+    insert_return_type1;
+  typedef BOOST_DEDUCED_TYPENAME Container2::insert_return_type
+    insert_return_type2;
 
-    insert_return_type1 r1 = c1.insert(node_type());
-    insert_return_type2 r2 = c2.insert(node_type());
-    BOOST_TEST(!r1.inserted);
-    BOOST_TEST(!r1.node);
-    BOOST_TEST(r1.position == c1.end());
-    BOOST_TEST(!r2.inserted);
-    BOOST_TEST(!r2.node);
-    BOOST_TEST(r2.position == c2.end());
+  insert_return_type1 r1 = c1.insert(node_type());
+  insert_return_type2 r2 = c2.insert(node_type());
+  BOOST_TEST(!r1.inserted);
+  BOOST_TEST(!r1.node);
+  BOOST_TEST(r1.position == c1.end());
+  BOOST_TEST(!r2.inserted);
+  BOOST_TEST(!r2.node);
+  BOOST_TEST(r2.position == c2.end());
 
-    while (!c1.empty()) {
-        value_type v = *c1.begin();
-        value_type const* v_ptr = boost::addressof(*c1.begin());
-        std::size_t count = c2.count(test::get_key<Container1>(v));
-        insert_return_type2 r = c2.insert(c1.extract(c1.begin()));
-        if (!count) {
-            BOOST_TEST(r.inserted);
-            BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
-            BOOST_TEST(r.position != c2.end());
-            BOOST_TEST(boost::addressof(*r.position) == v_ptr);
-            BOOST_TEST(!r.node);
-        } else {
-            BOOST_TEST(!r.inserted);
-            BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
-            BOOST_TEST(r.position != c2.end());
-            BOOST_TEST(test::get_key<Container2>(*r.position) ==
-                       test::get_key<Container2>(v));
-            BOOST_TEST(r.node);
-            node_handle_compare(r.node, v);
-        }
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::addressof(*c1.begin());
+    std::size_t count = c2.count(test::get_key<Container1>(v));
+    insert_return_type2 r = c2.insert(c1.extract(c1.begin()));
+    if (!count) {
+      BOOST_TEST(r.inserted);
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(boost::addressof(*r.position) == v_ptr);
+      BOOST_TEST(!r.node);
+    } else {
+      BOOST_TEST(!r.inserted);
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(
+        test::get_key<Container2>(*r.position) == test::get_key<Container2>(v));
+      BOOST_TEST(r.node);
+      node_handle_compare(r.node, v);
     }
+  }
 }
 
 template <typename Container1, typename Container2>
 void insert_node_handle_unique2(Container1& c1, Container2& c2)
 {
-    typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
-    BOOST_STATIC_ASSERT(boost::is_same<node_type,
-        BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
+  typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(boost::is_same<node_type,
+    BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
 
-    // typedef BOOST_DEDUCED_TYPENAME Container1::insert_return_type
-    // insert_return_type1;
-    typedef BOOST_DEDUCED_TYPENAME Container2::insert_return_type
-        insert_return_type2;
+  // typedef BOOST_DEDUCED_TYPENAME Container1::insert_return_type
+  // insert_return_type1;
+  typedef BOOST_DEDUCED_TYPENAME Container2::insert_return_type
+    insert_return_type2;
 
-    while (!c1.empty()) {
-        value_type v = *c1.begin();
-        value_type const* v_ptr = boost::addressof(*c1.begin());
-        std::size_t count = c2.count(test::get_key<Container1>(v));
-        insert_return_type2 r =
-            c2.insert(c1.extract(test::get_key<Container1>(v)));
-        if (r.inserted) {
-            BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
-            BOOST_TEST(r.position != c2.end());
-            BOOST_TEST(boost::addressof(*r.position) == v_ptr);
-            BOOST_TEST(!r.node);
-        } else {
-            BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
-            BOOST_TEST(r.position != c2.end());
-            BOOST_TEST(test::get_key<Container2>(*r.position) ==
-                       test::get_key<Container2>(v));
-            BOOST_TEST(r.node);
-            node_handle_compare(r.node, v);
-        }
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::addressof(*c1.begin());
+    std::size_t count = c2.count(test::get_key<Container1>(v));
+    insert_return_type2 r = c2.insert(c1.extract(test::get_key<Container1>(v)));
+    if (r.inserted) {
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(boost::addressof(*r.position) == v_ptr);
+      BOOST_TEST(!r.node);
+    } else {
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(
+        test::get_key<Container2>(*r.position) == test::get_key<Container2>(v));
+      BOOST_TEST(r.node);
+      node_handle_compare(r.node, v);
     }
+  }
 }
 
 template <typename Container1, typename Container2>
 void insert_node_handle_equiv(Container1& c1, Container2& c2)
 {
-    typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
-    typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
-    BOOST_STATIC_ASSERT(boost::is_same<node_type,
-        BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
+  typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(boost::is_same<node_type,
+    BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
 
-    typedef BOOST_DEDUCED_TYPENAME Container1::iterator iterator1;
-    typedef BOOST_DEDUCED_TYPENAME Container2::iterator iterator2;
+  typedef BOOST_DEDUCED_TYPENAME Container1::iterator iterator1;
+  typedef BOOST_DEDUCED_TYPENAME Container2::iterator iterator2;
 
-    iterator1 r1 = c1.insert(node_type());
-    iterator2 r2 = c2.insert(node_type());
-    BOOST_TEST(r1 == c1.end());
-    BOOST_TEST(r2 == c2.end());
+  iterator1 r1 = c1.insert(node_type());
+  iterator2 r2 = c2.insert(node_type());
+  BOOST_TEST(r1 == c1.end());
+  BOOST_TEST(r2 == c2.end());
 
-    while (!c1.empty()) {
-        value_type v = *c1.begin();
-        value_type const* v_ptr = boost::addressof(*c1.begin());
-        std::size_t count = c2.count(test::get_key<Container1>(v));
-        iterator2 r = c2.insert(c1.extract(c1.begin()));
-        BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
-        BOOST_TEST(r != c2.end());
-        BOOST_TEST(boost::addressof(*r) == v_ptr);
-    }
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::addressof(*c1.begin());
+    std::size_t count = c2.count(test::get_key<Container1>(v));
+    iterator2 r = c2.insert(c1.extract(c1.begin()));
+    BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
+    BOOST_TEST(r != c2.end());
+    BOOST_TEST(boost::addressof(*r) == v_ptr);
+  }
 }
 
 struct hash_thing
 {
-    std::size_t operator()(int x) const
-    {
-        return static_cast<std::size_t>(x * 13 + 5);
-    }
+  std::size_t operator()(int x) const
+  {
+    return static_cast<std::size_t>(x * 13 + 5);
+  }
 };
 
 UNORDERED_AUTO_TEST(insert_node_handle_unique_tests)
 {
-    {
-        boost::unordered_set<int> x1;
-        boost::unordered_set<int> x2;
-        x1.emplace(100);
-        x1.emplace(140);
-        x1.emplace(-55);
-        x2.emplace(140);
-        insert_node_handle_unique(x1, x2);
-        BOOST_TEST(x2.size() == 3);
-    }
+  {
+    boost::unordered_set<int> x1;
+    boost::unordered_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
 
-    {
-        boost::unordered_map<int, int, hash_thing> x1;
-        boost::unordered_map<int, int> x2;
-        x1.emplace(67, 50);
-        x1.emplace(23, 45);
-        x1.emplace(18, 19);
-        x2.emplace(23, 50);
-        x2.emplace(12, 49);
-        insert_node_handle_unique(x1, x2);
-        BOOST_TEST(x2.size() == 4);
-    }
+  {
+    boost::unordered_map<int, int, hash_thing> x1;
+    boost::unordered_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
 }
 
 UNORDERED_AUTO_TEST(insert_node_handle_equiv_tests)
 {
-    {
-        boost::unordered_multimap<int, int, hash_thing> x1;
-        boost::unordered_multimap<int, int> x2;
-        x1.emplace(67, 50);
-        x1.emplace(67, 100);
-        x1.emplace(23, 45);
-        x1.emplace(18, 19);
-        x2.emplace(23, 50);
-        x2.emplace(12, 49);
-        insert_node_handle_equiv(x1, x2);
-        BOOST_TEST(x2.size() == 6);
-    }
+  {
+    boost::unordered_multimap<int, int, hash_thing> x1;
+    boost::unordered_multimap<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(67, 100);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_equiv(x1, x2);
+    BOOST_TEST(x2.size() == 6);
+  }
 }
 
 UNORDERED_AUTO_TEST(insert_node_handle_unique_tests2)
 {
-    {
-        boost::unordered_set<int> x1;
-        boost::unordered_set<int> x2;
-        x1.emplace(100);
-        x1.emplace(140);
-        x1.emplace(-55);
-        x2.emplace(140);
-        insert_node_handle_unique2(x1, x2);
-        BOOST_TEST(x2.size() == 3);
-    }
+  {
+    boost::unordered_set<int> x1;
+    boost::unordered_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
 
-    {
-        boost::unordered_map<int, int, hash_thing> x1;
-        boost::unordered_map<int, int> x2;
-        x1.emplace(67, 50);
-        x1.emplace(23, 45);
-        x1.emplace(18, 19);
-        x2.emplace(23, 50);
-        x2.emplace(12, 49);
-        insert_node_handle_unique2(x1, x2);
-        BOOST_TEST(x2.size() == 4);
-    }
+  {
+    boost::unordered_map<int, int, hash_thing> x1;
+    boost::unordered_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/noexcept_tests.cpp b/test/unordered/noexcept_tests.cpp
index d801ae1c..3a82facd 100644
--- a/test/unordered/noexcept_tests.cpp
+++ b/test/unordered/noexcept_tests.cpp
@@ -13,37 +13,37 @@
 #include "../helpers/test.hpp"
 
 namespace noexcept_tests {
-// Test the noexcept is set correctly for the move constructor.
+  // Test the noexcept is set correctly for the move constructor.
 
-struct hash_possible_exception : boost::hash<int>
-{
+  struct hash_possible_exception : boost::hash<int>
+  {
     hash_possible_exception(hash_possible_exception const&) {}
-};
+  };
 
-struct equal_to_possible_exception : std::equal_to<int>
-{
+  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)
-{
+  bool throwing_test_exception = false;
+  void test_throw(char const* name)
+  {
     if (throwing_test_exception) {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Throw exception in: " << name
-                                       << std::endl;
-        throw test_exception();
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Throw exception in: " << name
+                                     << std::endl;
+      throw test_exception();
     }
-}
+  }
 
-class hash_nothrow_move : boost::hash<int>
-{
+  class hash_nothrow_move : boost::hash<int>
+  {
     BOOST_COPYABLE_AND_MOVABLE(hash_nothrow_move)
 
     typedef boost::hash<int> base;
@@ -55,23 +55,23 @@ class hash_nothrow_move : boost::hash<int>
     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;
+      test_throw("Assign");
+      return *this;
     }
     hash_nothrow_move& operator=(BOOST_RV_REF(hash_nothrow_move))
     {
-        test_throw("Move Assign");
-        return *this;
+      test_throw("Move Assign");
+      return *this;
     }
     std::size_t operator()(int x) const
     {
-        test_throw("Operator");
-        return static_cast<base const&>(*this)(x);
+      test_throw("Operator");
+      return static_cast<base const&>(*this)(x);
     }
-};
+  };
 
-class equal_to_nothrow_move : std::equal_to<int>
-{
+  class equal_to_nothrow_move : std::equal_to<int>
+  {
     BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow_move)
 
     typedef std::equal_to<int> base;
@@ -81,31 +81,31 @@ class equal_to_nothrow_move : std::equal_to<int>
     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))
+      BOOST_COPY_ASSIGN_REF(equal_to_nothrow_move))
     {
-        test_throw("Assign");
-        return *this;
+      test_throw("Assign");
+      return *this;
     }
     equal_to_nothrow_move& operator=(BOOST_RV_REF(equal_to_nothrow_move))
     {
-        test_throw("Move Assign");
-        return *this;
+      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);
+      test_throw("Operator");
+      return static_cast<base const&>(*this)(x, y);
     }
-};
+  };
 
-bool have_is_nothrow_move = false;
+  bool have_is_nothrow_move = false;
 
-UNORDERED_AUTO_TEST(check_is_nothrow_move)
-{
+  UNORDERED_AUTO_TEST(check_is_nothrow_move)
+  {
     BOOST_TEST(
-        !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
+      !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
     have_is_nothrow_move =
-        boost::is_nothrow_move_constructible<hash_nothrow_move>::value;
+      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.
@@ -114,58 +114,58 @@ UNORDERED_AUTO_TEST(check_is_nothrow_move)
 // 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_WORKAROUND(BOOST_GCC_VERSION, < 40800)
     BOOST_TEST(have_is_nothrow_move);
 #endif
-}
+  }
 
-UNORDERED_AUTO_TEST(test_noexcept)
-{
+  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> >::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));
-}
+      (!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)
-{
+  UNORDERED_AUTO_TEST(test_no_throw_when_noexcept)
+  {
     typedef boost::unordered_set<int, hash_nothrow_move, equal_to_nothrow_move>
-        throwing_set;
+      throwing_set;
 
     if (have_is_nothrow_move) {
-        BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
+      BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
 
-        throwing_test_exception = false;
+      throwing_test_exception = false;
 
-        throwing_set x1;
-        x1.insert(10);
-        x1.insert(50);
+      throwing_set x1;
+      x1.insert(10);
+      x1.insert(50);
 
-        try {
-            throwing_test_exception = true;
+      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_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;
+      throwing_test_exception = false;
     }
-}
+  }
 }
 
 RUN_TESTS()
diff --git a/test/unordered/rehash_tests.cpp b/test/unordered/rehash_tests.cpp
index ee670ace..21d94b3e 100644
--- a/test/unordered/rehash_tests.cpp
+++ b/test/unordered/rehash_tests.cpp
@@ -18,18 +18,18 @@
 
 namespace rehash_tests {
 
-test::seed_t initialize_seed(2974);
+  test::seed_t initialize_seed(2974);
 
-template <class X>
-bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
-{
+  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() &&
+             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;
 
     x.rehash(10000);
@@ -40,10 +40,11 @@ template <class X> void rehash_empty_test1(X*)
 
     x.rehash(10000000);
     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;
 
@@ -61,10 +62,11 @@ template <class X> void rehash_empty_test2(X*, test::random_generator generator)
     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;
 
@@ -78,10 +80,10 @@ template <class X> void rehash_empty_test3(X*, test::random_generator generator)
     tracker.compare(x);
 
     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());
@@ -104,10 +106,10 @@ template <class X> void rehash_test1(X*, test::random_generator generator)
     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;
 
     x.reserve(10000);
@@ -117,10 +119,10 @@ template <class X> void reserve_empty_test1(X*)
 
     x.reserve(10000000);
     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);
 
@@ -131,98 +133,96 @@ template <class X> void reserve_empty_test2(X*)
 
     x.reserve(10000000);
     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) {
-            test::random_values<X> v(i, generator);
+      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());
+        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.reserve(test::has_unique_keys<X>::value ? i : v.size());
+        X x;
+        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
-            // no iterators to invalidate in the range insert, and it can
-            // rehash.
-            typename test::random_values<X>::iterator it = v.begin();
-            x.insert(*it);
-            ++it;
+        // Insert an element before the range insert, otherwise there are
+        // no iterators to invalidate in the range insert, and it can
+        // rehash.
+        typename test::random_values<X>::iterator it = v.begin();
+        x.insert(*it);
+        ++it;
 
-            std::size_t bucket_count = x.bucket_count();
-            x.insert(it, v.end());
-            BOOST_TEST(bucket_count == x.bucket_count());
-            tracker.compare(x);
-        }
+        std::size_t bucket_count = x.bucket_count();
+        x.insert(it, v.end());
+        BOOST_TEST(bucket_count == x.bucket_count());
+        tracker.compare(x);
+      }
     }
-}
+  }
 
-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) {
-            test::random_values<X> v(i, generator);
+      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());
+        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 x;
+        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());
+        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) {
-                x.insert(*it);
-            }
-
-            BOOST_TEST(bucket_count == x.bucket_count());
-            tracker.compare(x);
+        std::size_t bucket_count = x.bucket_count();
+        for (typename test::random_values<X>::iterator it = v.begin();
+             it != v.end(); ++it) {
+          x.insert(*it);
         }
-    }
-}
 
-boost::unordered_set<int>* int_set_ptr;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+        BOOST_TEST(bucket_count == x.bucket_count());
+        tracker.compare(x);
+      }
+    }
+  }
+
+  boost::unordered_set<int>* int_set_ptr;
+  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;
+  boost::unordered_multimap<int, int>* int_multimap_ptr;
 
-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(rehash_empty_test1,
+  UNORDERED_TEST(rehash_empty_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
-UNORDERED_TEST(rehash_empty_test2,
+  UNORDERED_TEST(rehash_empty_test2,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(rehash_empty_test3,
+  UNORDERED_TEST(rehash_empty_test3,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(rehash_test1,
+  UNORDERED_TEST(rehash_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(reserve_empty_test1,
+  UNORDERED_TEST(reserve_empty_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
-UNORDERED_TEST(reserve_empty_test2,
+  UNORDERED_TEST(reserve_empty_test2,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
-UNORDERED_TEST(reserve_test1,
+  UNORDERED_TEST(reserve_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(reserve_test2,
+  UNORDERED_TEST(reserve_test2,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
 }
diff --git a/test/unordered/simple_tests.cpp b/test/unordered/simple_tests.cpp
index 40ba5fc3..ca99a86f 100644
--- a/test/unordered/simple_tests.cpp
+++ b/test/unordered/simple_tests.cpp
@@ -19,117 +19,117 @@
 
 template <class X> void simple_test(X const& a)
 {
-    test::unordered_equivalence_tester<X> equivalent(a);
+  test::unordered_equivalence_tester<X> equivalent(a);
 
-    {
-        X u;
-        BOOST_TEST(u.size() == 0);
-        BOOST_TEST(X().size() == 0);
-    }
+  {
+    X u;
+    BOOST_TEST(u.size() == 0);
+    BOOST_TEST(X().size() == 0);
+  }
 
-    {
-        BOOST_TEST(equivalent(X(a)));
-    }
+  {
+    BOOST_TEST(equivalent(X(a)));
+  }
 
-    {
-        X u(a);
-        BOOST_TEST(equivalent(u));
-    }
+  {
+    X u(a);
+    BOOST_TEST(equivalent(u));
+  }
 
-    {
-        X u = a;
-        BOOST_TEST(equivalent(u));
-    }
+  {
+    X u = a;
+    BOOST_TEST(equivalent(u));
+  }
 
-    {
-        X b(a);
-        BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin());
-        BOOST_TEST(b.end() == const_cast<X const&>(b).cend());
-    }
+  {
+    X b(a);
+    BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin());
+    BOOST_TEST(b.end() == const_cast<X const&>(b).cend());
+  }
 
-    {
-        X b(a);
-        X c;
-        BOOST_TEST(equivalent(b));
-        BOOST_TEST(c.empty());
-        b.swap(c);
-        BOOST_TEST(b.empty());
-        BOOST_TEST(equivalent(c));
-        b.swap(c);
-        BOOST_TEST(c.empty());
-        BOOST_TEST(equivalent(b));
-    }
+  {
+    X b(a);
+    X c;
+    BOOST_TEST(equivalent(b));
+    BOOST_TEST(c.empty());
+    b.swap(c);
+    BOOST_TEST(b.empty());
+    BOOST_TEST(equivalent(c));
+    b.swap(c);
+    BOOST_TEST(c.empty());
+    BOOST_TEST(equivalent(b));
+  }
 
-    {
-        X u;
-        X& r = u;
-        BOOST_TEST(&(r = r) == &r);
+  {
+    X u;
+    X& r = u;
+    BOOST_TEST(&(r = r) == &r);
 
-        BOOST_TEST(r.empty());
-        BOOST_TEST(&(r = a) == &r);
-        BOOST_TEST(equivalent(r));
-        BOOST_TEST(&(r = r) == &r);
-        BOOST_TEST(equivalent(r));
-    }
+    BOOST_TEST(r.empty());
+    BOOST_TEST(&(r = a) == &r);
+    BOOST_TEST(equivalent(r));
+    BOOST_TEST(&(r = r) == &r);
+    BOOST_TEST(equivalent(r));
+  }
 
-    {
-        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())));
+  }
 
-    {
-        BOOST_TEST(a.empty() == (a.size() == 0));
-    }
+  {
+    BOOST_TEST(a.empty() == (a.size() == 0));
+  }
 
-    {
-        BOOST_TEST(a.empty() == (a.begin() == a.end()));
-        X u;
-        BOOST_TEST(u.begin() == u.end());
-    }
+  {
+    BOOST_TEST(a.empty() == (a.begin() == a.end()));
+    X u;
+    BOOST_TEST(u.begin() == u.end());
+  }
 }
 
 UNORDERED_AUTO_TEST(simple_tests)
 {
-    using namespace std;
-    srand(14878);
+  using namespace std;
+  srand(14878);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
-    boost::unordered_set<int> set;
-    simple_test(set);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  boost::unordered_set<int> set;
+  simple_test(set);
 
-    set.insert(1);
-    set.insert(2);
-    set.insert(1456);
-    simple_test(set);
+  set.insert(1);
+  set.insert(2);
+  set.insert(1456);
+  simple_test(set);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
-    boost::unordered_multiset<int> multiset;
-    simple_test(multiset);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  boost::unordered_multiset<int> multiset;
+  simple_test(multiset);
 
-    for (int i1 = 0; i1 < 1000; ++i1) {
-        int count = rand() % 10, index = rand();
-        for (int j = 0; j < count; ++j)
-            multiset.insert(index);
-    }
-    simple_test(multiset);
+  for (int i1 = 0; i1 < 1000; ++i1) {
+    int count = rand() % 10, index = rand();
+    for (int j = 0; j < count; ++j)
+      multiset.insert(index);
+  }
+  simple_test(multiset);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
-    boost::unordered_map<int, int> map;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  boost::unordered_map<int, int> map;
 
-    for (int i2 = 0; i2 < 1000; ++i2) {
-        map.insert(std::pair<const int, int>(rand(), rand()));
-    }
-    simple_test(map);
+  for (int i2 = 0; i2 < 1000; ++i2) {
+    map.insert(std::pair<const int, int>(rand(), rand()));
+  }
+  simple_test(map);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
-    boost::unordered_multimap<int, int> multimap;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+  boost::unordered_multimap<int, int> multimap;
 
-    for (int i3 = 0; i3 < 1000; ++i3) {
-        int count = rand() % 10, index = rand();
-        for (int j = 0; j < count; ++j)
-            multimap.insert(std::pair<const int, int>(index, rand()));
-    }
-    simple_test(multimap);
+  for (int i3 = 0; i3 < 1000; ++i3) {
+    int count = rand() % 10, index = rand();
+    for (int j = 0; j < count; ++j)
+      multimap.insert(std::pair<const int, int>(index, rand()));
+  }
+  simple_test(multimap);
 }
 
 RUN_TESTS()
diff --git a/test/unordered/swap_tests.cpp b/test/unordered/swap_tests.cpp
index 9c6e4656..ac033743 100644
--- a/test/unordered/swap_tests.cpp
+++ b/test/unordered/swap_tests.cpp
@@ -26,10 +26,10 @@
 
 namespace swap_tests {
 
-test::seed_t initialize_seed(783472);
+  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);
     tracker1.insert_range(x1.begin(), x1.end());
@@ -37,45 +37,45 @@ template <class X> void swap_test_impl(X& x1, X& x2)
     x1.swap(x2);
     tracker1.compare(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_;
+      test::check_instances check_;
 
-        X x;
-        swap_test_impl(x, x);
+      X x;
+      swap_test_impl(x, x);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x, y;
-        swap_test_impl(x, y);
+      X x, y;
+      swap_test_impl(x, y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<X> v(1000, generator);
-        X x, y(v.begin(), v.end());
-        swap_test_impl(x, y);
-        swap_test_impl(x, y);
+      test::random_values<X> v(1000, generator);
+      X x, y(v.begin(), v.end());
+      swap_test_impl(x, y);
+      swap_test_impl(x, y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<X> vx(1000, generator), vy(1000, generator);
-        X x(vx.begin(), vx.end()), y(vy.begin(), vy.end());
-        swap_test_impl(x, y);
-        swap_test_impl(x, y);
+      test::random_values<X> vx(1000, generator), vy(1000, generator);
+      X x(vx.begin(), vx.end()), y(vy.begin(), vy.end());
+      swap_test_impl(x, y);
+      swap_test_impl(x, y);
     }
-}
+  }
 
-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);
 
     typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
@@ -83,134 +83,130 @@ template <class X> void swap_tests2(X* ptr, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        X x(0, hasher(1), key_equal(1));
-        X y(0, hasher(2), key_equal(2));
-        swap_test_impl(x, y);
+      X x(0, hasher(1), key_equal(1));
+      X y(0, hasher(2), key_equal(2));
+      swap_test_impl(x, y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<X> v(1000, generator);
-        X x(v.begin(), v.end(), 0, hasher(1), key_equal(1));
-        X y(0, hasher(2), key_equal(2));
-        swap_test_impl(x, y);
+      test::random_values<X> v(1000, generator);
+      X x(v.begin(), v.end(), 0, hasher(1), key_equal(1));
+      X y(0, hasher(2), key_equal(2));
+      swap_test_impl(x, y);
     }
 
     {
-        test::check_instances check_;
+      test::check_instances check_;
 
-        test::random_values<X> vx(100, generator), vy(50, generator);
-        X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1));
-        X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2));
-        swap_test_impl(x, y);
-        swap_test_impl(x, y);
+      test::random_values<X> vx(100, generator), vy(50, generator);
+      X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1));
+      X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2));
+      swap_test_impl(x, y);
+      swap_test_impl(x, y);
     }
 
     {
-        test::force_equal_allocator force_(
-            !allocator_type::is_propagate_on_swap);
-        test::check_instances check_;
+      test::force_equal_allocator force_(!allocator_type::is_propagate_on_swap);
+      test::check_instances check_;
 
-        test::random_values<X> vx(50, generator), vy(100, generator);
-        X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
-        X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
+      test::random_values<X> vx(50, generator), vy(100, generator);
+      X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
+      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()) {
-            swap_test_impl(x, y);
-        }
+      if (allocator_type::is_propagate_on_swap ||
+          x.get_allocator() == y.get_allocator()) {
+        swap_test_impl(x, y);
+      }
     }
 
     {
-        test::force_equal_allocator force_(
-            !allocator_type::is_propagate_on_swap);
-        test::check_instances check_;
+      test::force_equal_allocator force_(!allocator_type::is_propagate_on_swap);
+      test::check_instances check_;
 
-        test::random_values<X> vx(100, generator), vy(100, generator);
-        X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1),
-            allocator_type(1));
-        X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2),
-            allocator_type(2));
+      test::random_values<X> vx(100, generator), vy(100, generator);
+      X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1), allocator_type(1));
+      X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2), allocator_type(2));
 
-        if (allocator_type::is_propagate_on_swap ||
-            x.get_allocator() == y.get_allocator()) {
-            swap_test_impl(x, y);
-            swap_test_impl(x, y);
-        }
+      if (allocator_type::is_propagate_on_swap ||
+          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,
+  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::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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;
-}
+  }
 
-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_AUTO_TEST(check_traits)
-{
+  UNORDERED_AUTO_TEST(check_traits)
+  {
     BOOST_TEST(!is_propagate(test_set));
     BOOST_TEST(is_propagate(test_set_prop_swap));
     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))(
+  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,
+  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))(
+      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 1e22dd66..27d71762 100644
--- a/test/unordered/unnecessary_copy_tests.cpp
+++ b/test/unordered/unnecessary_copy_tests.cpp
@@ -13,8 +13,8 @@
 #include "../helpers/test.hpp"
 
 namespace unnecessary_copy_tests {
-struct count_copies
-{
+  struct count_copies
+  {
   private:
     BOOST_COPYABLE_AND_MOVABLE(count_copies)
   public:
@@ -24,14 +24,14 @@ struct count_copies
 
     count_copies() : tag_(0), id_(++id_count)
     {
-        ++copies;
-        trace_op("Default construct");
+      ++copies;
+      trace_op("Default construct");
     }
 
     explicit count_copies(int tag) : tag_(tag), id_(++id_count)
     {
-        ++copies;
-        trace_op("Tag construct");
+      ++copies;
+      trace_op("Tag construct");
     }
 
     // This bizarre constructor is an attempt to confuse emplace.
@@ -46,66 +46,66 @@ struct count_copies
     count_copies(count_copies const&, count_copies const& x)
         : tag_(x.tag_), id_(++id_count)
     {
-        ++copies;
-        trace_op("Pair construct");
+      ++copies;
+      trace_op("Pair construct");
     }
 
     count_copies(count_copies const& x) : tag_(x.tag_), id_(++id_count)
     {
-        ++copies;
-        trace_op("Copy construct");
+      ++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");
+      x.tag_ = -1;
+      ++moves;
+      trace_op("Move construct");
     }
 
     count_copies& operator=(
-        BOOST_COPY_ASSIGN_REF(count_copies) p) // Copy assignment
+      BOOST_COPY_ASSIGN_REF(count_copies) p) // Copy assignment
     {
-        tag_ = p.tag_;
-        ++copies;
-        trace_op("Copy assign");
-        return *this;
+      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;
+      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;
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << str << ": " << tag_ << " (#" << id_
+                                     << ")" << std::endl;
     }
 
     int tag_;
     int id_;
-};
+  };
 
-bool operator==(count_copies const& x, count_copies const& y)
-{
+  bool operator==(count_copies const& x, count_copies const& y)
+  {
     return x.tag_ == y.tag_;
-}
+  }
 
-template <class T> T source() { return T(); }
+  template <class T> T source() { return T(); }
 
-void reset()
-{
+  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)
@@ -114,10 +114,10 @@ namespace boost
 namespace unnecessary_copy_tests
 #endif
 {
-std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
-{
+  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,59 +135,57 @@ std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
 #endif
 
 #define COPY_COUNT(n)                                                          \
-    if (::unnecessary_copy_tests::count_copies::copies != n) {                 \
-        BOOST_ERROR("Wrong number of copies.");                                \
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
-            << "Number of copies: "                                            \
-            << ::unnecessary_copy_tests::count_copies::copies                  \
-            << " expecting: " << n << std::endl;                               \
-    }
+  if (::unnecessary_copy_tests::count_copies::copies != n) {                   \
+    BOOST_ERROR("Wrong number of copies.");                                    \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "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.");                                 \
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
-            << "Number of moves: "                                             \
-            << ::unnecessary_copy_tests::count_copies::moves                   \
-            << " expecting: " << n << std::endl;                               \
-    }
+  if (::unnecessary_copy_tests::count_copies::moves != n) {                    \
+    BOOST_ERROR("Wrong number of moves.");                                     \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "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.");                                \
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
-            << "Number of copies: "                                            \
-            << ::unnecessary_copy_tests::count_copies::copies                  \
-            << " expecting: [" << a << ", " << b << "]" << std::endl;          \
-    }
+  if (::unnecessary_copy_tests::count_copies::copies < a ||                    \
+      ::unnecessary_copy_tests::count_copies::copies > b) {                    \
+    BOOST_ERROR("Wrong number of copies.");                                    \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "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.");                                 \
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
-            << "Number of moves: "                                             \
-            << ::unnecessary_copy_tests::count_copies::moves                   \
-            << " expecting: [" << a << ", " << b << "]" << std::endl;          \
-    }
+  if (::unnecessary_copy_tests::count_copies::moves < a ||                     \
+      ::unnecessary_copy_tests::count_copies::moves > b) {                     \
+    BOOST_ERROR("Wrong number of moves.");                                     \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "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)
 
 namespace unnecessary_copy_tests {
-int count_copies::copies;
-int count_copies::moves;
-int count_copies::id_count;
+  int count_copies::copies;
+  int count_copies::moves;
+  int count_copies::id_count;
 
-template <class T> void unnecessary_copy_insert_test(T*)
-{
+  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);
     MOVE_COUNT(0);
-}
+  }
 
-template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
-{
+  template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
+  {
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
     reset();
@@ -200,10 +198,10 @@ template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
     x.insert(boost::move(a));
     COPY_COUNT(0);
     MOVE_COUNT((x.size() == 2 ? 1 : 0));
-}
+  }
 
-template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
-{
+  template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
+  {
     // Doesn't currently try to emulate std::pair move construction,
     // so std::pair's require a copy. Could try emulating it in
     // construct_from_args.
@@ -230,29 +228,29 @@ template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
     COPY_COUNT(0);
     MOVE_COUNT((x.size() == 2 ? 1 : 0));
 #endif
-}
+  }
 
-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_rvalue_set_test, ((set)(multiset)))
-UNORDERED_TEST(unnecessary_copy_insert_rvalue_map_test, ((map)(multimap)))
+  UNORDERED_TEST(unnecessary_copy_insert_test, ((set)(multiset)(map)(multimap)))
+  UNORDERED_TEST(unnecessary_copy_insert_rvalue_set_test, ((set)(multiset)))
+  UNORDERED_TEST(unnecessary_copy_insert_rvalue_map_test, ((map)(multimap)))
 
-template <class T> void unnecessary_copy_emplace_test(T*)
-{
+  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*)
-{
+  template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
+  {
     reset();
     T x;
     x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
@@ -261,15 +259,16 @@ template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
 #else
     COPY_COUNT(2);
 #endif
-}
+  }
 
-UNORDERED_TEST(unnecessary_copy_emplace_test, ((set)(multiset)(map)(multimap)))
-UNORDERED_TEST(
+  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*)
-{
+  template <class T> void unnecessary_copy_emplace_std_move_test(T*)
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
@@ -278,14 +277,14 @@ template <class T> void unnecessary_copy_emplace_std_move_test(T*)
     x.emplace(std::move(a));
     COPY_COUNT(1);
     MOVE_COUNT(1);
-}
+  }
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     unnecessary_copy_emplace_std_move_test, ((set)(multiset)(map)(multimap)))
 #endif
 
-template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
-{
+  template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
@@ -300,13 +299,13 @@ template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
     COPY_COUNT_RANGE(1, 2);
     MOVE_COUNT_RANGE(0, 1);
 #endif
-}
+  }
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     unnecessary_copy_emplace_boost_move_test, ((set)(multiset)(map)(multimap)))
 
-template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
-{
+  template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
@@ -315,12 +314,13 @@ template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
     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*)
-{
+  template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
+  {
     reset();
     T x;
     COPY_COUNT(0);
@@ -336,12 +336,13 @@ template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
     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)
-{
+  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.
 
@@ -422,10 +423,10 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
     x.emplace(b, b);
     COPY_COUNT(1);
     MOVE_COUNT(0);
-}
+  }
 
-UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
-{
+  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.
 
@@ -471,7 +472,7 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
 
     reset();
     x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
-        boost::make_tuple());
+      boost::make_tuple());
     COPY_COUNT(2);
     MOVE_COUNT(0);
 
@@ -492,7 +493,7 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
     MOVE_COUNT(source_pair_cost);
 
 #if !(defined(__GNUC__) && __cplusplus < 199900L) &&                           \
-    !(defined(_MSC_VER) && _MSC_VER < 1600)
+  !(defined(_MSC_VER) && _MSC_VER < 1600)
     count_copies part;
     reset();
     std::pair<count_copies const&, count_copies const&> a_ref(part, part);
@@ -538,8 +539,8 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
 
     reset();
     x.emplace(boost::unordered::piecewise_construct,
-        boost::make_tuple(boost::ref(b.first)),
-        boost::make_tuple(boost::ref(b.second)));
+      boost::make_tuple(boost::ref(b.first)),
+      boost::make_tuple(boost::ref(b.second)));
     COPY_COUNT(0);
     MOVE_COUNT(0);
 
@@ -547,8 +548,7 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
 
     reset();
     x.emplace(boost::unordered::piecewise_construct,
-        std::make_tuple(std::ref(b.first)),
-        std::make_tuple(std::ref(b.second)));
+      std::make_tuple(std::ref(b.first)), std::make_tuple(std::ref(b.second)));
     COPY_COUNT(0);
     MOVE_COUNT(0);
 
@@ -562,23 +562,23 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
     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)));
+      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) &&             \
-    !(defined(BOOST_MSVC) && BOOST_MSVC < 1700)
+  !(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));
+      std::forward_as_tuple(b.first), std::forward_as_tuple(b.second));
     COPY_COUNT(0);
     MOVE_COUNT(0);
 #endif
 
 #endif
-}
+  }
 }
 
 RUN_TESTS()